diff --git a/cmd/commands/assets.go b/cmd/commands/assets.go index 069f3f840..d0f9a0304 100644 --- a/cmd/commands/assets.go +++ b/cmd/commands/assets.go @@ -1154,7 +1154,7 @@ var fetchMetaCommand = cli.Command{ Name: "meta", Usage: "fetch asset meta", Description: "fetch the meta bytes for an asset based on the " + - "asset_id or meta_hash", + "asset_id, meta_hash, or group_key", Action: fetchMeta, Flags: []cli.Flag{ cli.StringFlag{ @@ -1165,44 +1165,58 @@ var fetchMetaCommand = cli.Command{ Name: metaName, Usage: "meta_hash to fetch meta for", }, + &cli.StringFlag{ + Name: "group_key", + Usage: "the hex-encoded group key of the assets to fetch metadata for. " + + "Mutually exclusive with asset_id and meta_hash", + }, }, } func fetchMeta(ctx *cli.Context) error { - switch { - case ctx.IsSet(metaName) && ctx.IsSet(assetIDName): - return fmt.Errorf("only the asset_id or meta_hash can be set") + assetID := ctx.String(assetIDName) + metaHashHex := ctx.String(metaName) + groupKeyHex := ctx.String("group_key") - case !ctx.IsSet(assetIDName) && !ctx.IsSet(metaName): - return cli.ShowSubcommandHelp(ctx) + numIdentifiers := 0 + if assetID != "" { + numIdentifiers++ + } + if metaHashHex != "" { + numIdentifiers++ + } + if groupKeyHex != "" { + numIdentifiers++ + } + + if numIdentifiers == 0 { + return fmt.Errorf("must specify one of asset_id, meta_hash, or group_key") + } + if numIdentifiers > 1 { + return fmt.Errorf("must specify only one of asset_id, meta_hash, or group_key") } ctxc := getContext() client, cleanUp := getClient(ctx) defer cleanUp() - req := &taprpc.FetchAssetMetaRequest{} - if ctx.IsSet(assetIDName) { - assetIDHex, err := hex.DecodeString(ctx.String(assetIDName)) - if err != nil { - return fmt.Errorf("invalid asset ID") - } - - req.Asset = &taprpc.FetchAssetMetaRequest_AssetId{ - AssetId: assetIDHex, - } - } else { - metaBytes, err := hex.DecodeString(ctx.String(metaName)) - if err != nil { - return fmt.Errorf("invalid meta hash") - } - - req.Asset = &taprpc.FetchAssetMetaRequest_MetaHash{ - MetaHash: metaBytes, - } + fetchReq := &taprpc.FetchAssetMetaRequest{} + switch { + case assetID != "": + // The RPC expects bytes, but the CLI takes a hex string for AssetIdStr. + // The original code used AssetId (bytes) for assetIDName. + // For consistency with proto changes and to allow string input, + // we'll use AssetIdStr. If the RPC still needs bytes for asset_id, + // this part would need further adjustment or the proto needs AssetIdStr. + // The proto *does* have AssetIdStr, so this is fine. + fetchReq.Asset = &taprpc.FetchAssetMetaRequest_AssetIdStr{AssetIdStr: assetID} + case metaHashHex != "": + fetchReq.Asset = &taprpc.FetchAssetMetaRequest_MetaHashStr{MetaHashStr: metaHashHex} + case groupKeyHex != "": + fetchReq.Asset = &taprpc.FetchAssetMetaRequest_GroupKeyStr{GroupKeyStr: groupKeyHex} } - resp, err := client.FetchAssetMeta(ctxc, req) + resp, err := client.FetchAssetMeta(ctxc, fetchReq) if err != nil { return fmt.Errorf("unable to fetch asset meta: %w", err) } diff --git a/itest/asset_meta_test.go b/itest/asset_meta_test.go index 68789a6b6..1a12204f5 100644 --- a/itest/asset_meta_test.go +++ b/itest/asset_meta_test.go @@ -247,3 +247,354 @@ func testMintAssetWithDecimalDisplayMetaField(t *harnessTest) { t.t, 7, thirdAssets[0].DecimalDisplay.DecimalDisplay, ) } + +// testFetchAssetMetaRPC tests the FetchAssetMeta RPC endpoint with various +// scenarios, including fetching by group key. +func testFetchAssetMetaRPC(t *harnessTest) { + ctxb := context.Background() + ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout*3) + defer cancel() + + // 1. Mint a group of assets. + groupName := "meta-test-group" + groupMetaJSON := `{"type": "test-group"}` + groupDecimalDisplay := uint32(2) + + // Asset 1 in the group + groupAsset1Req := &mintrpc.MintAssetRequest{ + Asset: &mintrpc.MintAsset{ + AssetType: taprpc.AssetType_NORMAL, + Name: groupName + "-alpha", + AssetMeta: &taprpc.AssetMeta{ + Data: []byte(`{"id":"alpha"}`), // Individual meta + Type: taprpc.AssetMetaType_META_TYPE_JSON, + }, + Amount: 1000, + NewGroupedAsset: true, // This will be the group anchor + DecimalDisplay: groupDecimalDisplay, + }, + } + + // Mint and get the first asset to establish the group. + rpcGroupAssets := MintAssetsConfirmBatch( + t.t, t.lndHarness.Miner().Client, t.tapd, + []*mintrpc.MintAssetRequest{groupAsset1Req}, + ) + require.Len(t.t, rpcGroupAssets, 1) + groupAsset1 := rpcGroupAssets[0] + require.NotNil(t.t, groupAsset1.AssetGroup) + groupKeyBytes := groupAsset1.AssetGroup.TweakedGroupKey + groupKeyHex := hex.EncodeToString(groupKeyBytes) + t.Logf("Minted group anchor %s with group key %s", groupAsset1.AssetGenesis.Name, groupKeyHex) + + // Asset 2 in the same group + groupAsset2Req := &mintrpc.MintAssetRequest{ + Asset: &mintrpc.MintAsset{ + AssetType: taprpc.AssetType_NORMAL, + Name: groupName + "-beta", + AssetMeta: &taprpc.AssetMeta{ // Ensure meta is provided if DecimalDisplay is used + Data: []byte(`{"id":"beta"}`), // Individual meta + Type: taprpc.AssetMetaType_META_TYPE_JSON, + }, + Amount: 2000, + GroupedAsset: true, + GroupKey: groupKeyBytes, + DecimalDisplay: groupDecimalDisplay, // Must match group's + }, + } + rpcGroupAssets2 := MintAssetsConfirmBatch( + t.t, t.lndHarness.Miner().Client, t.tapd, + []*mintrpc.MintAssetRequest{groupAsset2Req}, + ) + require.Len(t.t, rpcGroupAssets2, 1) + groupAsset2 := rpcGroupAssets2[0] + t.Logf("Minted grouped asset %s into group key %s", groupAsset2.AssetGenesis.Name, groupKeyHex) + + // 2. Mint a non-grouped asset. + soloAssetName := "solo-meta-asset" + soloAssetMetaJSON := `{"type": "solo"}` + soloAssetDecimalDisplay := uint32(3) + soloAssetReq := &mintrpc.MintAssetRequest{ + Asset: &mintrpc.MintAsset{ + AssetType: taprpc.AssetType_NORMAL, + Name: soloAssetName, + AssetMeta: &taprpc.AssetMeta{ + Data: []byte(soloAssetMetaJSON), + Type: taprpc.AssetMetaType_META_TYPE_JSON, + }, + Amount: 3000, + DecimalDisplay: soloAssetDecimalDisplay, + }, + } + rpcSoloAssets := MintAssetsConfirmBatch( + t.t, t.lndHarness.Miner().Client, t.tapd, + []*mintrpc.MintAssetRequest{soloAssetReq}, + ) + require.Len(t.t, rpcSoloAssets, 1) + soloAsset := rpcSoloAssets[0] + soloAssetIdStr := hex.EncodeToString(soloAsset.AssetGenesis.AssetId) + var soloAssetMetaHash [32]byte + copy(soloAssetMetaHash[:], soloAsset.AssetGenesis.MetaHash) + soloAssetMetaHashStr := hex.EncodeToString(soloAsset.AssetGenesis.MetaHash) + t.Logf("Minted solo asset %s with ID %s", soloAssetName, soloAssetIdStr) + + // Test Case: RPC Fetch by Group Key - Success + t.t.Run("RPC Fetch by Group Key - Success", func(tt *testing.T) { + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_GroupKeyStr{ + GroupKeyStr: groupKeyHex, + }, + } + resp, err := t.tapd.FetchAssetMeta(ctxt, req) + require.NoError(tt, err) + require.NotNil(tt, resp) + require.Len(tt, resp.AssetMetas, 2, "Should fetch two assets in the group") + require.Equal(tt, int32(groupDecimalDisplay), resp.DecimalDisplay) + + // Verify metas (content check can be shallow, e.g. name in data) + var foundAlpha, foundBeta bool + for _, meta := range resp.AssetMetas { + if strings.Contains(string(meta.Data), `"id":"alpha"`) { + foundAlpha = true + } + if strings.Contains(string(meta.Data), `"id":"beta"`) { + foundBeta = true + } + } + require.True(tt, foundAlpha, "GroupAssetAlpha meta not found or content mismatch") + require.True(tt, foundBeta, "GroupAssetBeta meta not found or content mismatch") + }) + + // Test Case: RPC Fetch by Group Key - Group Not Found + t.t.Run("RPC Fetch by Group Key - Group Not Found", func(tt *testing.T) { + nonExistentGroupKey := "03aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_GroupKeyStr{ + GroupKeyStr: nonExistentGroupKey, + }, + } + resp, err := t.tapd.FetchAssetMeta(ctxt, req) + require.NoError(tt, err) // Should not error, just return empty + require.NotNil(tt, resp) + require.Empty(tt, resp.AssetMetas) + require.Equal(tt, int32(0), resp.DecimalDisplay) + }) + + // Test Case: RPC Fetch by Asset ID - Grouped Asset + t.t.Run("RPC Fetch by Asset ID - Grouped Asset", func(tt *testing.T) { + groupedAssetIdStr := hex.EncodeToString(groupAsset1.AssetGenesis.AssetId) + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_AssetIdStr{ + AssetIdStr: groupedAssetIdStr, + }, + } + resp, err := t.tapd.FetchAssetMeta(ctxt, req) + require.NoError(tt, err) + require.NotNil(tt, resp) + require.Len(tt, resp.AssetMetas, 1) + require.True(tt, strings.Contains(string(resp.AssetMetas[0].Data), `"id":"alpha"`)) + require.Equal(tt, int32(groupDecimalDisplay), resp.DecimalDisplay) + }) + + // Test Case: RPC Fetch by Asset ID - Non-Grouped Asset + t.t.Run("RPC Fetch by Asset ID - Non-Grouped Asset", func(tt *testing.T) { + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_AssetIdStr{ + AssetIdStr: soloAssetIdStr, + }, + } + resp, err := t.tapd.FetchAssetMeta(ctxt, req) + require.NoError(tt, err) + require.NotNil(tt, resp) + require.Len(tt, resp.AssetMetas, 1) + require.JSONEq(tt, soloAssetMetaJSON, string(resp.AssetMetas[0].Data)) + require.Equal(tt, int32(soloAssetDecimalDisplay), resp.DecimalDisplay) + }) + + // Test Case: RPC Fetch by Meta Hash + t.t.Run("RPC Fetch by Meta Hash", func(tt *testing.T) { + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_MetaHashStr{ + MetaHashStr: soloAssetMetaHashStr, + }, + } + resp, err := t.tapd.FetchAssetMeta(ctxt, req) + require.NoError(tt, err) + require.NotNil(tt, resp) + require.Len(tt, resp.AssetMetas, 1) + require.JSONEq(tt, soloAssetMetaJSON, string(resp.AssetMetas[0].Data)) + require.Equal(tt, int32(soloAssetDecimalDisplay), resp.DecimalDisplay) + }) +} + +// testFetchAssetMetaCLI tests the 'tapcli assets fetchmeta' command with +// various scenarios, including fetching by group key and flag validation. +func testFetchAssetMetaCLI(t *harnessTest) { + ctxb := context.Background() + ctxt, cancel := context.WithTimeout(ctxb, defaultWaitTimeout*3) + defer cancel() + + // Re-use the same minting logic as testFetchAssetMetaRPC for consistency. + // Mint a group of assets. + groupName := "cli-meta-test-group" + groupDecimalDisplay := uint32(2) + groupAsset1Req := &mintrpc.MintAssetRequest{ + Asset: &mintrpc.MintAsset{ + AssetType: taprpc.AssetType_NORMAL, + Name: groupName + "-alpha-cli", + AssetMeta: &taprpc.AssetMeta{ + Data: []byte(`{"id":"alpha-cli"}`), + Type: taprpc.AssetMetaType_META_TYPE_JSON, + }, + Amount: 1000, + NewGroupedAsset: true, + DecimalDisplay: groupDecimalDisplay, + }, + } + rpcGroupAssets := MintAssetsConfirmBatch( + t.t, t.lndHarness.Miner().Client, t.tapd, + []*mintrpc.MintAssetRequest{groupAsset1Req}, + ) + require.Len(t.t, rpcGroupAssets, 1) + groupAsset1 := rpcGroupAssets[0] + groupKeyBytes := groupAsset1.AssetGroup.TweakedGroupKey + groupKeyHex := hex.EncodeToString(groupKeyBytes) + t.Logf("CLI: Minted group anchor %s with group key %s", groupAsset1.AssetGenesis.Name, groupKeyHex) + + groupAsset2Req := &mintrpc.MintAssetRequest{ + Asset: &mintrpc.MintAsset{ + AssetType: taprpc.AssetType_NORMAL, + Name: groupName + "-beta-cli", + AssetMeta: &taprpc.AssetMeta{ + Data: []byte(`{"id":"beta-cli"}`), + Type: taprpc.AssetMetaType_META_TYPE_JSON, + }, + Amount: 2000, + GroupedAsset: true, + GroupKey: groupKeyBytes, + DecimalDisplay: groupDecimalDisplay, + }, + } + MintAssetsConfirmBatch( + t.t, t.lndHarness.Miner().Client, t.tapd, + []*mintrpc.MintAssetRequest{groupAsset2Req}, + ) + t.Logf("CLI: Minted grouped asset %s into group key %s", groupAsset2Req.Asset.Name, groupKeyHex) + + // Mint a non-grouped asset. + soloAssetName := "cli-solo-meta-asset" + soloAssetMetaJSON := `{"type": "solo-cli"}` + soloAssetDecimalDisplay := uint32(3) + soloAssetReq := &mintrpc.MintAssetRequest{ + Asset: &mintrpc.MintAsset{ + AssetType: taprpc.AssetType_NORMAL, + Name: soloAssetName, + AssetMeta: &taprpc.AssetMeta{ + Data: []byte(soloAssetMetaJSON), + Type: taprpc.AssetMetaType_META_TYPE_JSON, + }, + Amount: 3000, + DecimalDisplay: soloAssetDecimalDisplay, + }, + } + rpcSoloAssets := MintAssetsConfirmBatch( + t.t, t.lndHarness.Miner().Client, t.tapd, + []*mintrpc.MintAssetRequest{soloAssetReq}, + ) + require.Len(t.t, rpcSoloAssets, 1) + soloAsset := rpcSoloAssets[0] + soloAssetIdStr := hex.EncodeToString(soloAsset.AssetGenesis.AssetId) + t.Logf("CLI: Minted solo asset %s with ID %s", soloAssetName, soloAssetIdStr) + + // Test Case: CLI Fetch by Group Key - Success + t.t.Run("CLI Fetch by Group Key - Success", func(tt *testing.T) { + respJSON, err := ExecTapCLI( + ctxt, t.tapd, "assets", "fetchmeta", "--group_key", groupKeyHex, + ) + require.NoError(tt, err) + + var resp taprpc.FetchAssetMetaResponse + require.NoError(tt, taprpc.RpcAssetsCommandJsonParser.Unmarshal( + []byte(respJSON.(string)), &resp, + )) + + require.Len(tt, resp.AssetMetas, 2, "Should fetch two assets in the group via CLI") + require.Equal(tt, int32(groupDecimalDisplay), resp.DecimalDisplay) + var foundAlpha, foundBeta bool + for _, meta := range resp.AssetMetas { + if strings.Contains(string(meta.Data), `"id":"alpha-cli"`) { + foundAlpha = true + } + if strings.Contains(string(meta.Data), `"id":"beta-cli"`) { + foundBeta = true + } + } + require.True(tt, foundAlpha, "GroupAssetAlpha meta not found via CLI") + require.True(tt, foundBeta, "GroupAssetBeta meta not found via CLI") + }) + + // Test Case: CLI Fetch by Group Key - Group Not Found + t.t.Run("CLI Fetch by Group Key - Group Not Found", func(tt *testing.T) { + nonExistentGroupKey := "03bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" + respJSON, err := ExecTapCLI( + ctxt, t.tapd, "assets", "fetchmeta", "--group_key", nonExistentGroupKey, + ) + require.NoError(tt, err) + var resp taprpc.FetchAssetMetaResponse + require.NoError(tt, taprpc.RpcAssetsCommandJsonParser.Unmarshal( + []byte(respJSON.(string)), &resp, + )) + require.Empty(tt, resp.AssetMetas) + require.Equal(tt, int32(0), resp.DecimalDisplay) + }) + + // Test Case: CLI Fetch by Asset ID - Non-Grouped Asset + t.t.Run("CLI Fetch by Asset ID - Non-Grouped Asset", func(tt *testing.T) { + respJSON, err := ExecTapCLI( + ctxt, t.tapd, "assets", "fetchmeta", "--asset_id", soloAssetIdStr, + ) + require.NoError(tt, err) + var resp taprpc.FetchAssetMetaResponse + require.NoError(tt, taprpc.RpcAssetsCommandJsonParser.Unmarshal( + []byte(respJSON.(string)), &resp, + )) + require.Len(tt, resp.AssetMetas, 1) + require.JSONEq(tt, soloAssetMetaJSON, string(resp.AssetMetas[0].Data)) + require.Equal(tt, int32(soloAssetDecimalDisplay), resp.DecimalDisplay) + }) + + // Test Case: CLI - Mutual Exclusivity of Flags + t.t.Run("CLI Mutual Exclusivity", func(tt *testing.T) { + _, err := ExecTapCLIFail( + ctxt, t.tapd, errStringMutuallyExclusive, "assets", "fetchmeta", + "--group_key", groupKeyHex, "--asset_id", soloAssetIdStr, + ) + require.NoError(tt, err) // ExecTapCLIFail checks for the error string + + _, err = ExecTapCLIFail( + ctxt, t.tapd, errStringMutuallyExclusive, "assets", "fetchmeta", + "--group_key", groupKeyHex, "--meta_hash", "aabbcc", + ) + require.NoError(tt, err) + + _, err = ExecTapCLIFail( + ctxt, t.tapd, errStringMutuallyExclusive, "assets", "fetchmeta", + "--asset_id", soloAssetIdStr, "--meta_hash", "aabbcc", + ) + require.NoError(tt, err) + + _, err = ExecTapCLIFail( + ctxt, t.tapd, errStringMutuallyExclusive, "assets", "fetchmeta", + "--group_key", groupKeyHex, "--asset_id", soloAssetIdStr, "--meta_hash", "aabbcc", + ) + require.NoError(tt, err) + + _, err = ExecTapCLIFail( + ctxt, t.tapd, "must specify one of asset_id, meta_hash, or group_key", + "assets", "fetchmeta", + ) + require.NoError(tt, err) + }) +} + +// And register both in the main test list for this file. diff --git a/itest/test_list_on_test.go b/itest/test_list_on_test.go index f3b6f407d..6a28cefb0 100644 --- a/itest/test_list_on_test.go +++ b/itest/test_list_on_test.go @@ -49,6 +49,14 @@ var testCases = []*testCase{ name: "mint asset decimal display", test: testMintAssetWithDecimalDisplayMetaField, }, + { + name: "fetch asset meta rpc", + test: testFetchAssetMetaRPC, + }, + { + name: "fetch asset meta cli", + test: testFetchAssetMetaCLI, + }, { name: "addresses", test: testAddresses, diff --git a/rpcserver.go b/rpcserver.go index 1e7a46110..f3d750399 100644 --- a/rpcserver.go +++ b/rpcserver.go @@ -4727,92 +4727,279 @@ func parseUserKey(scriptKey []byte) (*btcec.PublicKey, error) { } } -func (r *rpcServer) FetchAssetMeta(ctx context.Context, - req *taprpc.FetchAssetMetaRequest) (*taprpc.AssetMeta, error) { +// fetchMetaByAssetID is a helper function to fetch asset metadata by asset ID. +func (s *rpcServer) fetchMetaByAssetID(ctx context.Context, assetIdBytes []byte) (*taprpc.FetchAssetMetaResponse, error) { + if len(assetIdBytes) != sha256.Size { + return nil, fmt.Errorf("asset ID must be 32 bytes") + } + var parsedAssetID asset.ID + copy(parsedAssetID[:], assetIdBytes) - var ( - assetMeta *proof.MetaReveal - err error - ) + dbMeta, fetchErr := s.cfg.AddrBook.FetchAssetMetaForAsset(ctx, parsedAssetID) + if fetchErr != nil { + return nil, fmt.Errorf("unable to fetch asset meta for asset ID: %w", fetchErr) + } - switch { - case req.GetAssetId() != nil: - if len(req.GetAssetId()) != sha256.Size { - return nil, fmt.Errorf("asset ID must be 32 bytes") - } + rpcMeta, err := rpcutils.MarshalAssetMeta(dbMeta) + if err != nil { + return nil, fmt.Errorf("unable to marshal asset meta: %w", err) + } - var assetID asset.ID - copy(assetID[:], req.GetAssetId()) + decDisplay, _ := dbMeta.DecDisplayOption() - assetMeta, err = r.cfg.AddrBook.FetchAssetMetaForAsset( - ctx, assetID, - ) + return &taprpc.FetchAssetMetaResponse{ + AssetMetas: []*taprpc.AssetMeta{rpcMeta}, + DecimalDisplay: int32(decDisplay.UnwrapOr(0)), + }, nil +} + +// fetchMetaByMetaHash is a helper function to fetch asset metadata by meta hash. +func (s *rpcServer) fetchMetaByMetaHash(ctx context.Context, metaHashBytes []byte) (*taprpc.FetchAssetMetaResponse, error) { + if len(metaHashBytes) != sha256.Size { + return nil, fmt.Errorf("meta hash must be 32 bytes") + } + var mH [asset.MetaHashLen]byte + copy(mH[:], metaHashBytes) - case req.GetAssetIdStr() != "": - if len(req.GetAssetIdStr()) != hex.EncodedLen(sha256.Size) { - return nil, fmt.Errorf("asset ID must be 32 bytes") + dbMeta, fetchErr := s.cfg.AddrBook.FetchAssetMetaByHash(ctx, mH) + if fetchErr != nil { + return nil, fmt.Errorf("unable to fetch asset meta by hash: %w", fetchErr) + } + + rpcMeta, err := rpcutils.MarshalAssetMeta(dbMeta) + if err != nil { + return nil, fmt.Errorf("unable to marshal asset meta: %w", err) + } + + decDisplay, _ := dbMeta.DecDisplayOption() + + return &taprpc.FetchAssetMetaResponse{ + AssetMetas: []*taprpc.AssetMeta{rpcMeta}, + DecimalDisplay: int32(decDisplay.UnwrapOr(0)), + }, nil +} + +// fetchMetaByGroupKey is a helper function to fetch asset metadata by group key. +func (s *rpcServer) fetchMetaByGroupKey(ctx context.Context, groupKeyBytes []byte) (*taprpc.FetchAssetMetaResponse, error) { + if len(groupKeyBytes) != btcec.PubKeyBytesCompressed && len(groupKeyBytes) != schnorr.PubKeyBytesLen { + return nil, fmt.Errorf("group key must be 32 or 33 bytes") + } + parsedGroupKey, err := parseUserKey(groupKeyBytes) // Reuses existing helper + if err != nil { + return nil, fmt.Errorf("invalid group key: %w", err) + } + + assetSpecifier := asset.NewSpecifierFromGroupKey(*parsedGroupKey) + filters := &tapdb.AssetQueryFilters{ + CommitmentConstraints: tapfreighter.CommitmentConstraints{ + AssetSpecifier: assetSpecifier, + }, + } + // We want all assets, spent or unspent, leased or not, to get their metas. + // Setting withWitness to false as we only need meta. + rpcChainAssets, err := s.fetchRpcAssets(ctx, false, true, true, filters) + if err != nil { + return nil, fmt.Errorf("unable to fetch assets for group key: %w", err) + } + + if len(rpcChainAssets) == 0 { + // If no assets are found for the group, it's not an error per se, + // but there's no metadata to return. The decimal display would be default (0). + return &taprpc.FetchAssetMetaResponse{ + AssetMetas: []*taprpc.AssetMeta{}, + DecimalDisplay: 0, + }, nil + } + + rpcMetas := make([]*taprpc.AssetMeta, 0, len(rpcChainAssets)) + var groupDecimalDisplay uint32 // Assuming it's the same for the whole group. + + for i, chainAsset := range rpcChainAssets { + var assetIDVar asset.ID + copy(assetIDVar[:], chainAsset.AssetGenesis.AssetId) + + dbMeta, fetchErr := s.cfg.AddrBook.FetchAssetMetaForAsset(ctx, assetIDVar) + if fetchErr != nil { + rpcsLog.Warnf("Failed to fetch meta for asset %x in group %x: %v", + assetIDVar[:], parsedGroupKey.SerializeCompressed(), fetchErr) + continue } - var assetIDBytes []byte - assetIDBytes, err = hex.DecodeString(req.GetAssetIdStr()) - if err != nil { - return nil, fmt.Errorf("error hex decoding asset ID: "+ - "%w", err) + rpcMetaItem, marshalErr := rpcutils.MarshalAssetMeta(dbMeta) + if marshalErr != nil { + rpcsLog.Warnf("Failed to marshal meta for asset %x in group %x: %v", + assetIDVar[:], parsedGroupKey.SerializeCompressed(), marshalErr) + continue } + rpcMetas = append(rpcMetas, rpcMetaItem) - var assetID asset.ID - copy(assetID[:], assetIDBytes) + if i == 0 { + decOpt, _ := dbMeta.DecDisplayOption() + groupDecimalDisplay = decOpt.UnwrapOr(0) + } + } - assetMeta, err = r.cfg.AddrBook.FetchAssetMetaForAsset( - ctx, assetID, - ) + return &taprpc.FetchAssetMetaResponse{ + AssetMetas: rpcMetas, + DecimalDisplay: int32(groupDecimalDisplay), + }, nil +} + +// fetchMetaByAssetID is a helper function to fetch asset metadata by asset ID. +func (s *rpcServer) fetchMetaByAssetID(ctx context.Context, assetIdBytes []byte) (*taprpc.FetchAssetMetaResponse, error) { + if len(assetIdBytes) != sha256.Size { + return nil, fmt.Errorf("asset ID must be 32 bytes") + } + var parsedAssetID asset.ID + copy(parsedAssetID[:], assetIdBytes) + + dbMeta, fetchErr := s.cfg.AddrBook.FetchAssetMetaForAsset(ctx, parsedAssetID) + if fetchErr != nil { + return nil, fmt.Errorf("unable to fetch asset meta for asset ID: %w", fetchErr) + } - case req.GetMetaHash() != nil: - if len(req.GetMetaHash()) != sha256.Size { - return nil, fmt.Errorf("meta hash must be 32 bytes") + rpcMeta, err := rpcutils.MarshalAssetMeta(dbMeta) + if err != nil { + return nil, fmt.Errorf("unable to marshal asset meta: %w", err) + } + + decDisplay, _ := dbMeta.DecDisplayOption() + + return &taprpc.FetchAssetMetaResponse{ + AssetMetas: []*taprpc.AssetMeta{rpcMeta}, + DecimalDisplay: int32(decDisplay.UnwrapOr(0)), + }, nil +} + +// fetchMetaByMetaHash is a helper function to fetch asset metadata by meta hash. +func (s *rpcServer) fetchMetaByMetaHash(ctx context.Context, metaHashBytes []byte) (*taprpc.FetchAssetMetaResponse, error) { + if len(metaHashBytes) != sha256.Size { + return nil, fmt.Errorf("meta hash must be 32 bytes") + } + var mH [asset.MetaHashLen]byte + copy(mH[:], metaHashBytes) + + dbMeta, fetchErr := s.cfg.AddrBook.FetchAssetMetaByHash(ctx, mH) + if fetchErr != nil { + return nil, fmt.Errorf("unable to fetch asset meta by hash: %w", fetchErr) + } + + rpcMeta, err := rpcutils.MarshalAssetMeta(dbMeta) + if err != nil { + return nil, fmt.Errorf("unable to marshal asset meta: %w", err) + } + + decDisplay, _ := dbMeta.DecDisplayOption() + + return &taprpc.FetchAssetMetaResponse{ + AssetMetas: []*taprpc.AssetMeta{rpcMeta}, + DecimalDisplay: int32(decDisplay.UnwrapOr(0)), + }, nil +} + +// fetchMetaByGroupKey is a helper function to fetch asset metadata by group key. +func (s *rpcServer) fetchMetaByGroupKey(ctx context.Context, groupKeyBytes []byte) (*taprpc.FetchAssetMetaResponse, error) { + if len(groupKeyBytes) != btcec.PubKeyBytesCompressed && len(groupKeyBytes) != schnorr.PubKeyBytesLen { + return nil, fmt.Errorf("group key must be 32 or 33 bytes") + } + parsedGroupKey, err := parseUserKey(groupKeyBytes) // Reuses existing helper + if err != nil { + return nil, fmt.Errorf("invalid group key: %w", err) + } + + assetSpecifier := asset.NewSpecifierFromGroupKey(*parsedGroupKey) + filters := &tapdb.AssetQueryFilters{ + CommitmentConstraints: tapfreighter.CommitmentConstraints{ + AssetSpecifier: assetSpecifier, + }, + } + // We want all assets, spent or unspent, leased or not, to get their metas. + // Setting withWitness to false as we only need meta. + rpcChainAssets, err := s.fetchRpcAssets(ctx, false, true, true, filters) + if err != nil { + return nil, fmt.Errorf("unable to fetch assets for group key: %w", err) + } + + if len(rpcChainAssets) == 0 { + // If no assets are found for the group, it's not an error per se, + // but there's no metadata to return. The decimal display would be default (0). + return &taprpc.FetchAssetMetaResponse{ + AssetMetas: []*taprpc.AssetMeta{}, + DecimalDisplay: 0, + }, nil + } + + rpcMetas := make([]*taprpc.AssetMeta, 0, len(rpcChainAssets)) + var groupDecimalDisplay uint32 // Assuming it's the same for the whole group. + + for i, chainAsset := range rpcChainAssets { + var assetIDVar asset.ID + copy(assetIDVar[:], chainAsset.AssetGenesis.AssetId) + + dbMeta, fetchErr := s.cfg.AddrBook.FetchAssetMetaForAsset(ctx, assetIDVar) + if fetchErr != nil { + rpcsLog.Warnf("Failed to fetch meta for asset %x in group %x: %v", + assetIDVar[:], parsedGroupKey.SerializeCompressed(), fetchErr) + continue } - var metaHash [asset.MetaHashLen]byte - copy(metaHash[:], req.GetMetaHash()) + rpcMetaItem, marshalErr := rpcutils.MarshalAssetMeta(dbMeta) + if marshalErr != nil { + rpcsLog.Warnf("Failed to marshal meta for asset %x in group %x: %v", + assetIDVar[:], parsedGroupKey.SerializeCompressed(), marshalErr) + continue + } + rpcMetas = append(rpcMetas, rpcMetaItem) - assetMeta, err = r.cfg.AddrBook.FetchAssetMetaByHash( - ctx, metaHash, - ) + if i == 0 { + decOpt, _ := dbMeta.DecDisplayOption() + groupDecimalDisplay = decOpt.UnwrapOr(0) + } + } + + return &taprpc.FetchAssetMetaResponse{ + AssetMetas: rpcMetas, + DecimalDisplay: int32(groupDecimalDisplay), + }, nil +} + +func (s *rpcServer) FetchAssetMeta(ctx context.Context, + req *taprpc.FetchAssetMetaRequest) (*taprpc.FetchAssetMetaResponse, error) { - case req.GetMetaHashStr() != "": - if len(req.GetMetaHashStr()) != hex.EncodedLen(sha256.Size) { - return nil, fmt.Errorf("meta hash must be 32 bytes") + switch assetType := req.Asset.(type) { + case *taprpc.FetchAssetMetaRequest_AssetId: + return s.fetchMetaByAssetID(ctx, assetType.AssetId) + + case *taprpc.FetchAssetMetaRequest_AssetIdStr: + assetIDBytes, err := hex.DecodeString(assetType.AssetIdStr) + if err != nil { + return nil, fmt.Errorf("unable to decode asset id string: %w", err) } + return s.fetchMetaByAssetID(ctx, assetIDBytes) - var metaHashBytes []byte - metaHashBytes, err = hex.DecodeString(req.GetMetaHashStr()) + case *taprpc.FetchAssetMetaRequest_MetaHash: + return s.fetchMetaByMetaHash(ctx, assetType.MetaHash) + + case *taprpc.FetchAssetMetaRequest_MetaHashStr: + metaHashBytes, err := hex.DecodeString(assetType.MetaHashStr) if err != nil { - return nil, fmt.Errorf("error hex decoding meta hash: "+ - "%w", err) + return nil, fmt.Errorf("unable to decode meta hash string: %w", err) } + return s.fetchMetaByMetaHash(ctx, metaHashBytes) - var metaHash [asset.MetaHashLen]byte - copy(metaHash[:], metaHashBytes) + case *taprpc.FetchAssetMetaRequest_GroupKey: + return s.fetchMetaByGroupKey(ctx, assetType.GroupKey) - assetMeta, err = r.cfg.AddrBook.FetchAssetMetaByHash( - ctx, metaHash, - ) + case *taprpc.FetchAssetMetaRequest_GroupKeyStr: + groupKeyBytes, err := hex.DecodeString(assetType.GroupKeyStr) + if err != nil { + return nil, fmt.Errorf("unable to decode group key string: %w", err) + } + return s.fetchMetaByGroupKey(ctx, groupKeyBytes) default: - return nil, fmt.Errorf("either asset ID or meta hash must " + - "be set") + return nil, fmt.Errorf("unknown asset identifier in FetchAssetMetaRequest") } - if err != nil { - return nil, fmt.Errorf("unable to fetch asset "+ - "meta: %w", err) - } - - metaHash := assetMeta.MetaHash() - return &taprpc.AssetMeta{ - Data: assetMeta.Data, - Type: taprpc.AssetMetaType(assetMeta.Type), - MetaHash: metaHash[:], - }, nil } // MarshalUniProofType marshals the universe proof type into the RPC diff --git a/rpcserver_test.go b/rpcserver_test.go new file mode 100644 index 000000000..7fdce1a7c --- /dev/null +++ b/rpcserver_test.go @@ -0,0 +1,351 @@ +package taprootassets + +import ( + "context" + "encoding/hex" + "encoding/json" + "fmt" + "testing" + + "github.com/lightninglabs/taproot-assets/address" + "github.com/lightninglabs/taproot-assets/asset" + "github.com/lightninglabs/taproot-assets/proof" + "github.com/lightninglabs/taproot-assets/tapdb" + "github.com/lightninglabs/taproot-assets/taprpc" + "github.com/btcsuite/btcd/btcec/v2" + "github.com/btcsuite/btcd/chaincfg/chainhash" + "github.com/stretchr/testify/require" +) + +// mockAddrBook is a mock implementation of the address.Book interface. +type mockAddrBook struct { + address.Book // Embed to satisfy most methods if not overridden + + FetchAssetMetaForAssetFunc func(ctx context.Context, id asset.ID) (*proof.MetaReveal, error) + FetchAssetMetaByHashFunc func(ctx context.Context, hash [proof.MetaHashLen]byte) (*proof.MetaReveal, error) + // Add other methods if FetchAssetMeta indirectly calls them. +} + +func (m *mockAddrBook) FetchAssetMetaForAsset(ctx context.Context, id asset.ID) (*proof.MetaReveal, error) { + if m.FetchAssetMetaForAssetFunc != nil { + return m.FetchAssetMetaForAssetFunc(ctx, id) + } + return nil, fmt.Errorf("mockAddrBook.FetchAssetMetaForAssetFunc not implemented") +} + +func (m *mockAddrBook) FetchAssetMetaByHash(ctx context.Context, hash [proof.MetaHashLen]byte) (*proof.MetaReveal, error) { + if m.FetchAssetMetaByHashFunc != nil { + return m.FetchAssetMetaByHashFunc(ctx, hash) + } + return nil, fmt.Errorf("mockAddrBook.FetchAssetMetaByHashFunc not implemented") +} + +// mockAssetStore is a mock implementation of the tapdb.AssetStore interface. +type mockAssetStore struct { + tapdb.AssetStore // Embed to satisfy most methods if not overridden + + FetchAllAssetsFunc func(context.Context, bool, bool, *tapdb.AssetQueryFilters) ([]*asset.ChainAsset, error) + // Add other methods if FetchAssetMeta indirectly calls them. +} + +func (m *mockAssetStore) FetchAllAssets(ctx context.Context, includeSpent, includeLeased bool, + filters *tapdb.AssetQueryFilters) ([]*asset.ChainAsset, error) { + if m.FetchAllAssetsFunc != nil { + return m.FetchAllAssetsFunc(ctx, includeSpent, includeLeased, filters) + } + return nil, fmt.Errorf("mockAssetStore.FetchAllAssetsFunc not implemented") +} + +func newTestRpcServer(t *testing.T, mockBook address.Book, mockStore tapdb.AssetStore) *rpcServer { + // We use a minimal config here. If other parts of Config are accessed by + // FetchAssetMeta or its callees (like ChainParams for address encoding, + // or KeyRing for local key checks in MarshalChainAsset), they might need + // to be initialized. For now, AddrBook and AssetStore are the direct ones. + cfg := &Config{ + AddrBook: mockBook, + AssetStore: mockStore, + // ChainParams: &chaincfg.MainNetParams, // Example if needed + } + return &rpcServer{cfg: cfg} +} + +func makeMetaReveal(t *testing.T, name string, decDisplay uint32) *proof.MetaReveal { + metaJSON := map[string]interface{}{ + "name": name, + } + // Only add decimal_display if it's non-zero to simulate cases where it might be absent + if decDisplay > 0 { + metaJSON["decimal_display"] = decDisplay + } + metaBytes, err := json.Marshal(metaJSON) + require.NoError(t, err) + + // The DecDisplayOption() method on MetaReveal tries TLV first, then JSON. + // To make it simpler for mocking, we can directly set the Data to JSON. + // Alternatively, one could construct the TLV bytes if testing that path specifically. + return &proof.MetaReveal{ + Data: metaBytes, + Type: proof.MetaJson, + } +} + +func TestFetchAssetMeta(t *testing.T) { + ctx := context.Background() + + // Common assets and keys for tests + assetID1Bytes, _ := hex.DecodeString("0101010101010101010101010101010101010101010101010101010101010101") + var assetID1 asset.ID + copy(assetID1[:], assetID1Bytes) + + assetID2Bytes, _ := hex.DecodeString("0202020202020202020202020202020202020202020202020202020202020202") + var assetID2 asset.ID + copy(assetID2[:], assetID2Bytes) + + groupKeyBytes, _ := hex.DecodeString("030000000000000000000000000000000000000000000000000000000000000001") + groupKey, _ := btcec.ParsePubKey(groupKeyBytes) + + meta1 := makeMetaReveal(t, "Asset One", 2) + meta2 := makeMetaReveal(t, "Asset Two in Group", 2) // Same decimal display for group + meta3 := makeMetaReveal(t, "Asset Three in Group", 2) // Same decimal display for group + + var meta1Hash [proof.MetaHashLen]byte + copy(meta1Hash[:], meta1.MetaHash()) + + + t.Run("Fetch by Group Key - Success", func(t *testing.T) { + mockBook := &mockAddrBook{} + mockStore := &mockAssetStore{} + + chainAsset2 := &asset.ChainAsset{ + Asset: asset.Asset{ + Version: asset.V0, + Genesis: asset.Genesis{ID: assetID2, MetaHash: meta2.MetaHash()}, + GroupKey: &asset.GroupKey{GroupPubKey: *groupKey}, + // Other fields as needed by MarshalChainAsset + ScriptKey: asset.ScriptKey{PubKey: &btcec.PublicKey{}}, + }, + } + chainAsset3 := &asset.ChainAsset{ + Asset: asset.Asset{ + Version: asset.V0, + Genesis: asset.Genesis{ID: assetID1, MetaHash: meta3.MetaHash()}, // Note: using assetID1 for variety + GroupKey: &asset.GroupKey{GroupPubKey: *groupKey}, + // Other fields as needed by MarshalChainAsset + ScriptKey: asset.ScriptKey{PubKey: &btcec.PublicKey{}}, + }, + } + + mockStore.FetchAllAssetsFunc = func(_ context.Context, _, _ bool, filters *tapdb.AssetQueryFilters) ([]*asset.ChainAsset, error) { + require.NotNil(t, filters) + require.NotNil(t, filters.AssetSpecifier) + require.True(t, filters.AssetSpecifier.HasGroupPubKey()) + require.True(t, filters.AssetSpecifier.UnwrapGroupKeyToPtr().IsEqual(groupKey)) + return []*asset.ChainAsset{chainAsset2, chainAsset3}, nil + } + + mockBook.FetchAssetMetaForAssetFunc = func(_ context.Context, id asset.ID) (*proof.MetaReveal, error) { + if id == assetID2 { + return meta2, nil + } + if id == assetID1 { // Corresponds to chainAsset3's Genesis ID + return meta3, nil + } + return nil, fmt.Errorf("unexpected asset ID: %x", id) + } + + server := newTestRpcServer(t, mockBook, mockStore) + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_GroupKeyStr{GroupKeyStr: hex.EncodeToString(groupKeyBytes)}, + } + + resp, err := server.FetchAssetMeta(ctx, req) + require.NoError(t, err) + require.NotNil(t, resp) + require.Len(t, resp.AssetMetas, 2) + require.Equal(t, int32(2), resp.DecimalDisplay) + + // Check individual metas (order might vary depending on fetchRpcAssets) + foundMeta2 := false + foundMeta3 := false + for _, rpcMeta := range resp.AssetMetas { + if bytes.Equal(rpcMeta.MetaHash, meta2.MetaHash()) { + foundMeta2 = true + require.Equal(t, meta2.Data, rpcMeta.Data) + } + if bytes.Equal(rpcMeta.MetaHash, meta3.MetaHash()) { + foundMeta3 = true + require.Equal(t, meta3.Data, rpcMeta.Data) + } + } + require.True(t, foundMeta2, "meta2 not found in response") + require.True(t, foundMeta3, "meta3 not found in response") + }) + + t.Run("Fetch by Group Key - Group Not Found", func(t *testing.T) { + mockBook := &mockAddrBook{} // Not used in this path + mockStore := &mockAssetStore{} + mockStore.FetchAllAssetsFunc = func(_ context.Context, _, _ bool, filters *tapdb.AssetQueryFilters) ([]*asset.ChainAsset, error) { + return []*asset.ChainAsset{}, nil // No assets for this group + } + + server := newTestRpcServer(t, mockBook, mockStore) + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_GroupKeyStr{GroupKeyStr: hex.EncodeToString(groupKeyBytes)}, + } + + resp, err := server.FetchAssetMeta(ctx, req) + require.NoError(t, err) + require.NotNil(t, resp) + require.Empty(t, resp.AssetMetas) + require.Equal(t, int32(0), resp.DecimalDisplay) + }) + + t.Run("Fetch by Asset ID - DecimalDisplay populated", func(t *testing.T) { + mockBook := &mockAddrBook{} + mockStore := &mockAssetStore{} // Not directly used by FetchAssetMetaForAsset path + + mockBook.FetchAssetMetaForAssetFunc = func(_ context.Context, id asset.ID) (*proof.MetaReveal, error) { + require.Equal(t, assetID1, id) + return meta1, nil + } + + server := newTestRpcServer(t, mockBook, mockStore) + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_AssetIdStr{AssetIdStr: hex.EncodeToString(assetID1Bytes)}, + } + + resp, err := server.FetchAssetMeta(ctx, req) + require.NoError(t, err) + require.NotNil(t, resp) + require.Len(t, resp.AssetMetas, 1) + require.Equal(t, meta1.Data, resp.AssetMetas[0].Data) + require.Equal(t, meta1.MetaHash(), resp.AssetMetas[0].MetaHash) + require.Equal(t, int32(2), resp.DecimalDisplay) + }) + + t.Run("Fetch by Meta Hash - DecimalDisplay populated", func(t *testing.T) { + mockBook := &mockAddrBook{} + mockStore := &mockAssetStore{} // Not directly used by FetchAssetMetaByHash path + + mockBook.FetchAssetMetaByHashFunc = func(_ context.Context, hash [proof.MetaHashLen]byte) (*proof.MetaReveal, error) { + require.Equal(t, meta1Hash, hash) + return meta1, nil + } + + server := newTestRpcServer(t, mockBook, mockStore) + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_MetaHashStr{MetaHashStr: hex.EncodeToString(meta1Hash[:])}, + } + + resp, err := server.FetchAssetMeta(ctx, req) + require.NoError(t, err) + require.NotNil(t, resp) + require.Len(t, resp.AssetMetas, 1) + require.Equal(t, meta1.Data, resp.AssetMetas[0].Data) + require.Equal(t, meta1.MetaHash(), resp.AssetMetas[0].MetaHash) + require.Equal(t, int32(2), resp.DecimalDisplay) + }) + + // Test cases for raw byte inputs + t.Run("Fetch by Group Key (Raw Bytes) - Success", func(t *testing.T) { + mockBook := &mockAddrBook{} + mockStore := &mockAssetStore{} + + chainAsset2 := &asset.ChainAsset{ + Asset: asset.Asset{ + Version: asset.V0, + Genesis: asset.Genesis{ID: assetID2, MetaHash: meta2.MetaHash()}, + GroupKey: &asset.GroupKey{GroupPubKey: *groupKey}, + ScriptKey: asset.ScriptKey{PubKey: &btcec.PublicKey{}}, + }, + } + chainAsset3 := &asset.ChainAsset{ + Asset: asset.Asset{ + Version: asset.V0, + Genesis: asset.Genesis{ID: assetID1, MetaHash: meta3.MetaHash()}, + GroupKey: &asset.GroupKey{GroupPubKey: *groupKey}, + ScriptKey: asset.ScriptKey{PubKey: &btcec.PublicKey{}}, + }, + } + + mockStore.FetchAllAssetsFunc = func(_ context.Context, _, _ bool, filters *tapdb.AssetQueryFilters) ([]*asset.ChainAsset, error) { + require.NotNil(t, filters) + require.NotNil(t, filters.AssetSpecifier) + require.True(t, filters.AssetSpecifier.HasGroupPubKey()) + require.True(t, filters.AssetSpecifier.UnwrapGroupKeyToPtr().IsEqual(groupKey)) + return []*asset.ChainAsset{chainAsset2, chainAsset3}, nil + } + + mockBook.FetchAssetMetaForAssetFunc = func(_ context.Context, id asset.ID) (*proof.MetaReveal, error) { + if id == assetID2 { + return meta2, nil + } + if id == assetID1 { + return meta3, nil + } + return nil, fmt.Errorf("unexpected asset ID: %x", id) + } + + server := newTestRpcServer(t, mockBook, mockStore) + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_GroupKey{GroupKey: groupKeyBytes}, + } + + resp, err := server.FetchAssetMeta(ctx, req) + require.NoError(t, err) + require.NotNil(t, resp) + require.Len(t, resp.AssetMetas, 2) + require.Equal(t, int32(2), resp.DecimalDisplay) + }) + + t.Run("Fetch by Asset ID (Raw Bytes) - DecimalDisplay populated", func(t *testing.T) { + mockBook := &mockAddrBook{} + mockStore := &mockAssetStore{} + + mockBook.FetchAssetMetaForAssetFunc = func(_ context.Context, id asset.ID) (*proof.MetaReveal, error) { + require.Equal(t, assetID1, id) + return meta1, nil + } + + server := newTestRpcServer(t, mockBook, mockStore) + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_AssetId{AssetId: assetID1Bytes}, + } + + resp, err := server.FetchAssetMeta(ctx, req) + require.NoError(t, err) + require.NotNil(t, resp) + require.Len(t, resp.AssetMetas, 1) + require.Equal(t, meta1.Data, resp.AssetMetas[0].Data) + require.Equal(t, meta1.MetaHash(), resp.AssetMetas[0].MetaHash) + require.Equal(t, int32(2), resp.DecimalDisplay) + }) + + t.Run("Fetch by Meta Hash (Raw Bytes) - DecimalDisplay populated", func(t *testing.T) { + mockBook := &mockAddrBook{} + mockStore := &mockAssetStore{} + + mockBook.FetchAssetMetaByHashFunc = func(_ context.Context, hash [proof.MetaHashLen]byte) (*proof.MetaReveal, error) { + require.Equal(t, meta1Hash, hash) + return meta1, nil + } + + server := newTestRpcServer(t, mockBook, mockStore) + req := &taprpc.FetchAssetMetaRequest{ + Asset: &taprpc.FetchAssetMetaRequest_MetaHash{MetaHash: meta1Hash[:]}, + } + + resp, err := server.FetchAssetMeta(ctx, req) + require.NoError(t, err) + require.NotNil(t, resp) + require.Len(t, resp.AssetMetas, 1) + require.Equal(t, meta1.Data, resp.AssetMetas[0].Data) + require.Equal(t, meta1.MetaHash(), resp.AssetMetas[0].MetaHash) + require.Equal(t, int32(2), resp.DecimalDisplay) + }) +} + +// TODO: Add tests for invalid inputs (bad hex strings, wrong lengths) if not covered by main RPC error handling. +// These are implicitly tested by the main function's initial parsing, but dedicated unit tests for those +// specific error paths in FetchAssetMeta could be added if desired. +// The current tests focus on the logic after successful parsing of the request's oneof field. diff --git a/taprpc/assetwalletrpc/assetwallet.pb.go b/taprpc/assetwalletrpc/assetwallet.pb.go index 1a5d7a4a4..ff5a1f3e9 100644 --- a/taprpc/assetwalletrpc/assetwallet.pb.go +++ b/taprpc/assetwalletrpc/assetwallet.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.34.2 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: assetwalletrpc/assetwallet.proto @@ -12,6 +12,7 @@ import ( protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + unsafe "unsafe" ) const ( @@ -77,11 +78,8 @@ func (CoinSelectType) EnumDescriptor() ([]byte, []int) { } type FundVirtualPsbtRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Template: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Template: // // *FundVirtualPsbtRequest_Psbt // *FundVirtualPsbtRequest_Raw @@ -89,15 +87,15 @@ type FundVirtualPsbtRequest struct { // Specify the type of coins that should be selected. Defaults to allowing both // script trees and BIP-086 compliant inputs. CoinSelectType CoinSelectType `protobuf:"varint,3,opt,name=coin_select_type,json=coinSelectType,proto3,enum=assetwalletrpc.CoinSelectType" json:"coin_select_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *FundVirtualPsbtRequest) Reset() { *x = FundVirtualPsbtRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FundVirtualPsbtRequest) String() string { @@ -108,7 +106,7 @@ func (*FundVirtualPsbtRequest) ProtoMessage() {} func (x *FundVirtualPsbtRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -123,23 +121,27 @@ func (*FundVirtualPsbtRequest) Descriptor() ([]byte, []int) { return file_assetwalletrpc_assetwallet_proto_rawDescGZIP(), []int{0} } -func (m *FundVirtualPsbtRequest) GetTemplate() isFundVirtualPsbtRequest_Template { - if m != nil { - return m.Template +func (x *FundVirtualPsbtRequest) GetTemplate() isFundVirtualPsbtRequest_Template { + if x != nil { + return x.Template } return nil } func (x *FundVirtualPsbtRequest) GetPsbt() []byte { - if x, ok := x.GetTemplate().(*FundVirtualPsbtRequest_Psbt); ok { - return x.Psbt + if x != nil { + if x, ok := x.Template.(*FundVirtualPsbtRequest_Psbt); ok { + return x.Psbt + } } return nil } func (x *FundVirtualPsbtRequest) GetRaw() *TxTemplate { - if x, ok := x.GetTemplate().(*FundVirtualPsbtRequest_Raw); ok { - return x.Raw + if x != nil { + if x, ok := x.Template.(*FundVirtualPsbtRequest_Raw); ok { + return x.Raw + } } return nil } @@ -170,10 +172,7 @@ func (*FundVirtualPsbtRequest_Psbt) isFundVirtualPsbtRequest_Template() {} func (*FundVirtualPsbtRequest_Raw) isFundVirtualPsbtRequest_Template() {} type FundVirtualPsbtResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The funded but not yet signed virtual PSBT packet. FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"` // The index of the added change output or -1 if no change was left over. @@ -189,15 +188,15 @@ type FundVirtualPsbtResponse struct { // they are just carried along and not directly affected by the direct user // action. PassiveAssetPsbts [][]byte `protobuf:"bytes,3,rep,name=passive_asset_psbts,json=passiveAssetPsbts,proto3" json:"passive_asset_psbts,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *FundVirtualPsbtResponse) Reset() { *x = FundVirtualPsbtResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FundVirtualPsbtResponse) String() string { @@ -208,7 +207,7 @@ func (*FundVirtualPsbtResponse) ProtoMessage() {} func (x *FundVirtualPsbtResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[1] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -245,10 +244,7 @@ func (x *FundVirtualPsbtResponse) GetPassiveAssetPsbts() [][]byte { } type TxTemplate struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // An optional list of inputs to use. Every input must be an asset UTXO known // to the wallet. The sum of all inputs must be greater than or equal to the // sum of all outputs. @@ -258,16 +254,16 @@ type TxTemplate struct { Inputs []*PrevId `protobuf:"bytes,1,rep,name=inputs,proto3" json:"inputs,omitempty"` // A map of all Taproot Asset addresses mapped to the anchor transaction's // output index that should be sent to. - Recipients map[string]uint64 `protobuf:"bytes,2,rep,name=recipients,proto3" json:"recipients,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + Recipients map[string]uint64 `protobuf:"bytes,2,rep,name=recipients,proto3" json:"recipients,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *TxTemplate) Reset() { *x = TxTemplate{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *TxTemplate) String() string { @@ -278,7 +274,7 @@ func (*TxTemplate) ProtoMessage() {} func (x *TxTemplate) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -308,26 +304,23 @@ func (x *TxTemplate) GetRecipients() map[string]uint64 { } type PrevId struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The bitcoin anchor output on chain that contains the input asset. Outpoint *taprpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"` // The asset ID of the previous asset tree. Id []byte `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` // The tweaked Taproot output key committing to the possible spending // conditions of the asset. - ScriptKey []byte `protobuf:"bytes,3,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` + ScriptKey []byte `protobuf:"bytes,3,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PrevId) Reset() { *x = PrevId{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PrevId) String() string { @@ -338,7 +331,7 @@ func (*PrevId) ProtoMessage() {} func (x *PrevId) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[3] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -375,23 +368,20 @@ func (x *PrevId) GetScriptKey() []byte { } type SignVirtualPsbtRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The PSBT of the virtual transaction that should be signed. The PSBT must // contain all required inputs, outputs, UTXO data and custom fields required // to identify the signing key. - FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"` + FundedPsbt []byte `protobuf:"bytes,1,opt,name=funded_psbt,json=fundedPsbt,proto3" json:"funded_psbt,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SignVirtualPsbtRequest) Reset() { *x = SignVirtualPsbtRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SignVirtualPsbtRequest) String() string { @@ -402,7 +392,7 @@ func (*SignVirtualPsbtRequest) ProtoMessage() {} func (x *SignVirtualPsbtRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -425,23 +415,20 @@ func (x *SignVirtualPsbtRequest) GetFundedPsbt() []byte { } type SignVirtualPsbtResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The signed virtual transaction in PSBT format. SignedPsbt []byte `protobuf:"bytes,1,opt,name=signed_psbt,json=signedPsbt,proto3" json:"signed_psbt,omitempty"` // The indices of signed inputs. - SignedInputs []uint32 `protobuf:"varint,2,rep,packed,name=signed_inputs,json=signedInputs,proto3" json:"signed_inputs,omitempty"` + SignedInputs []uint32 `protobuf:"varint,2,rep,packed,name=signed_inputs,json=signedInputs,proto3" json:"signed_inputs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SignVirtualPsbtResponse) Reset() { *x = SignVirtualPsbtResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SignVirtualPsbtResponse) String() string { @@ -452,7 +439,7 @@ func (*SignVirtualPsbtResponse) ProtoMessage() {} func (x *SignVirtualPsbtResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[5] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -482,22 +469,19 @@ func (x *SignVirtualPsbtResponse) GetSignedInputs() []uint32 { } type AnchorVirtualPsbtsRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The list of virtual transactions that should be merged and committed to in // the BTC level anchor transaction. - VirtualPsbts [][]byte `protobuf:"bytes,1,rep,name=virtual_psbts,json=virtualPsbts,proto3" json:"virtual_psbts,omitempty"` + VirtualPsbts [][]byte `protobuf:"bytes,1,rep,name=virtual_psbts,json=virtualPsbts,proto3" json:"virtual_psbts,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AnchorVirtualPsbtsRequest) Reset() { *x = AnchorVirtualPsbtsRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AnchorVirtualPsbtsRequest) String() string { @@ -508,7 +492,7 @@ func (*AnchorVirtualPsbtsRequest) ProtoMessage() {} func (x *AnchorVirtualPsbtsRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[6] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -531,10 +515,7 @@ func (x *AnchorVirtualPsbtsRequest) GetVirtualPsbts() [][]byte { } type CommitVirtualPsbtsRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The list of virtual transactions that should be mapped to the given BTC // level anchor transaction template. The virtual transactions are expected to // be signed (or use ASSET_VERSION_V1 with segregated witness to allow for @@ -558,12 +539,12 @@ type CommitVirtualPsbtsRequest struct { // transactions given above. This can be achieved by using // tapfreighter.PrepareAnchoringTemplate for example. AnchorPsbt []byte `protobuf:"bytes,3,opt,name=anchor_psbt,json=anchorPsbt,proto3" json:"anchor_psbt,omitempty"` - // Types that are assignable to AnchorChangeOutput: + // Types that are valid to be assigned to AnchorChangeOutput: // // *CommitVirtualPsbtsRequest_ExistingOutputIndex // *CommitVirtualPsbtsRequest_Add AnchorChangeOutput isCommitVirtualPsbtsRequest_AnchorChangeOutput `protobuf_oneof:"anchor_change_output"` - // Types that are assignable to Fees: + // Types that are valid to be assigned to Fees: // // *CommitVirtualPsbtsRequest_TargetConf // *CommitVirtualPsbtsRequest_SatPerVbyte @@ -578,16 +559,16 @@ type CommitVirtualPsbtsRequest struct { LockExpirationSeconds uint64 `protobuf:"varint,9,opt,name=lock_expiration_seconds,json=lockExpirationSeconds,proto3" json:"lock_expiration_seconds,omitempty"` // If set, the psbt funding step will be skipped. This is useful if the intent // is to create a zero-fee transaction. - SkipFunding bool `protobuf:"varint,10,opt,name=skip_funding,json=skipFunding,proto3" json:"skip_funding,omitempty"` + SkipFunding bool `protobuf:"varint,10,opt,name=skip_funding,json=skipFunding,proto3" json:"skip_funding,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CommitVirtualPsbtsRequest) Reset() { *x = CommitVirtualPsbtsRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *CommitVirtualPsbtsRequest) String() string { @@ -598,7 +579,7 @@ func (*CommitVirtualPsbtsRequest) ProtoMessage() {} func (x *CommitVirtualPsbtsRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[7] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -634,44 +615,52 @@ func (x *CommitVirtualPsbtsRequest) GetAnchorPsbt() []byte { return nil } -func (m *CommitVirtualPsbtsRequest) GetAnchorChangeOutput() isCommitVirtualPsbtsRequest_AnchorChangeOutput { - if m != nil { - return m.AnchorChangeOutput +func (x *CommitVirtualPsbtsRequest) GetAnchorChangeOutput() isCommitVirtualPsbtsRequest_AnchorChangeOutput { + if x != nil { + return x.AnchorChangeOutput } return nil } func (x *CommitVirtualPsbtsRequest) GetExistingOutputIndex() int32 { - if x, ok := x.GetAnchorChangeOutput().(*CommitVirtualPsbtsRequest_ExistingOutputIndex); ok { - return x.ExistingOutputIndex + if x != nil { + if x, ok := x.AnchorChangeOutput.(*CommitVirtualPsbtsRequest_ExistingOutputIndex); ok { + return x.ExistingOutputIndex + } } return 0 } func (x *CommitVirtualPsbtsRequest) GetAdd() bool { - if x, ok := x.GetAnchorChangeOutput().(*CommitVirtualPsbtsRequest_Add); ok { - return x.Add + if x != nil { + if x, ok := x.AnchorChangeOutput.(*CommitVirtualPsbtsRequest_Add); ok { + return x.Add + } } return false } -func (m *CommitVirtualPsbtsRequest) GetFees() isCommitVirtualPsbtsRequest_Fees { - if m != nil { - return m.Fees +func (x *CommitVirtualPsbtsRequest) GetFees() isCommitVirtualPsbtsRequest_Fees { + if x != nil { + return x.Fees } return nil } func (x *CommitVirtualPsbtsRequest) GetTargetConf() uint32 { - if x, ok := x.GetFees().(*CommitVirtualPsbtsRequest_TargetConf); ok { - return x.TargetConf + if x != nil { + if x, ok := x.Fees.(*CommitVirtualPsbtsRequest_TargetConf); ok { + return x.TargetConf + } } return 0 } func (x *CommitVirtualPsbtsRequest) GetSatPerVbyte() uint64 { - if x, ok := x.GetFees().(*CommitVirtualPsbtsRequest_SatPerVbyte); ok { - return x.SatPerVbyte + if x != nil { + if x, ok := x.Fees.(*CommitVirtualPsbtsRequest_SatPerVbyte); ok { + return x.SatPerVbyte + } } return 0 } @@ -739,10 +728,7 @@ func (*CommitVirtualPsbtsRequest_TargetConf) isCommitVirtualPsbtsRequest_Fees() func (*CommitVirtualPsbtsRequest_SatPerVbyte) isCommitVirtualPsbtsRequest_Fees() {} type CommitVirtualPsbtsResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The funded BTC level anchor transaction with all outputs updated to commit // to the virtual transactions given. The transaction is ready to be signed, // unless some of the asset inputs don't belong to this daemon, in which case @@ -766,15 +752,15 @@ type CommitVirtualPsbtsResponse struct { // PSBT packet from lnd. Only inputs added to the PSBT by this RPC are locked, // inputs that were already present in the PSBT are not locked. LndLockedUtxos []*taprpc.OutPoint `protobuf:"bytes,6,rep,name=lnd_locked_utxos,json=lndLockedUtxos,proto3" json:"lnd_locked_utxos,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CommitVirtualPsbtsResponse) Reset() { *x = CommitVirtualPsbtsResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *CommitVirtualPsbtsResponse) String() string { @@ -785,7 +771,7 @@ func (*CommitVirtualPsbtsResponse) ProtoMessage() {} func (x *CommitVirtualPsbtsResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[8] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -836,10 +822,7 @@ func (x *CommitVirtualPsbtsResponse) GetLndLockedUtxos() []*taprpc.OutPoint { } type PublishAndLogRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The funded BTC level anchor transaction with all outputs updated to commit // to the virtual transactions given. The transaction is ready to be signed, // unless some of the asset inputs don't belong to this daemon, in which case @@ -864,16 +847,16 @@ type PublishAndLogRequest struct { // An optional short label for the transfer. This label can be used to track // the progress of the transfer via the logs or an event subscription. // Multiple transfers can share the same label. - Label string `protobuf:"bytes,7,opt,name=label,proto3" json:"label,omitempty"` + Label string `protobuf:"bytes,7,opt,name=label,proto3" json:"label,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PublishAndLogRequest) Reset() { *x = PublishAndLogRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PublishAndLogRequest) String() string { @@ -884,7 +867,7 @@ func (*PublishAndLogRequest) ProtoMessage() {} func (x *PublishAndLogRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[9] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -949,20 +932,17 @@ func (x *PublishAndLogRequest) GetLabel() string { } type NextInternalKeyRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + KeyFamily uint32 `protobuf:"varint,1,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"` unknownFields protoimpl.UnknownFields - - KeyFamily uint32 `protobuf:"varint,1,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"` + sizeCache protoimpl.SizeCache } func (x *NextInternalKeyRequest) Reset() { *x = NextInternalKeyRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[10] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *NextInternalKeyRequest) String() string { @@ -973,7 +953,7 @@ func (*NextInternalKeyRequest) ProtoMessage() {} func (x *NextInternalKeyRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[10] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -996,20 +976,17 @@ func (x *NextInternalKeyRequest) GetKeyFamily() uint32 { } type NextInternalKeyResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + InternalKey *taprpc.KeyDescriptor `protobuf:"bytes,1,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"` unknownFields protoimpl.UnknownFields - - InternalKey *taprpc.KeyDescriptor `protobuf:"bytes,1,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"` + sizeCache protoimpl.SizeCache } func (x *NextInternalKeyResponse) Reset() { *x = NextInternalKeyResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *NextInternalKeyResponse) String() string { @@ -1020,7 +997,7 @@ func (*NextInternalKeyResponse) ProtoMessage() {} func (x *NextInternalKeyResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[11] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1043,20 +1020,17 @@ func (x *NextInternalKeyResponse) GetInternalKey() *taprpc.KeyDescriptor { } type NextScriptKeyRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + KeyFamily uint32 `protobuf:"varint,1,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"` unknownFields protoimpl.UnknownFields - - KeyFamily uint32 `protobuf:"varint,1,opt,name=key_family,json=keyFamily,proto3" json:"key_family,omitempty"` + sizeCache protoimpl.SizeCache } func (x *NextScriptKeyRequest) Reset() { *x = NextScriptKeyRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[12] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *NextScriptKeyRequest) String() string { @@ -1067,7 +1041,7 @@ func (*NextScriptKeyRequest) ProtoMessage() {} func (x *NextScriptKeyRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[12] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1090,20 +1064,17 @@ func (x *NextScriptKeyRequest) GetKeyFamily() uint32 { } type NextScriptKeyResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + ScriptKey *taprpc.ScriptKey `protobuf:"bytes,1,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` unknownFields protoimpl.UnknownFields - - ScriptKey *taprpc.ScriptKey `protobuf:"bytes,1,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` + sizeCache protoimpl.SizeCache } func (x *NextScriptKeyResponse) Reset() { *x = NextScriptKeyResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[13] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *NextScriptKeyResponse) String() string { @@ -1114,7 +1085,7 @@ func (*NextScriptKeyResponse) ProtoMessage() {} func (x *NextScriptKeyResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[13] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1137,22 +1108,19 @@ func (x *NextScriptKeyResponse) GetScriptKey() *taprpc.ScriptKey { } type QueryInternalKeyRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The internal key to look for. This can either be the 32-byte x-only raw // internal key or the 33-byte raw internal key with the parity byte. - InternalKey []byte `protobuf:"bytes,1,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"` + InternalKey []byte `protobuf:"bytes,1,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryInternalKeyRequest) Reset() { *x = QueryInternalKeyRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryInternalKeyRequest) String() string { @@ -1163,7 +1131,7 @@ func (*QueryInternalKeyRequest) ProtoMessage() {} func (x *QueryInternalKeyRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[14] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1186,20 +1154,17 @@ func (x *QueryInternalKeyRequest) GetInternalKey() []byte { } type QueryInternalKeyResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + InternalKey *taprpc.KeyDescriptor `protobuf:"bytes,1,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"` unknownFields protoimpl.UnknownFields - - InternalKey *taprpc.KeyDescriptor `protobuf:"bytes,1,opt,name=internal_key,json=internalKey,proto3" json:"internal_key,omitempty"` + sizeCache protoimpl.SizeCache } func (x *QueryInternalKeyResponse) Reset() { *x = QueryInternalKeyResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryInternalKeyResponse) String() string { @@ -1210,7 +1175,7 @@ func (*QueryInternalKeyResponse) ProtoMessage() {} func (x *QueryInternalKeyResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[15] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1233,23 +1198,20 @@ func (x *QueryInternalKeyResponse) GetInternalKey() *taprpc.KeyDescriptor { } type QueryScriptKeyRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The tweaked script key to look for. This can either be the 32-byte // x-only tweaked script key or the 33-byte tweaked script key with the // parity byte. TweakedScriptKey []byte `protobuf:"bytes,1,opt,name=tweaked_script_key,json=tweakedScriptKey,proto3" json:"tweaked_script_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryScriptKeyRequest) Reset() { *x = QueryScriptKeyRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[16] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryScriptKeyRequest) String() string { @@ -1260,7 +1222,7 @@ func (*QueryScriptKeyRequest) ProtoMessage() {} func (x *QueryScriptKeyRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[16] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1283,20 +1245,17 @@ func (x *QueryScriptKeyRequest) GetTweakedScriptKey() []byte { } type QueryScriptKeyResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + ScriptKey *taprpc.ScriptKey `protobuf:"bytes,1,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` unknownFields protoimpl.UnknownFields - - ScriptKey *taprpc.ScriptKey `protobuf:"bytes,1,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` + sizeCache protoimpl.SizeCache } func (x *QueryScriptKeyResponse) Reset() { *x = QueryScriptKeyResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[17] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryScriptKeyResponse) String() string { @@ -1307,7 +1266,7 @@ func (*QueryScriptKeyResponse) ProtoMessage() {} func (x *QueryScriptKeyResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[17] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1330,26 +1289,23 @@ func (x *QueryScriptKeyResponse) GetScriptKey() *taprpc.ScriptKey { } type ProveAssetOwnershipRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` - ScriptKey []byte `protobuf:"bytes,2,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` - Outpoint *taprpc.OutPoint `protobuf:"bytes,3,opt,name=outpoint,proto3" json:"outpoint,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` + ScriptKey []byte `protobuf:"bytes,2,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` + Outpoint *taprpc.OutPoint `protobuf:"bytes,3,opt,name=outpoint,proto3" json:"outpoint,omitempty"` // An optional 32-byte challenge that may be used to bind the generated // proof. This challenge needs to be also presented on the // VerifyAssetOwnership RPC in order to check the proof against it. - Challenge []byte `protobuf:"bytes,4,opt,name=challenge,proto3" json:"challenge,omitempty"` + Challenge []byte `protobuf:"bytes,4,opt,name=challenge,proto3" json:"challenge,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *ProveAssetOwnershipRequest) Reset() { *x = ProveAssetOwnershipRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[18] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *ProveAssetOwnershipRequest) String() string { @@ -1360,7 +1316,7 @@ func (*ProveAssetOwnershipRequest) ProtoMessage() {} func (x *ProveAssetOwnershipRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[18] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1404,20 +1360,17 @@ func (x *ProveAssetOwnershipRequest) GetChallenge() []byte { } type ProveAssetOwnershipResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - ProofWithWitness []byte `protobuf:"bytes,1,opt,name=proof_with_witness,json=proofWithWitness,proto3" json:"proof_with_witness,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + ProofWithWitness []byte `protobuf:"bytes,1,opt,name=proof_with_witness,json=proofWithWitness,proto3" json:"proof_with_witness,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *ProveAssetOwnershipResponse) Reset() { *x = ProveAssetOwnershipResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[19] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *ProveAssetOwnershipResponse) String() string { @@ -1428,7 +1381,7 @@ func (*ProveAssetOwnershipResponse) ProtoMessage() {} func (x *ProveAssetOwnershipResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[19] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1451,24 +1404,21 @@ func (x *ProveAssetOwnershipResponse) GetProofWithWitness() []byte { } type VerifyAssetOwnershipRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - ProofWithWitness []byte `protobuf:"bytes,1,opt,name=proof_with_witness,json=proofWithWitness,proto3" json:"proof_with_witness,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + ProofWithWitness []byte `protobuf:"bytes,1,opt,name=proof_with_witness,json=proofWithWitness,proto3" json:"proof_with_witness,omitempty"` // An optional 32-byte challenge that may be used to check the ownership // proof against. This challenge must match the one that the prover used // on the ProveAssetOwnership RPC. - Challenge []byte `protobuf:"bytes,2,opt,name=challenge,proto3" json:"challenge,omitempty"` + Challenge []byte `protobuf:"bytes,2,opt,name=challenge,proto3" json:"challenge,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *VerifyAssetOwnershipRequest) Reset() { *x = VerifyAssetOwnershipRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[20] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *VerifyAssetOwnershipRequest) String() string { @@ -1479,7 +1429,7 @@ func (*VerifyAssetOwnershipRequest) ProtoMessage() {} func (x *VerifyAssetOwnershipRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[20] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1509,11 +1459,8 @@ func (x *VerifyAssetOwnershipRequest) GetChallenge() []byte { } type VerifyAssetOwnershipResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - ValidProof bool `protobuf:"varint,1,opt,name=valid_proof,json=validProof,proto3" json:"valid_proof,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + ValidProof bool `protobuf:"varint,1,opt,name=valid_proof,json=validProof,proto3" json:"valid_proof,omitempty"` // The outpoint the proof commits to. Outpoint *taprpc.OutPoint `protobuf:"bytes,2,opt,name=outpoint,proto3" json:"outpoint,omitempty"` // The outpoint in the human-readable form "hash:index". @@ -1523,16 +1470,16 @@ type VerifyAssetOwnershipResponse struct { // The block hash as hexadecimal string of the byte-reversed hash. BlockHashStr string `protobuf:"bytes,5,opt,name=block_hash_str,json=blockHashStr,proto3" json:"block_hash_str,omitempty"` // The block height of the block the output is part of. - BlockHeight uint32 `protobuf:"varint,6,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + BlockHeight uint32 `protobuf:"varint,6,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *VerifyAssetOwnershipResponse) Reset() { *x = VerifyAssetOwnershipResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[21] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *VerifyAssetOwnershipResponse) String() string { @@ -1543,7 +1490,7 @@ func (*VerifyAssetOwnershipResponse) ProtoMessage() {} func (x *VerifyAssetOwnershipResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[21] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1601,21 +1548,18 @@ func (x *VerifyAssetOwnershipResponse) GetBlockHeight() uint32 { } type RemoveUTXOLeaseRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The outpoint of the UTXO to remove the lease for. - Outpoint *taprpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"` + Outpoint *taprpc.OutPoint `protobuf:"bytes,1,opt,name=outpoint,proto3" json:"outpoint,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *RemoveUTXOLeaseRequest) Reset() { *x = RemoveUTXOLeaseRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[22] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *RemoveUTXOLeaseRequest) String() string { @@ -1626,7 +1570,7 @@ func (*RemoveUTXOLeaseRequest) ProtoMessage() {} func (x *RemoveUTXOLeaseRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[22] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1649,18 +1593,16 @@ func (x *RemoveUTXOLeaseRequest) GetOutpoint() *taprpc.OutPoint { } type RemoveUTXOLeaseResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *RemoveUTXOLeaseResponse) Reset() { *x = RemoveUTXOLeaseResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[23] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *RemoveUTXOLeaseResponse) String() string { @@ -1671,7 +1613,7 @@ func (*RemoveUTXOLeaseResponse) ProtoMessage() {} func (x *RemoveUTXOLeaseResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[23] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1687,20 +1629,17 @@ func (*RemoveUTXOLeaseResponse) Descriptor() ([]byte, []int) { } type DeclareScriptKeyRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + ScriptKey *taprpc.ScriptKey `protobuf:"bytes,1,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` unknownFields protoimpl.UnknownFields - - ScriptKey *taprpc.ScriptKey `protobuf:"bytes,1,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` + sizeCache protoimpl.SizeCache } func (x *DeclareScriptKeyRequest) Reset() { *x = DeclareScriptKeyRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[24] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *DeclareScriptKeyRequest) String() string { @@ -1711,7 +1650,7 @@ func (*DeclareScriptKeyRequest) ProtoMessage() {} func (x *DeclareScriptKeyRequest) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[24] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1734,20 +1673,17 @@ func (x *DeclareScriptKeyRequest) GetScriptKey() *taprpc.ScriptKey { } type DeclareScriptKeyResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + ScriptKey *taprpc.ScriptKey `protobuf:"bytes,1,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` unknownFields protoimpl.UnknownFields - - ScriptKey *taprpc.ScriptKey `protobuf:"bytes,1,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` + sizeCache protoimpl.SizeCache } func (x *DeclareScriptKeyResponse) Reset() { *x = DeclareScriptKeyResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[25] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *DeclareScriptKeyResponse) String() string { @@ -1758,7 +1694,7 @@ func (*DeclareScriptKeyResponse) ProtoMessage() {} func (x *DeclareScriptKeyResponse) ProtoReflect() protoreflect.Message { mi := &file_assetwalletrpc_assetwallet_proto_msgTypes[25] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1782,325 +1718,152 @@ func (x *DeclareScriptKeyResponse) GetScriptKey() *taprpc.ScriptKey { var File_assetwalletrpc_assetwallet_proto protoreflect.FileDescriptor -var file_assetwalletrpc_assetwallet_proto_rawDesc = []byte{ - 0x0a, 0x20, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, - 0x2f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x12, 0x0e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 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, 0xb4, 0x01, 0x0a, 0x16, 0x46, 0x75, 0x6e, 0x64, - 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x14, 0x0a, 0x04, 0x70, 0x73, 0x62, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, - 0x48, 0x00, 0x52, 0x04, 0x70, 0x73, 0x62, 0x74, 0x12, 0x2e, 0x0a, 0x03, 0x72, 0x61, 0x77, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, - 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x78, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, - 0x65, 0x48, 0x00, 0x52, 0x03, 0x72, 0x61, 0x77, 0x12, 0x48, 0x0a, 0x10, 0x63, 0x6f, 0x69, 0x6e, - 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x54, 0x79, - 0x70, 0x65, 0x52, 0x0e, 0x63, 0x6f, 0x69, 0x6e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x54, 0x79, - 0x70, 0x65, 0x42, 0x0a, 0x0a, 0x08, 0x74, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x22, 0x9a, - 0x01, 0x0a, 0x17, 0x46, 0x75, 0x6e, 0x64, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, - 0x62, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x75, - 0x6e, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x0a, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, 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, 0x2e, 0x0a, 0x13, 0x70, - 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x70, 0x73, 0x62, - 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x11, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, - 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x73, 0x62, 0x74, 0x73, 0x22, 0xc7, 0x01, 0x0a, 0x0a, - 0x54, 0x78, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x69, 0x6e, - 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x65, 0x76, - 0x49, 0x64, 0x52, 0x06, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x4a, 0x0a, 0x0a, 0x72, 0x65, - 0x63, 0x69, 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, - 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x54, 0x78, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x61, 0x74, 0x65, 0x2e, 0x52, 0x65, 0x63, 0x69, 0x70, - 0x69, 0x65, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x72, 0x65, 0x63, 0x69, - 0x70, 0x69, 0x65, 0x6e, 0x74, 0x73, 0x1a, 0x3d, 0x0a, 0x0f, 0x52, 0x65, 0x63, 0x69, 0x70, 0x69, - 0x65, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x65, 0x0a, 0x06, 0x50, 0x72, 0x65, 0x76, 0x49, 0x64, 0x12, - 0x2c, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x01, 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, 0x12, 0x0e, 0x0a, - 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 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, 0x22, 0x39, 0x0a, 0x16, - 0x53, 0x69, 0x67, 0x6e, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x75, 0x6e, 0x64, 0x65, 0x64, - 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x66, 0x75, 0x6e, - 0x64, 0x65, 0x64, 0x50, 0x73, 0x62, 0x74, 0x22, 0x5f, 0x0a, 0x17, 0x53, 0x69, 0x67, 0x6e, 0x56, - 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x70, 0x73, 0x62, - 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x50, - 0x73, 0x62, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x69, 0x6e, - 0x70, 0x75, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x0c, 0x73, 0x69, 0x67, 0x6e, - 0x65, 0x64, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x22, 0x40, 0x0a, 0x19, 0x41, 0x6e, 0x63, 0x68, - 0x6f, 0x72, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, - 0x5f, 0x70, 0x73, 0x62, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0c, 0x76, 0x69, - 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x73, 0x22, 0xc5, 0x03, 0x0a, 0x19, 0x43, - 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x69, 0x72, 0x74, - 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0c, 0x52, - 0x0c, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x73, 0x12, 0x2e, 0x0a, - 0x13, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x70, - 0x73, 0x62, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x11, 0x70, 0x61, 0x73, 0x73, - 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x73, 0x62, 0x74, 0x73, 0x12, 0x1f, 0x0a, - 0x0b, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x0a, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x50, 0x73, 0x62, 0x74, 0x12, 0x34, - 0x0a, 0x15, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, - 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, - 0x13, 0x65, 0x78, 0x69, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, - 0x6e, 0x64, 0x65, 0x78, 0x12, 0x12, 0x0a, 0x03, 0x61, 0x64, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x08, 0x48, 0x00, 0x52, 0x03, 0x61, 0x64, 0x64, 0x12, 0x21, 0x0a, 0x0b, 0x74, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x48, 0x01, 0x52, - 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x12, 0x24, 0x0a, 0x0d, 0x73, - 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x62, 0x79, 0x74, 0x65, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x04, 0x48, 0x01, 0x52, 0x0b, 0x73, 0x61, 0x74, 0x50, 0x65, 0x72, 0x56, 0x62, 0x79, 0x74, - 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, - 0x5f, 0x69, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x63, 0x75, 0x73, 0x74, 0x6f, - 0x6d, 0x4c, 0x6f, 0x63, 0x6b, 0x49, 0x64, 0x12, 0x36, 0x0a, 0x17, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, - 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, - 0x64, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x04, 0x52, 0x15, 0x6c, 0x6f, 0x63, 0x6b, 0x45, 0x78, - 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, - 0x21, 0x0a, 0x0c, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x18, - 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x73, 0x6b, 0x69, 0x70, 0x46, 0x75, 0x6e, 0x64, 0x69, - 0x6e, 0x67, 0x42, 0x16, 0x0a, 0x14, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x63, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x42, 0x06, 0x0a, 0x04, 0x66, 0x65, - 0x65, 0x73, 0x22, 0xfe, 0x01, 0x0a, 0x1a, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x56, 0x69, 0x72, - 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 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, 0x23, 0x0a, 0x0d, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x73, - 0x62, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0c, 0x76, 0x69, 0x72, 0x74, 0x75, - 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x70, 0x61, 0x73, 0x73, 0x69, - 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x73, 0x18, 0x04, - 0x20, 0x03, 0x28, 0x0c, 0x52, 0x11, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x50, 0x73, 0x62, 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x68, 0x61, 0x6e, 0x67, - 0x65, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x75, 0x74, 0x70, - 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x3a, 0x0a, 0x10, 0x6c, 0x6e, 0x64, 0x5f, 0x6c, - 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x5f, 0x75, 0x74, 0x78, 0x6f, 0x73, 0x18, 0x06, 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, 0x22, 0xc7, 0x02, 0x0a, 0x14, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x41, - 0x6e, 0x64, 0x4c, 0x6f, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 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, 0x23, 0x0a, - 0x0d, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0c, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, - 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, - 0x11, 0x70, 0x61, 0x73, 0x73, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x73, 0x62, - 0x74, 0x73, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x5f, 0x6f, 0x75, 0x74, - 0x70, 0x75, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x11, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, - 0x65, 0x78, 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, 0x37, - 0x0a, 0x18, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x5f, 0x74, 0x78, - 0x5f, 0x62, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x15, 0x73, 0x6b, 0x69, 0x70, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x54, 0x78, 0x42, 0x72, - 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x22, 0x37, 0x0a, - 0x16, 0x4e, 0x65, 0x78, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x66, - 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x6b, 0x65, 0x79, - 0x46, 0x61, 0x6d, 0x69, 0x6c, 0x79, 0x22, 0x53, 0x0a, 0x17, 0x4e, 0x65, 0x78, 0x74, 0x49, 0x6e, - 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x38, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 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, 0x0b, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x22, 0x35, 0x0a, 0x14, 0x4e, - 0x65, 0x78, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6b, 0x65, 0x79, 0x5f, 0x66, 0x61, 0x6d, 0x69, 0x6c, - 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x6b, 0x65, 0x79, 0x46, 0x61, 0x6d, 0x69, - 0x6c, 0x79, 0x22, 0x49, 0x0a, 0x15, 0x4e, 0x65, 0x78, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 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, 0x3c, 0x0a, - 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, - 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x22, 0x54, 0x0a, 0x18, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x38, 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 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, 0x0b, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, - 0x79, 0x22, 0x45, 0x0a, 0x15, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x74, 0x77, - 0x65, 0x61, 0x6b, 0x65, 0x64, 0x5f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x74, 0x77, 0x65, 0x61, 0x6b, 0x65, 0x64, 0x53, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x22, 0x4a, 0x0a, 0x16, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, - 0x18, 0x01, 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, 0xa2, 0x01, 0x0a, 0x1a, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 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, 0x12, 0x1c, 0x0a, 0x09, 0x63, - 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, - 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, 0x22, 0x4b, 0x0a, 0x1b, 0x50, 0x72, 0x6f, - 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x6f, - 0x66, 0x5f, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x57, 0x69, 0x74, 0x68, 0x57, - 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x22, 0x69, 0x0a, 0x1b, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x77, - 0x69, 0x74, 0x68, 0x5f, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x57, 0x69, 0x74, 0x68, 0x57, 0x69, 0x74, 0x6e, - 0x65, 0x73, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6c, 0x6c, 0x65, 0x6e, 0x67, - 0x65, 0x22, 0xf8, 0x01, 0x0a, 0x1c, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x6f, - 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x72, - 0x6f, 0x6f, 0x66, 0x12, 0x2c, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, - 0x02, 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, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x5f, 0x73, 0x74, - 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, - 0x74, 0x53, 0x74, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, - 0x73, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, - 0x61, 0x73, 0x68, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x68, 0x61, 0x73, - 0x68, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x62, 0x6c, 0x6f, - 0x63, 0x6b, 0x48, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 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, 0x22, 0x46, 0x0a, 0x16, - 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x55, 0x54, 0x58, 0x4f, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2c, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, - 0x6e, 0x74, 0x18, 0x01, 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, 0x19, 0x0a, 0x17, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x55, 0x54, - 0x58, 0x4f, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x4b, 0x0a, 0x17, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 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, 0x4c, 0x0a, 0x18, - 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 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, 0x2a, 0x6b, 0x0a, 0x0e, 0x43, 0x6f, - 0x69, 0x6e, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x13, - 0x43, 0x4f, 0x49, 0x4e, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x5f, 0x44, 0x45, 0x46, 0x41, - 0x55, 0x4c, 0x54, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x43, 0x4f, 0x49, 0x4e, 0x5f, 0x53, 0x45, - 0x4c, 0x45, 0x43, 0x54, 0x5f, 0x42, 0x49, 0x50, 0x38, 0x36, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, - 0x01, 0x12, 0x24, 0x0a, 0x20, 0x43, 0x4f, 0x49, 0x4e, 0x5f, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, - 0x5f, 0x53, 0x43, 0x52, 0x49, 0x50, 0x54, 0x5f, 0x54, 0x52, 0x45, 0x45, 0x53, 0x5f, 0x41, 0x4c, - 0x4c, 0x4f, 0x57, 0x45, 0x44, 0x10, 0x02, 0x32, 0xb0, 0x0a, 0x0a, 0x0b, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x57, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x12, 0x62, 0x0a, 0x0f, 0x46, 0x75, 0x6e, 0x64, 0x56, - 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x12, 0x26, 0x2e, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, - 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, - 0x73, 0x62, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x0f, 0x53, - 0x69, 0x67, 0x6e, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x12, 0x26, - 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, - 0x53, 0x69, 0x67, 0x6e, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, - 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x56, 0x69, 0x72, 0x74, - 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x5a, 0x0a, 0x12, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, - 0x50, 0x73, 0x62, 0x74, 0x73, 0x12, 0x29, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, - 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x56, 0x69, 0x72, - 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x73, 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, 0x6b, 0x0a, 0x12, 0x43, - 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, - 0x73, 0x12, 0x29, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, - 0x50, 0x73, 0x62, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x43, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x15, 0x50, 0x75, 0x62, 0x6c, - 0x69, 0x73, 0x68, 0x41, 0x6e, 0x64, 0x4c, 0x6f, 0x67, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, - 0x72, 0x12, 0x24, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x41, 0x6e, 0x64, 0x4c, 0x6f, 0x67, - 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, 0x62, 0x0a, 0x0f, 0x4e, 0x65, 0x78, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x26, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, - 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x65, 0x78, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4e, - 0x65, 0x78, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5c, 0x0a, 0x0d, 0x4e, 0x65, 0x78, 0x74, 0x53, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x24, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, - 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x65, 0x78, 0x74, 0x53, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4e, - 0x65, 0x78, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x10, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x27, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, - 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x28, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, - 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5f, 0x0a, 0x0e, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x25, 0x2e, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, - 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x13, - 0x50, 0x72, 0x6f, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, - 0x68, 0x69, 0x70, 0x12, 0x2a, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, - 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x2b, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, - 0x73, 0x68, 0x69, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x71, 0x0a, 0x14, - 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, - 0x73, 0x68, 0x69, 0x70, 0x12, 0x2b, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, - 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x2c, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, - 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4f, 0x77, - 0x6e, 0x65, 0x72, 0x73, 0x68, 0x69, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x62, 0x0a, 0x0f, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x55, 0x54, 0x58, 0x4f, 0x4c, 0x65, 0x61, - 0x73, 0x65, 0x12, 0x26, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, - 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x55, 0x54, 0x58, 0x4f, 0x4c, 0x65, - 0x61, 0x73, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x6d, 0x6f, - 0x76, 0x65, 0x55, 0x54, 0x58, 0x4f, 0x4c, 0x65, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x10, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x53, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x27, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, - 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, - 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x28, 0x2e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x44, 0x65, 0x63, 0x6c, 0x61, 0x72, 0x65, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, - 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3f, 0x5a, 0x3d, 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, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x77, 0x61, 0x6c, 0x6c, 0x65, 0x74, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x33, -} +const file_assetwalletrpc_assetwallet_proto_rawDesc = "" + + "\n" + + " assetwalletrpc/assetwallet.proto\x12\x0eassetwalletrpc\x1a\x13taprootassets.proto\"\xb4\x01\n" + + "\x16FundVirtualPsbtRequest\x12\x14\n" + + "\x04psbt\x18\x01 \x01(\fH\x00R\x04psbt\x12.\n" + + "\x03raw\x18\x02 \x01(\v2\x1a.assetwalletrpc.TxTemplateH\x00R\x03raw\x12H\n" + + "\x10coin_select_type\x18\x03 \x01(\x0e2\x1e.assetwalletrpc.CoinSelectTypeR\x0ecoinSelectTypeB\n" + + "\n" + + "\btemplate\"\x9a\x01\n" + + "\x17FundVirtualPsbtResponse\x12\x1f\n" + + "\vfunded_psbt\x18\x01 \x01(\fR\n" + + "fundedPsbt\x12.\n" + + "\x13change_output_index\x18\x02 \x01(\x05R\x11changeOutputIndex\x12.\n" + + "\x13passive_asset_psbts\x18\x03 \x03(\fR\x11passiveAssetPsbts\"\xc7\x01\n" + + "\n" + + "TxTemplate\x12.\n" + + "\x06inputs\x18\x01 \x03(\v2\x16.assetwalletrpc.PrevIdR\x06inputs\x12J\n" + + "\n" + + "recipients\x18\x02 \x03(\v2*.assetwalletrpc.TxTemplate.RecipientsEntryR\n" + + "recipients\x1a=\n" + + "\x0fRecipientsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01\"e\n" + + "\x06PrevId\x12,\n" + + "\boutpoint\x18\x01 \x01(\v2\x10.taprpc.OutPointR\boutpoint\x12\x0e\n" + + "\x02id\x18\x02 \x01(\fR\x02id\x12\x1d\n" + + "\n" + + "script_key\x18\x03 \x01(\fR\tscriptKey\"9\n" + + "\x16SignVirtualPsbtRequest\x12\x1f\n" + + "\vfunded_psbt\x18\x01 \x01(\fR\n" + + "fundedPsbt\"_\n" + + "\x17SignVirtualPsbtResponse\x12\x1f\n" + + "\vsigned_psbt\x18\x01 \x01(\fR\n" + + "signedPsbt\x12#\n" + + "\rsigned_inputs\x18\x02 \x03(\rR\fsignedInputs\"@\n" + + "\x19AnchorVirtualPsbtsRequest\x12#\n" + + "\rvirtual_psbts\x18\x01 \x03(\fR\fvirtualPsbts\"\xc5\x03\n" + + "\x19CommitVirtualPsbtsRequest\x12#\n" + + "\rvirtual_psbts\x18\x01 \x03(\fR\fvirtualPsbts\x12.\n" + + "\x13passive_asset_psbts\x18\x02 \x03(\fR\x11passiveAssetPsbts\x12\x1f\n" + + "\vanchor_psbt\x18\x03 \x01(\fR\n" + + "anchorPsbt\x124\n" + + "\x15existing_output_index\x18\x04 \x01(\x05H\x00R\x13existingOutputIndex\x12\x12\n" + + "\x03add\x18\x05 \x01(\bH\x00R\x03add\x12!\n" + + "\vtarget_conf\x18\x06 \x01(\rH\x01R\n" + + "targetConf\x12$\n" + + "\rsat_per_vbyte\x18\a \x01(\x04H\x01R\vsatPerVbyte\x12$\n" + + "\x0ecustom_lock_id\x18\b \x01(\fR\fcustomLockId\x126\n" + + "\x17lock_expiration_seconds\x18\t \x01(\x04R\x15lockExpirationSeconds\x12!\n" + + "\fskip_funding\x18\n" + + " \x01(\bR\vskipFundingB\x16\n" + + "\x14anchor_change_outputB\x06\n" + + "\x04fees\"\xfe\x01\n" + + "\x1aCommitVirtualPsbtsResponse\x12\x1f\n" + + "\vanchor_psbt\x18\x01 \x01(\fR\n" + + "anchorPsbt\x12#\n" + + "\rvirtual_psbts\x18\x02 \x03(\fR\fvirtualPsbts\x12.\n" + + "\x13passive_asset_psbts\x18\x04 \x03(\fR\x11passiveAssetPsbts\x12.\n" + + "\x13change_output_index\x18\x05 \x01(\x05R\x11changeOutputIndex\x12:\n" + + "\x10lnd_locked_utxos\x18\x06 \x03(\v2\x10.taprpc.OutPointR\x0elndLockedUtxos\"\xc7\x02\n" + + "\x14PublishAndLogRequest\x12\x1f\n" + + "\vanchor_psbt\x18\x01 \x01(\fR\n" + + "anchorPsbt\x12#\n" + + "\rvirtual_psbts\x18\x02 \x03(\fR\fvirtualPsbts\x12.\n" + + "\x13passive_asset_psbts\x18\x03 \x03(\fR\x11passiveAssetPsbts\x12.\n" + + "\x13change_output_index\x18\x04 \x01(\x05R\x11changeOutputIndex\x12:\n" + + "\x10lnd_locked_utxos\x18\x05 \x03(\v2\x10.taprpc.OutPointR\x0elndLockedUtxos\x127\n" + + "\x18skip_anchor_tx_broadcast\x18\x06 \x01(\bR\x15skipAnchorTxBroadcast\x12\x14\n" + + "\x05label\x18\a \x01(\tR\x05label\"7\n" + + "\x16NextInternalKeyRequest\x12\x1d\n" + + "\n" + + "key_family\x18\x01 \x01(\rR\tkeyFamily\"S\n" + + "\x17NextInternalKeyResponse\x128\n" + + "\finternal_key\x18\x01 \x01(\v2\x15.taprpc.KeyDescriptorR\vinternalKey\"5\n" + + "\x14NextScriptKeyRequest\x12\x1d\n" + + "\n" + + "key_family\x18\x01 \x01(\rR\tkeyFamily\"I\n" + + "\x15NextScriptKeyResponse\x120\n" + + "\n" + + "script_key\x18\x01 \x01(\v2\x11.taprpc.ScriptKeyR\tscriptKey\"<\n" + + "\x17QueryInternalKeyRequest\x12!\n" + + "\finternal_key\x18\x01 \x01(\fR\vinternalKey\"T\n" + + "\x18QueryInternalKeyResponse\x128\n" + + "\finternal_key\x18\x01 \x01(\v2\x15.taprpc.KeyDescriptorR\vinternalKey\"E\n" + + "\x15QueryScriptKeyRequest\x12,\n" + + "\x12tweaked_script_key\x18\x01 \x01(\fR\x10tweakedScriptKey\"J\n" + + "\x16QueryScriptKeyResponse\x120\n" + + "\n" + + "script_key\x18\x01 \x01(\v2\x11.taprpc.ScriptKeyR\tscriptKey\"\xa2\x01\n" + + "\x1aProveAssetOwnershipRequest\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12\x1d\n" + + "\n" + + "script_key\x18\x02 \x01(\fR\tscriptKey\x12,\n" + + "\boutpoint\x18\x03 \x01(\v2\x10.taprpc.OutPointR\boutpoint\x12\x1c\n" + + "\tchallenge\x18\x04 \x01(\fR\tchallenge\"K\n" + + "\x1bProveAssetOwnershipResponse\x12,\n" + + "\x12proof_with_witness\x18\x01 \x01(\fR\x10proofWithWitness\"i\n" + + "\x1bVerifyAssetOwnershipRequest\x12,\n" + + "\x12proof_with_witness\x18\x01 \x01(\fR\x10proofWithWitness\x12\x1c\n" + + "\tchallenge\x18\x02 \x01(\fR\tchallenge\"\xf8\x01\n" + + "\x1cVerifyAssetOwnershipResponse\x12\x1f\n" + + "\vvalid_proof\x18\x01 \x01(\bR\n" + + "validProof\x12,\n" + + "\boutpoint\x18\x02 \x01(\v2\x10.taprpc.OutPointR\boutpoint\x12!\n" + + "\foutpoint_str\x18\x03 \x01(\tR\voutpointStr\x12\x1d\n" + + "\n" + + "block_hash\x18\x04 \x01(\fR\tblockHash\x12$\n" + + "\x0eblock_hash_str\x18\x05 \x01(\tR\fblockHashStr\x12!\n" + + "\fblock_height\x18\x06 \x01(\rR\vblockHeight\"F\n" + + "\x16RemoveUTXOLeaseRequest\x12,\n" + + "\boutpoint\x18\x01 \x01(\v2\x10.taprpc.OutPointR\boutpoint\"\x19\n" + + "\x17RemoveUTXOLeaseResponse\"K\n" + + "\x17DeclareScriptKeyRequest\x120\n" + + "\n" + + "script_key\x18\x01 \x01(\v2\x11.taprpc.ScriptKeyR\tscriptKey\"L\n" + + "\x18DeclareScriptKeyResponse\x120\n" + + "\n" + + "script_key\x18\x01 \x01(\v2\x11.taprpc.ScriptKeyR\tscriptKey*k\n" + + "\x0eCoinSelectType\x12\x17\n" + + "\x13COIN_SELECT_DEFAULT\x10\x00\x12\x1a\n" + + "\x16COIN_SELECT_BIP86_ONLY\x10\x01\x12$\n" + + " COIN_SELECT_SCRIPT_TREES_ALLOWED\x10\x022\xb0\n" + + "\n" + + "\vAssetWallet\x12b\n" + + "\x0fFundVirtualPsbt\x12&.assetwalletrpc.FundVirtualPsbtRequest\x1a'.assetwalletrpc.FundVirtualPsbtResponse\x12b\n" + + "\x0fSignVirtualPsbt\x12&.assetwalletrpc.SignVirtualPsbtRequest\x1a'.assetwalletrpc.SignVirtualPsbtResponse\x12Z\n" + + "\x12AnchorVirtualPsbts\x12).assetwalletrpc.AnchorVirtualPsbtsRequest\x1a\x19.taprpc.SendAssetResponse\x12k\n" + + "\x12CommitVirtualPsbts\x12).assetwalletrpc.CommitVirtualPsbtsRequest\x1a*.assetwalletrpc.CommitVirtualPsbtsResponse\x12X\n" + + "\x15PublishAndLogTransfer\x12$.assetwalletrpc.PublishAndLogRequest\x1a\x19.taprpc.SendAssetResponse\x12b\n" + + "\x0fNextInternalKey\x12&.assetwalletrpc.NextInternalKeyRequest\x1a'.assetwalletrpc.NextInternalKeyResponse\x12\\\n" + + "\rNextScriptKey\x12$.assetwalletrpc.NextScriptKeyRequest\x1a%.assetwalletrpc.NextScriptKeyResponse\x12e\n" + + "\x10QueryInternalKey\x12'.assetwalletrpc.QueryInternalKeyRequest\x1a(.assetwalletrpc.QueryInternalKeyResponse\x12_\n" + + "\x0eQueryScriptKey\x12%.assetwalletrpc.QueryScriptKeyRequest\x1a&.assetwalletrpc.QueryScriptKeyResponse\x12n\n" + + "\x13ProveAssetOwnership\x12*.assetwalletrpc.ProveAssetOwnershipRequest\x1a+.assetwalletrpc.ProveAssetOwnershipResponse\x12q\n" + + "\x14VerifyAssetOwnership\x12+.assetwalletrpc.VerifyAssetOwnershipRequest\x1a,.assetwalletrpc.VerifyAssetOwnershipResponse\x12b\n" + + "\x0fRemoveUTXOLease\x12&.assetwalletrpc.RemoveUTXOLeaseRequest\x1a'.assetwalletrpc.RemoveUTXOLeaseResponse\x12e\n" + + "\x10DeclareScriptKey\x12'.assetwalletrpc.DeclareScriptKeyRequest\x1a(.assetwalletrpc.DeclareScriptKeyResponseB?Z=github.com/lightninglabs/taproot-assets/taprpc/assetwalletrpcb\x06proto3" var ( file_assetwalletrpc_assetwallet_proto_rawDescOnce sync.Once - file_assetwalletrpc_assetwallet_proto_rawDescData = file_assetwalletrpc_assetwallet_proto_rawDesc + file_assetwalletrpc_assetwallet_proto_rawDescData []byte ) func file_assetwalletrpc_assetwallet_proto_rawDescGZIP() []byte { file_assetwalletrpc_assetwallet_proto_rawDescOnce.Do(func() { - file_assetwalletrpc_assetwallet_proto_rawDescData = protoimpl.X.CompressGZIP(file_assetwalletrpc_assetwallet_proto_rawDescData) + file_assetwalletrpc_assetwallet_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_assetwalletrpc_assetwallet_proto_rawDesc), len(file_assetwalletrpc_assetwallet_proto_rawDesc))) }) return file_assetwalletrpc_assetwallet_proto_rawDescData } @@ -2196,320 +1959,6 @@ func file_assetwalletrpc_assetwallet_proto_init() { if File_assetwalletrpc_assetwallet_proto != nil { return } - if !protoimpl.UnsafeEnabled { - file_assetwalletrpc_assetwallet_proto_msgTypes[0].Exporter = func(v any, i int) any { - switch v := v.(*FundVirtualPsbtRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[1].Exporter = func(v any, i int) any { - switch v := v.(*FundVirtualPsbtResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[2].Exporter = func(v any, i int) any { - switch v := v.(*TxTemplate); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[3].Exporter = func(v any, i int) any { - switch v := v.(*PrevId); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[4].Exporter = func(v any, i int) any { - switch v := v.(*SignVirtualPsbtRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[5].Exporter = func(v any, i int) any { - switch v := v.(*SignVirtualPsbtResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[6].Exporter = func(v any, i int) any { - switch v := v.(*AnchorVirtualPsbtsRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[7].Exporter = func(v any, i int) any { - switch v := v.(*CommitVirtualPsbtsRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[8].Exporter = func(v any, i int) any { - switch v := v.(*CommitVirtualPsbtsResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[9].Exporter = func(v any, i int) any { - switch v := v.(*PublishAndLogRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[10].Exporter = func(v any, i int) any { - switch v := v.(*NextInternalKeyRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[11].Exporter = func(v any, i int) any { - switch v := v.(*NextInternalKeyResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[12].Exporter = func(v any, i int) any { - switch v := v.(*NextScriptKeyRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[13].Exporter = func(v any, i int) any { - switch v := v.(*NextScriptKeyResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[14].Exporter = func(v any, i int) any { - switch v := v.(*QueryInternalKeyRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[15].Exporter = func(v any, i int) any { - switch v := v.(*QueryInternalKeyResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[16].Exporter = func(v any, i int) any { - switch v := v.(*QueryScriptKeyRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[17].Exporter = func(v any, i int) any { - switch v := v.(*QueryScriptKeyResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[18].Exporter = func(v any, i int) any { - switch v := v.(*ProveAssetOwnershipRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[19].Exporter = func(v any, i int) any { - switch v := v.(*ProveAssetOwnershipResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[20].Exporter = func(v any, i int) any { - switch v := v.(*VerifyAssetOwnershipRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[21].Exporter = func(v any, i int) any { - switch v := v.(*VerifyAssetOwnershipResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[22].Exporter = func(v any, i int) any { - switch v := v.(*RemoveUTXOLeaseRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[23].Exporter = func(v any, i int) any { - switch v := v.(*RemoveUTXOLeaseResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[24].Exporter = func(v any, i int) any { - switch v := v.(*DeclareScriptKeyRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_assetwalletrpc_assetwallet_proto_msgTypes[25].Exporter = func(v any, i int) any { - switch v := v.(*DeclareScriptKeyResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - } file_assetwalletrpc_assetwallet_proto_msgTypes[0].OneofWrappers = []any{ (*FundVirtualPsbtRequest_Psbt)(nil), (*FundVirtualPsbtRequest_Raw)(nil), @@ -2524,7 +1973,7 @@ func file_assetwalletrpc_assetwallet_proto_init() { out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_assetwalletrpc_assetwallet_proto_rawDesc, + RawDescriptor: unsafe.Slice(unsafe.StringData(file_assetwalletrpc_assetwallet_proto_rawDesc), len(file_assetwalletrpc_assetwallet_proto_rawDesc)), NumEnums: 1, NumMessages: 27, NumExtensions: 0, @@ -2536,7 +1985,6 @@ func file_assetwalletrpc_assetwallet_proto_init() { MessageInfos: file_assetwalletrpc_assetwallet_proto_msgTypes, }.Build() File_assetwalletrpc_assetwallet_proto = out.File - file_assetwalletrpc_assetwallet_proto_rawDesc = nil file_assetwalletrpc_assetwallet_proto_goTypes = nil file_assetwalletrpc_assetwallet_proto_depIdxs = nil } diff --git a/taprpc/assetwalletrpc/assetwallet.pb.gw.go b/taprpc/assetwalletrpc/assetwallet.pb.gw.go index 9f3ce0722..2ab469256 100644 --- a/taprpc/assetwalletrpc/assetwallet.pb.gw.go +++ b/taprpc/assetwalletrpc/assetwallet.pb.gw.go @@ -10,6 +10,7 @@ package assetwalletrpc import ( "context" + "errors" "io" "net/http" @@ -24,418 +25,367 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = metadata.Join +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = errors.New + _ = runtime.String + _ = utilities.NewDoubleArray + _ = metadata.Join +) func request_AssetWallet_FundVirtualPsbt_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq FundVirtualPsbtRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq FundVirtualPsbtRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.FundVirtualPsbt(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_FundVirtualPsbt_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq FundVirtualPsbtRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq FundVirtualPsbtRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.FundVirtualPsbt(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_SignVirtualPsbt_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq SignVirtualPsbtRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SignVirtualPsbtRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.SignVirtualPsbt(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_SignVirtualPsbt_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq SignVirtualPsbtRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SignVirtualPsbtRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.SignVirtualPsbt(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_AnchorVirtualPsbts_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AnchorVirtualPsbtsRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq AnchorVirtualPsbtsRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.AnchorVirtualPsbts(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_AnchorVirtualPsbts_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AnchorVirtualPsbtsRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq AnchorVirtualPsbtsRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.AnchorVirtualPsbts(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_CommitVirtualPsbts_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq CommitVirtualPsbtsRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq CommitVirtualPsbtsRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.CommitVirtualPsbts(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_CommitVirtualPsbts_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq CommitVirtualPsbtsRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq CommitVirtualPsbtsRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.CommitVirtualPsbts(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_PublishAndLogTransfer_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq PublishAndLogRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq PublishAndLogRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.PublishAndLogTransfer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_PublishAndLogTransfer_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq PublishAndLogRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq PublishAndLogRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.PublishAndLogTransfer(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_NextInternalKey_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq NextInternalKeyRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq NextInternalKeyRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.NextInternalKey(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_NextInternalKey_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq NextInternalKeyRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq NextInternalKeyRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.NextInternalKey(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_NextScriptKey_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq NextScriptKeyRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq NextScriptKeyRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.NextScriptKey(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_NextScriptKey_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq NextScriptKeyRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq NextScriptKeyRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.NextScriptKey(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_QueryInternalKey_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryInternalKeyRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq QueryInternalKeyRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["internal_key"] + io.Copy(io.Discard, req.Body) + val, ok := pathParams["internal_key"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "internal_key") } - protoReq.InternalKey, err = runtime.Bytes(val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "internal_key", err) } - msg, err := client.QueryInternalKey(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_QueryInternalKey_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryInternalKeyRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq QueryInternalKeyRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["internal_key"] + val, ok := pathParams["internal_key"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "internal_key") } - protoReq.InternalKey, err = runtime.Bytes(val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "internal_key", err) } - msg, err := server.QueryInternalKey(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_QueryScriptKey_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryScriptKeyRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq QueryScriptKeyRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["tweaked_script_key"] + io.Copy(io.Discard, req.Body) + val, ok := pathParams["tweaked_script_key"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "tweaked_script_key") } - protoReq.TweakedScriptKey, err = runtime.Bytes(val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "tweaked_script_key", err) } - msg, err := client.QueryScriptKey(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_QueryScriptKey_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryScriptKeyRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq QueryScriptKeyRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["tweaked_script_key"] + val, ok := pathParams["tweaked_script_key"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "tweaked_script_key") } - protoReq.TweakedScriptKey, err = runtime.Bytes(val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "tweaked_script_key", err) } - msg, err := server.QueryScriptKey(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_ProveAssetOwnership_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ProveAssetOwnershipRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq ProveAssetOwnershipRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.ProveAssetOwnership(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_ProveAssetOwnership_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ProveAssetOwnershipRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq ProveAssetOwnershipRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.ProveAssetOwnership(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_VerifyAssetOwnership_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq VerifyAssetOwnershipRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq VerifyAssetOwnershipRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.VerifyAssetOwnership(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_VerifyAssetOwnership_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq VerifyAssetOwnershipRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq VerifyAssetOwnershipRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.VerifyAssetOwnership(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_RemoveUTXOLease_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq RemoveUTXOLeaseRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq RemoveUTXOLeaseRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.RemoveUTXOLease(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_RemoveUTXOLease_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq RemoveUTXOLeaseRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq RemoveUTXOLeaseRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.RemoveUTXOLease(ctx, &protoReq) return msg, metadata, err - } func request_AssetWallet_DeclareScriptKey_0(ctx context.Context, marshaler runtime.Marshaler, client AssetWalletClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DeclareScriptKeyRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq DeclareScriptKeyRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.DeclareScriptKey(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_AssetWallet_DeclareScriptKey_0(ctx context.Context, marshaler runtime.Marshaler, server AssetWalletServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DeclareScriptKeyRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq DeclareScriptKeyRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.DeclareScriptKey(ctx, &protoReq) return msg, metadata, err - } // RegisterAssetWalletHandlerServer registers the http handlers for service AssetWallet to "mux". // UnaryRPC :call AssetWalletServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterAssetWalletHandlerFromEndpoint instead. +// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call. func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AssetWalletServer) error { - - mux.Handle("POST", pattern_AssetWallet_FundVirtualPsbt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_FundVirtualPsbt_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, "/assetwalletrpc.AssetWallet/FundVirtualPsbt", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/fund")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/FundVirtualPsbt", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/fund")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -447,20 +397,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_FundVirtualPsbt_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_SignVirtualPsbt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_SignVirtualPsbt_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, "/assetwalletrpc.AssetWallet/SignVirtualPsbt", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/sign")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/SignVirtualPsbt", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/sign")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -472,20 +417,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_SignVirtualPsbt_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_AnchorVirtualPsbts_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_AnchorVirtualPsbts_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, "/assetwalletrpc.AssetWallet/AnchorVirtualPsbts", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/anchor")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/AnchorVirtualPsbts", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/anchor")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -497,20 +437,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_AnchorVirtualPsbts_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_CommitVirtualPsbts_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_CommitVirtualPsbts_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, "/assetwalletrpc.AssetWallet/CommitVirtualPsbts", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/commit")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/CommitVirtualPsbts", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/commit")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -522,20 +457,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_CommitVirtualPsbts_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_PublishAndLogTransfer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_PublishAndLogTransfer_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, "/assetwalletrpc.AssetWallet/PublishAndLogTransfer", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/log-transfer")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/PublishAndLogTransfer", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/log-transfer")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -547,20 +477,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_PublishAndLogTransfer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_NextInternalKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_NextInternalKey_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, "/assetwalletrpc.AssetWallet/NextInternalKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/internal-key/next")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/NextInternalKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/internal-key/next")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -572,20 +497,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_NextInternalKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_NextScriptKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_NextScriptKey_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, "/assetwalletrpc.AssetWallet/NextScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/next")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/NextScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/next")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -597,20 +517,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_NextScriptKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_AssetWallet_QueryInternalKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_AssetWallet_QueryInternalKey_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, "/assetwalletrpc.AssetWallet/QueryInternalKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/internal-key/{internal_key}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/QueryInternalKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/internal-key/{internal_key}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -622,20 +537,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_QueryInternalKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_AssetWallet_QueryScriptKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_AssetWallet_QueryScriptKey_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, "/assetwalletrpc.AssetWallet/QueryScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/{tweaked_script_key}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/QueryScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/{tweaked_script_key}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -647,20 +557,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_QueryScriptKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_ProveAssetOwnership_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_ProveAssetOwnership_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, "/assetwalletrpc.AssetWallet/ProveAssetOwnership", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/ownership/prove")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/ProveAssetOwnership", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/ownership/prove")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -672,20 +577,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_ProveAssetOwnership_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_VerifyAssetOwnership_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_VerifyAssetOwnership_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, "/assetwalletrpc.AssetWallet/VerifyAssetOwnership", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/ownership/verify")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/VerifyAssetOwnership", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/ownership/verify")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -697,20 +597,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_VerifyAssetOwnership_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_RemoveUTXOLease_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_RemoveUTXOLease_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, "/assetwalletrpc.AssetWallet/RemoveUTXOLease", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/utxo-lease/delete")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/RemoveUTXOLease", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/utxo-lease/delete")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -722,20 +617,15 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_RemoveUTXOLease_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_DeclareScriptKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_DeclareScriptKey_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, "/assetwalletrpc.AssetWallet/DeclareScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/declare")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/DeclareScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/declare")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -747,9 +637,7 @@ func RegisterAssetWalletHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_DeclareScriptKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil @@ -776,7 +664,6 @@ func RegisterAssetWalletHandlerFromEndpoint(ctx context.Context, mux *runtime.Se } }() }() - return RegisterAssetWalletHandler(ctx, mux, conn) } @@ -790,16 +677,13 @@ func RegisterAssetWalletHandler(ctx context.Context, mux *runtime.ServeMux, conn // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AssetWalletClient". // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AssetWalletClient" // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "AssetWalletClient" to call the correct interceptors. +// "AssetWalletClient" to call the correct interceptors. This client ignores the HTTP middlewares. func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AssetWalletClient) error { - - mux.Handle("POST", pattern_AssetWallet_FundVirtualPsbt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_FundVirtualPsbt_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, "/assetwalletrpc.AssetWallet/FundVirtualPsbt", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/fund")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/FundVirtualPsbt", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/fund")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -810,18 +694,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_FundVirtualPsbt_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_SignVirtualPsbt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_SignVirtualPsbt_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, "/assetwalletrpc.AssetWallet/SignVirtualPsbt", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/sign")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/SignVirtualPsbt", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/sign")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -832,18 +711,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_SignVirtualPsbt_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_AnchorVirtualPsbts_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_AnchorVirtualPsbts_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, "/assetwalletrpc.AssetWallet/AnchorVirtualPsbts", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/anchor")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/AnchorVirtualPsbts", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/anchor")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -854,18 +728,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_AnchorVirtualPsbts_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_CommitVirtualPsbts_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_CommitVirtualPsbts_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, "/assetwalletrpc.AssetWallet/CommitVirtualPsbts", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/commit")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/CommitVirtualPsbts", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/commit")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -876,18 +745,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_CommitVirtualPsbts_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_PublishAndLogTransfer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_PublishAndLogTransfer_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, "/assetwalletrpc.AssetWallet/PublishAndLogTransfer", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/log-transfer")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/PublishAndLogTransfer", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/virtual-psbt/log-transfer")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -898,18 +762,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_PublishAndLogTransfer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_NextInternalKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_NextInternalKey_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, "/assetwalletrpc.AssetWallet/NextInternalKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/internal-key/next")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/NextInternalKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/internal-key/next")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -920,18 +779,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_NextInternalKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_NextScriptKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_NextScriptKey_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, "/assetwalletrpc.AssetWallet/NextScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/next")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/NextScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/next")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -942,18 +796,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_NextScriptKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_AssetWallet_QueryInternalKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_AssetWallet_QueryInternalKey_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, "/assetwalletrpc.AssetWallet/QueryInternalKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/internal-key/{internal_key}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/QueryInternalKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/internal-key/{internal_key}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -964,18 +813,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_QueryInternalKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_AssetWallet_QueryScriptKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_AssetWallet_QueryScriptKey_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, "/assetwalletrpc.AssetWallet/QueryScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/{tweaked_script_key}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/QueryScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/{tweaked_script_key}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -986,18 +830,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_QueryScriptKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_ProveAssetOwnership_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_ProveAssetOwnership_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, "/assetwalletrpc.AssetWallet/ProveAssetOwnership", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/ownership/prove")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/ProveAssetOwnership", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/ownership/prove")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1008,18 +847,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_ProveAssetOwnership_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_VerifyAssetOwnership_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_VerifyAssetOwnership_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, "/assetwalletrpc.AssetWallet/VerifyAssetOwnership", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/ownership/verify")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/VerifyAssetOwnership", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/ownership/verify")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1030,18 +864,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_VerifyAssetOwnership_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_RemoveUTXOLease_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_RemoveUTXOLease_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, "/assetwalletrpc.AssetWallet/RemoveUTXOLease", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/utxo-lease/delete")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/RemoveUTXOLease", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/utxo-lease/delete")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1052,18 +881,13 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_RemoveUTXOLease_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_AssetWallet_DeclareScriptKey_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_AssetWallet_DeclareScriptKey_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, "/assetwalletrpc.AssetWallet/DeclareScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/declare")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/assetwalletrpc.AssetWallet/DeclareScriptKey", runtime.WithHTTPPathPattern("/v1/taproot-assets/wallet/script-key/declare")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1074,66 +898,39 @@ func RegisterAssetWalletHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_AssetWallet_DeclareScriptKey_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - return nil } var ( - pattern_AssetWallet_FundVirtualPsbt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "fund"}, "")) - - pattern_AssetWallet_SignVirtualPsbt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "sign"}, "")) - - pattern_AssetWallet_AnchorVirtualPsbts_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "anchor"}, "")) - - pattern_AssetWallet_CommitVirtualPsbts_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "commit"}, "")) - + pattern_AssetWallet_FundVirtualPsbt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "fund"}, "")) + pattern_AssetWallet_SignVirtualPsbt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "sign"}, "")) + pattern_AssetWallet_AnchorVirtualPsbts_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "anchor"}, "")) + pattern_AssetWallet_CommitVirtualPsbts_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "commit"}, "")) pattern_AssetWallet_PublishAndLogTransfer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "virtual-psbt", "log-transfer"}, "")) - - pattern_AssetWallet_NextInternalKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "internal-key", "next"}, "")) - - pattern_AssetWallet_NextScriptKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "script-key", "next"}, "")) - - pattern_AssetWallet_QueryInternalKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "taproot-assets", "wallet", "internal-key", "internal_key"}, "")) - - pattern_AssetWallet_QueryScriptKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "taproot-assets", "wallet", "script-key", "tweaked_script_key"}, "")) - - pattern_AssetWallet_ProveAssetOwnership_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "ownership", "prove"}, "")) - - pattern_AssetWallet_VerifyAssetOwnership_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "ownership", "verify"}, "")) - - pattern_AssetWallet_RemoveUTXOLease_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "utxo-lease", "delete"}, "")) - - pattern_AssetWallet_DeclareScriptKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "script-key", "declare"}, "")) + pattern_AssetWallet_NextInternalKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "internal-key", "next"}, "")) + pattern_AssetWallet_NextScriptKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "script-key", "next"}, "")) + pattern_AssetWallet_QueryInternalKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "taproot-assets", "wallet", "internal-key", "internal_key"}, "")) + pattern_AssetWallet_QueryScriptKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "taproot-assets", "wallet", "script-key", "tweaked_script_key"}, "")) + pattern_AssetWallet_ProveAssetOwnership_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "ownership", "prove"}, "")) + pattern_AssetWallet_VerifyAssetOwnership_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "ownership", "verify"}, "")) + pattern_AssetWallet_RemoveUTXOLease_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "utxo-lease", "delete"}, "")) + pattern_AssetWallet_DeclareScriptKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "wallet", "script-key", "declare"}, "")) ) var ( - forward_AssetWallet_FundVirtualPsbt_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_SignVirtualPsbt_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_AnchorVirtualPsbts_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_CommitVirtualPsbts_0 = runtime.ForwardResponseMessage - + forward_AssetWallet_FundVirtualPsbt_0 = runtime.ForwardResponseMessage + forward_AssetWallet_SignVirtualPsbt_0 = runtime.ForwardResponseMessage + forward_AssetWallet_AnchorVirtualPsbts_0 = runtime.ForwardResponseMessage + forward_AssetWallet_CommitVirtualPsbts_0 = runtime.ForwardResponseMessage forward_AssetWallet_PublishAndLogTransfer_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_NextInternalKey_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_NextScriptKey_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_QueryInternalKey_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_QueryScriptKey_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_ProveAssetOwnership_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_VerifyAssetOwnership_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_RemoveUTXOLease_0 = runtime.ForwardResponseMessage - - forward_AssetWallet_DeclareScriptKey_0 = runtime.ForwardResponseMessage + forward_AssetWallet_NextInternalKey_0 = runtime.ForwardResponseMessage + forward_AssetWallet_NextScriptKey_0 = runtime.ForwardResponseMessage + forward_AssetWallet_QueryInternalKey_0 = runtime.ForwardResponseMessage + forward_AssetWallet_QueryScriptKey_0 = runtime.ForwardResponseMessage + forward_AssetWallet_ProveAssetOwnership_0 = runtime.ForwardResponseMessage + forward_AssetWallet_VerifyAssetOwnership_0 = runtime.ForwardResponseMessage + forward_AssetWallet_RemoveUTXOLease_0 = runtime.ForwardResponseMessage + forward_AssetWallet_DeclareScriptKey_0 = runtime.ForwardResponseMessage ) diff --git a/taprpc/assetwalletrpc/assetwallet_grpc.pb.go b/taprpc/assetwalletrpc/assetwallet_grpc.pb.go index 1a685e2c4..421b08740 100644 --- a/taprpc/assetwalletrpc/assetwallet_grpc.pb.go +++ b/taprpc/assetwalletrpc/assetwallet_grpc.pb.go @@ -1,4 +1,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc v3.21.12 +// source: assetwalletrpc/assetwallet.proto package assetwalletrpc @@ -12,8 +16,24 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + AssetWallet_FundVirtualPsbt_FullMethodName = "/assetwalletrpc.AssetWallet/FundVirtualPsbt" + AssetWallet_SignVirtualPsbt_FullMethodName = "/assetwalletrpc.AssetWallet/SignVirtualPsbt" + AssetWallet_AnchorVirtualPsbts_FullMethodName = "/assetwalletrpc.AssetWallet/AnchorVirtualPsbts" + AssetWallet_CommitVirtualPsbts_FullMethodName = "/assetwalletrpc.AssetWallet/CommitVirtualPsbts" + AssetWallet_PublishAndLogTransfer_FullMethodName = "/assetwalletrpc.AssetWallet/PublishAndLogTransfer" + AssetWallet_NextInternalKey_FullMethodName = "/assetwalletrpc.AssetWallet/NextInternalKey" + AssetWallet_NextScriptKey_FullMethodName = "/assetwalletrpc.AssetWallet/NextScriptKey" + AssetWallet_QueryInternalKey_FullMethodName = "/assetwalletrpc.AssetWallet/QueryInternalKey" + AssetWallet_QueryScriptKey_FullMethodName = "/assetwalletrpc.AssetWallet/QueryScriptKey" + AssetWallet_ProveAssetOwnership_FullMethodName = "/assetwalletrpc.AssetWallet/ProveAssetOwnership" + AssetWallet_VerifyAssetOwnership_FullMethodName = "/assetwalletrpc.AssetWallet/VerifyAssetOwnership" + AssetWallet_RemoveUTXOLease_FullMethodName = "/assetwalletrpc.AssetWallet/RemoveUTXOLease" + AssetWallet_DeclareScriptKey_FullMethodName = "/assetwalletrpc.AssetWallet/DeclareScriptKey" +) // AssetWalletClient is the client API for AssetWallet service. // @@ -88,8 +108,9 @@ func NewAssetWalletClient(cc grpc.ClientConnInterface) AssetWalletClient { } func (c *assetWalletClient) FundVirtualPsbt(ctx context.Context, in *FundVirtualPsbtRequest, opts ...grpc.CallOption) (*FundVirtualPsbtResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(FundVirtualPsbtResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/FundVirtualPsbt", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_FundVirtualPsbt_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -97,8 +118,9 @@ func (c *assetWalletClient) FundVirtualPsbt(ctx context.Context, in *FundVirtual } func (c *assetWalletClient) SignVirtualPsbt(ctx context.Context, in *SignVirtualPsbtRequest, opts ...grpc.CallOption) (*SignVirtualPsbtResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(SignVirtualPsbtResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/SignVirtualPsbt", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_SignVirtualPsbt_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -106,8 +128,9 @@ func (c *assetWalletClient) SignVirtualPsbt(ctx context.Context, in *SignVirtual } func (c *assetWalletClient) AnchorVirtualPsbts(ctx context.Context, in *AnchorVirtualPsbtsRequest, opts ...grpc.CallOption) (*taprpc.SendAssetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(taprpc.SendAssetResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/AnchorVirtualPsbts", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_AnchorVirtualPsbts_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -115,8 +138,9 @@ func (c *assetWalletClient) AnchorVirtualPsbts(ctx context.Context, in *AnchorVi } func (c *assetWalletClient) CommitVirtualPsbts(ctx context.Context, in *CommitVirtualPsbtsRequest, opts ...grpc.CallOption) (*CommitVirtualPsbtsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CommitVirtualPsbtsResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/CommitVirtualPsbts", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_CommitVirtualPsbts_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -124,8 +148,9 @@ func (c *assetWalletClient) CommitVirtualPsbts(ctx context.Context, in *CommitVi } func (c *assetWalletClient) PublishAndLogTransfer(ctx context.Context, in *PublishAndLogRequest, opts ...grpc.CallOption) (*taprpc.SendAssetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(taprpc.SendAssetResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/PublishAndLogTransfer", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_PublishAndLogTransfer_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -133,8 +158,9 @@ func (c *assetWalletClient) PublishAndLogTransfer(ctx context.Context, in *Publi } func (c *assetWalletClient) NextInternalKey(ctx context.Context, in *NextInternalKeyRequest, opts ...grpc.CallOption) (*NextInternalKeyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(NextInternalKeyResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/NextInternalKey", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_NextInternalKey_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -142,8 +168,9 @@ func (c *assetWalletClient) NextInternalKey(ctx context.Context, in *NextInterna } func (c *assetWalletClient) NextScriptKey(ctx context.Context, in *NextScriptKeyRequest, opts ...grpc.CallOption) (*NextScriptKeyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(NextScriptKeyResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/NextScriptKey", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_NextScriptKey_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -151,8 +178,9 @@ func (c *assetWalletClient) NextScriptKey(ctx context.Context, in *NextScriptKey } func (c *assetWalletClient) QueryInternalKey(ctx context.Context, in *QueryInternalKeyRequest, opts ...grpc.CallOption) (*QueryInternalKeyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(QueryInternalKeyResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/QueryInternalKey", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_QueryInternalKey_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -160,8 +188,9 @@ func (c *assetWalletClient) QueryInternalKey(ctx context.Context, in *QueryInter } func (c *assetWalletClient) QueryScriptKey(ctx context.Context, in *QueryScriptKeyRequest, opts ...grpc.CallOption) (*QueryScriptKeyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(QueryScriptKeyResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/QueryScriptKey", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_QueryScriptKey_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -169,8 +198,9 @@ func (c *assetWalletClient) QueryScriptKey(ctx context.Context, in *QueryScriptK } func (c *assetWalletClient) ProveAssetOwnership(ctx context.Context, in *ProveAssetOwnershipRequest, opts ...grpc.CallOption) (*ProveAssetOwnershipResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ProveAssetOwnershipResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/ProveAssetOwnership", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_ProveAssetOwnership_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -178,8 +208,9 @@ func (c *assetWalletClient) ProveAssetOwnership(ctx context.Context, in *ProveAs } func (c *assetWalletClient) VerifyAssetOwnership(ctx context.Context, in *VerifyAssetOwnershipRequest, opts ...grpc.CallOption) (*VerifyAssetOwnershipResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(VerifyAssetOwnershipResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/VerifyAssetOwnership", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_VerifyAssetOwnership_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -187,8 +218,9 @@ func (c *assetWalletClient) VerifyAssetOwnership(ctx context.Context, in *Verify } func (c *assetWalletClient) RemoveUTXOLease(ctx context.Context, in *RemoveUTXOLeaseRequest, opts ...grpc.CallOption) (*RemoveUTXOLeaseResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RemoveUTXOLeaseResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/RemoveUTXOLease", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_RemoveUTXOLease_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -196,8 +228,9 @@ func (c *assetWalletClient) RemoveUTXOLease(ctx context.Context, in *RemoveUTXOL } func (c *assetWalletClient) DeclareScriptKey(ctx context.Context, in *DeclareScriptKeyRequest, opts ...grpc.CallOption) (*DeclareScriptKeyResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(DeclareScriptKeyResponse) - err := c.cc.Invoke(ctx, "/assetwalletrpc.AssetWallet/DeclareScriptKey", in, out, opts...) + err := c.cc.Invoke(ctx, AssetWallet_DeclareScriptKey_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -206,7 +239,7 @@ func (c *assetWalletClient) DeclareScriptKey(ctx context.Context, in *DeclareScr // AssetWalletServer is the server API for AssetWallet service. // All implementations must embed UnimplementedAssetWalletServer -// for forward compatibility +// for forward compatibility. type AssetWalletServer interface { // FundVirtualPsbt selects inputs from the available asset commitments to fund // a virtual transaction matching the template. @@ -269,9 +302,12 @@ type AssetWalletServer interface { mustEmbedUnimplementedAssetWalletServer() } -// UnimplementedAssetWalletServer must be embedded to have forward compatible implementations. -type UnimplementedAssetWalletServer struct { -} +// UnimplementedAssetWalletServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedAssetWalletServer struct{} func (UnimplementedAssetWalletServer) FundVirtualPsbt(context.Context, *FundVirtualPsbtRequest) (*FundVirtualPsbtResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method FundVirtualPsbt not implemented") @@ -313,6 +349,7 @@ func (UnimplementedAssetWalletServer) DeclareScriptKey(context.Context, *Declare return nil, status.Errorf(codes.Unimplemented, "method DeclareScriptKey not implemented") } func (UnimplementedAssetWalletServer) mustEmbedUnimplementedAssetWalletServer() {} +func (UnimplementedAssetWalletServer) testEmbeddedByValue() {} // UnsafeAssetWalletServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to AssetWalletServer will @@ -322,6 +359,13 @@ type UnsafeAssetWalletServer interface { } func RegisterAssetWalletServer(s grpc.ServiceRegistrar, srv AssetWalletServer) { + // If the following call pancis, it indicates UnimplementedAssetWalletServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&AssetWallet_ServiceDesc, srv) } @@ -335,7 +379,7 @@ func _AssetWallet_FundVirtualPsbt_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/FundVirtualPsbt", + FullMethod: AssetWallet_FundVirtualPsbt_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).FundVirtualPsbt(ctx, req.(*FundVirtualPsbtRequest)) @@ -353,7 +397,7 @@ func _AssetWallet_SignVirtualPsbt_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/SignVirtualPsbt", + FullMethod: AssetWallet_SignVirtualPsbt_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).SignVirtualPsbt(ctx, req.(*SignVirtualPsbtRequest)) @@ -371,7 +415,7 @@ func _AssetWallet_AnchorVirtualPsbts_Handler(srv interface{}, ctx context.Contex } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/AnchorVirtualPsbts", + FullMethod: AssetWallet_AnchorVirtualPsbts_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).AnchorVirtualPsbts(ctx, req.(*AnchorVirtualPsbtsRequest)) @@ -389,7 +433,7 @@ func _AssetWallet_CommitVirtualPsbts_Handler(srv interface{}, ctx context.Contex } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/CommitVirtualPsbts", + FullMethod: AssetWallet_CommitVirtualPsbts_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).CommitVirtualPsbts(ctx, req.(*CommitVirtualPsbtsRequest)) @@ -407,7 +451,7 @@ func _AssetWallet_PublishAndLogTransfer_Handler(srv interface{}, ctx context.Con } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/PublishAndLogTransfer", + FullMethod: AssetWallet_PublishAndLogTransfer_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).PublishAndLogTransfer(ctx, req.(*PublishAndLogRequest)) @@ -425,7 +469,7 @@ func _AssetWallet_NextInternalKey_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/NextInternalKey", + FullMethod: AssetWallet_NextInternalKey_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).NextInternalKey(ctx, req.(*NextInternalKeyRequest)) @@ -443,7 +487,7 @@ func _AssetWallet_NextScriptKey_Handler(srv interface{}, ctx context.Context, de } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/NextScriptKey", + FullMethod: AssetWallet_NextScriptKey_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).NextScriptKey(ctx, req.(*NextScriptKeyRequest)) @@ -461,7 +505,7 @@ func _AssetWallet_QueryInternalKey_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/QueryInternalKey", + FullMethod: AssetWallet_QueryInternalKey_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).QueryInternalKey(ctx, req.(*QueryInternalKeyRequest)) @@ -479,7 +523,7 @@ func _AssetWallet_QueryScriptKey_Handler(srv interface{}, ctx context.Context, d } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/QueryScriptKey", + FullMethod: AssetWallet_QueryScriptKey_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).QueryScriptKey(ctx, req.(*QueryScriptKeyRequest)) @@ -497,7 +541,7 @@ func _AssetWallet_ProveAssetOwnership_Handler(srv interface{}, ctx context.Conte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/ProveAssetOwnership", + FullMethod: AssetWallet_ProveAssetOwnership_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).ProveAssetOwnership(ctx, req.(*ProveAssetOwnershipRequest)) @@ -515,7 +559,7 @@ func _AssetWallet_VerifyAssetOwnership_Handler(srv interface{}, ctx context.Cont } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/VerifyAssetOwnership", + FullMethod: AssetWallet_VerifyAssetOwnership_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).VerifyAssetOwnership(ctx, req.(*VerifyAssetOwnershipRequest)) @@ -533,7 +577,7 @@ func _AssetWallet_RemoveUTXOLease_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/RemoveUTXOLease", + FullMethod: AssetWallet_RemoveUTXOLease_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).RemoveUTXOLease(ctx, req.(*RemoveUTXOLeaseRequest)) @@ -551,7 +595,7 @@ func _AssetWallet_DeclareScriptKey_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/assetwalletrpc.AssetWallet/DeclareScriptKey", + FullMethod: AssetWallet_DeclareScriptKey_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(AssetWalletServer).DeclareScriptKey(ctx, req.(*DeclareScriptKeyRequest)) diff --git a/taprpc/gen_protos.sh b/taprpc/gen_protos.sh index 46d8f5ae0..eace4e902 100755 --- a/taprpc/gen_protos.sh +++ b/taprpc/gen_protos.sh @@ -2,6 +2,8 @@ set -e +LND_VERSION="v0.17.0-beta" + # generate compiles the *.pb.go stubs from the *.proto files. function generate() { echo "Generating root gRPC server protos" diff --git a/taprpc/mintrpc/mint.pb.go b/taprpc/mintrpc/mint.pb.go index 4b65e761d..5e7b9afdc 100644 --- a/taprpc/mintrpc/mint.pb.go +++ b/taprpc/mintrpc/mint.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.34.2 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: mintrpc/mint.proto @@ -12,6 +12,7 @@ import ( protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + unsafe "unsafe" ) const ( @@ -89,10 +90,7 @@ func (BatchState) EnumDescriptor() ([]byte, []int) { } type PendingAsset struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The version of asset to mint. AssetVersion taprpc.AssetVersion `protobuf:"varint,1,opt,name=asset_version,json=assetVersion,proto3,enum=taprpc.AssetVersion" json:"asset_version,omitempty"` // The type of the asset to be created. @@ -122,16 +120,16 @@ type PendingAsset struct { 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"` + ScriptKey *taprpc.ScriptKey `protobuf:"bytes,11,opt,name=script_key,json=scriptKey,proto3" json:"script_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PendingAsset) Reset() { *x = PendingAsset{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PendingAsset) String() string { @@ -142,7 +140,7 @@ func (*PendingAsset) ProtoMessage() {} func (x *PendingAsset) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -235,10 +233,7 @@ func (x *PendingAsset) GetScriptKey() *taprpc.ScriptKey { } type UnsealedAsset struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // 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. @@ -247,15 +242,15 @@ type UnsealedAsset struct { GroupVirtualTx *taprpc.GroupVirtualTx `protobuf:"bytes,3,opt,name=group_virtual_tx,json=groupVirtualTx,proto3" json:"group_virtual_tx,omitempty"` // The byte serialized PSBT equivalent of the group virtual transaction. GroupVirtualPsbt string `protobuf:"bytes,4,opt,name=group_virtual_psbt,json=groupVirtualPsbt,proto3" json:"group_virtual_psbt,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } 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) - } + mi := &file_mintrpc_mint_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *UnsealedAsset) String() string { @@ -266,7 +261,7 @@ func (*UnsealedAsset) ProtoMessage() {} func (x *UnsealedAsset) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[1] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -310,10 +305,7 @@ func (x *UnsealedAsset) GetGroupVirtualPsbt() string { } type MintAsset struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The version of asset to mint. AssetVersion taprpc.AssetVersion `protobuf:"varint,1,opt,name=asset_version,json=assetVersion,proto3,enum=taprpc.AssetVersion" json:"asset_version,omitempty"` // The type of the asset to be created. @@ -386,15 +378,15 @@ type MintAsset struct { // (i.e., the first minting tranche of an asset group) and ensures that the // batch is limited to a single asset group. UniverseCommitments bool `protobuf:"varint,15,opt,name=universe_commitments,json=universeCommitments,proto3" json:"universe_commitments,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MintAsset) Reset() { *x = MintAsset{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *MintAsset) String() string { @@ -405,7 +397,7 @@ func (*MintAsset) ProtoMessage() {} func (x *MintAsset) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -526,25 +518,22 @@ func (x *MintAsset) GetUniverseCommitments() bool { } type MintAssetRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The asset to be minted. Asset *MintAsset `protobuf:"bytes,1,opt,name=asset,proto3" json:"asset,omitempty"` // 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,2,opt,name=short_response,json=shortResponse,proto3" json:"short_response,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MintAssetRequest) Reset() { *x = MintAssetRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *MintAssetRequest) String() string { @@ -555,7 +544,7 @@ func (*MintAssetRequest) ProtoMessage() {} func (x *MintAssetRequest) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[3] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -585,21 +574,18 @@ func (x *MintAssetRequest) GetShortResponse() bool { } type MintAssetResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The pending batch the asset was added to. - PendingBatch *MintingBatch `protobuf:"bytes,1,opt,name=pending_batch,json=pendingBatch,proto3" json:"pending_batch,omitempty"` + PendingBatch *MintingBatch `protobuf:"bytes,1,opt,name=pending_batch,json=pendingBatch,proto3" json:"pending_batch,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MintAssetResponse) Reset() { *x = MintAssetResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *MintAssetResponse) String() string { @@ -610,7 +596,7 @@ func (*MintAssetResponse) ProtoMessage() {} func (x *MintAssetResponse) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -633,10 +619,7 @@ func (x *MintAssetResponse) GetPendingBatch() *MintingBatch { } type MintingBatch struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // A public key serialized in compressed format that can be used to uniquely // identify a pending minting batch. Responses that share the same key will be // batched into the same minting transaction. @@ -654,16 +637,16 @@ type MintingBatch struct { HeightHint uint32 `protobuf:"varint,6,opt,name=height_hint,json=heightHint,proto3" json:"height_hint,omitempty"` // The genesis transaction as a PSBT packet. Only populated if the batch has // been committed. - BatchPsbt []byte `protobuf:"bytes,7,opt,name=batch_psbt,json=batchPsbt,proto3" json:"batch_psbt,omitempty"` + BatchPsbt []byte `protobuf:"bytes,7,opt,name=batch_psbt,json=batchPsbt,proto3" json:"batch_psbt,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MintingBatch) Reset() { *x = MintingBatch{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *MintingBatch) String() string { @@ -674,7 +657,7 @@ func (*MintingBatch) ProtoMessage() {} func (x *MintingBatch) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[5] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -739,23 +722,20 @@ func (x *MintingBatch) GetBatchPsbt() []byte { } type VerboseBatch struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } 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) - } + mi := &file_mintrpc_mint_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *VerboseBatch) String() string { @@ -766,7 +746,7 @@ func (*VerboseBatch) ProtoMessage() {} func (x *VerboseBatch) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[6] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -796,10 +776,7 @@ func (x *VerboseBatch) GetUnsealedAssets() []*UnsealedAsset { } type FundBatchRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // 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. @@ -810,20 +787,20 @@ type FundBatchRequest struct { // 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: + // Types that are valid to be assigned to BatchSibling: // // *FundBatchRequest_FullTree // *FundBatchRequest_Branch - BatchSibling isFundBatchRequest_BatchSibling `protobuf_oneof:"batch_sibling"` + BatchSibling isFundBatchRequest_BatchSibling `protobuf_oneof:"batch_sibling"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } 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) - } + mi := &file_mintrpc_mint_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FundBatchRequest) String() string { @@ -834,7 +811,7 @@ func (*FundBatchRequest) ProtoMessage() {} func (x *FundBatchRequest) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[7] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -863,23 +840,27 @@ func (x *FundBatchRequest) GetFeeRate() uint32 { return 0 } -func (m *FundBatchRequest) GetBatchSibling() isFundBatchRequest_BatchSibling { - if m != nil { - return m.BatchSibling +func (x *FundBatchRequest) GetBatchSibling() isFundBatchRequest_BatchSibling { + if x != nil { + return x.BatchSibling } return nil } func (x *FundBatchRequest) GetFullTree() *taprpc.TapscriptFullTree { - if x, ok := x.GetBatchSibling().(*FundBatchRequest_FullTree); ok { - return x.FullTree + if x != nil { + if x, ok := x.BatchSibling.(*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 + if x != nil { + if x, ok := x.BatchSibling.(*FundBatchRequest_Branch); ok { + return x.Branch + } } return nil } @@ -904,21 +885,18 @@ func (*FundBatchRequest_FullTree) isFundBatchRequest_BatchSibling() {} func (*FundBatchRequest_Branch) isFundBatchRequest_BatchSibling() {} type FundBatchResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The funded batch. - Batch *VerboseBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + Batch *VerboseBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } 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) - } + mi := &file_mintrpc_mint_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FundBatchResponse) String() string { @@ -929,7 +907,7 @@ func (*FundBatchResponse) ProtoMessage() {} func (x *FundBatchResponse) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[8] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -952,10 +930,7 @@ func (x *FundBatchResponse) GetBatch() *VerboseBatch { } type SealBatchRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // 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. @@ -968,15 +943,15 @@ type SealBatchRequest struct { // This field should not be used in conjunction with `group_witnesses`; // use one or the other. SignedGroupVirtualPsbts []string `protobuf:"bytes,3,rep,name=signed_group_virtual_psbts,json=signedGroupVirtualPsbts,proto3" json:"signed_group_virtual_psbts,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } 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) - } + mi := &file_mintrpc_mint_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SealBatchRequest) String() string { @@ -987,7 +962,7 @@ func (*SealBatchRequest) ProtoMessage() {} func (x *SealBatchRequest) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[9] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1024,21 +999,18 @@ func (x *SealBatchRequest) GetSignedGroupVirtualPsbts() []string { } type SealBatchResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The sealed batch. - Batch *MintingBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + Batch *MintingBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } 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) - } + mi := &file_mintrpc_mint_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SealBatchResponse) String() string { @@ -1049,7 +1021,7 @@ func (*SealBatchResponse) ProtoMessage() {} func (x *SealBatchResponse) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[10] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1072,10 +1044,7 @@ func (x *SealBatchResponse) GetBatch() *MintingBatch { } type FinalizeBatchRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // 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. @@ -1086,20 +1055,20 @@ type FinalizeBatchRequest struct { // 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: + // Types that are valid to be assigned to BatchSibling: // // *FinalizeBatchRequest_FullTree // *FinalizeBatchRequest_Branch - BatchSibling isFinalizeBatchRequest_BatchSibling `protobuf_oneof:"batch_sibling"` + BatchSibling isFinalizeBatchRequest_BatchSibling `protobuf_oneof:"batch_sibling"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *FinalizeBatchRequest) Reset() { *x = FinalizeBatchRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FinalizeBatchRequest) String() string { @@ -1110,7 +1079,7 @@ func (*FinalizeBatchRequest) ProtoMessage() {} func (x *FinalizeBatchRequest) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[11] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1139,23 +1108,27 @@ func (x *FinalizeBatchRequest) GetFeeRate() uint32 { return 0 } -func (m *FinalizeBatchRequest) GetBatchSibling() isFinalizeBatchRequest_BatchSibling { - if m != nil { - return m.BatchSibling +func (x *FinalizeBatchRequest) GetBatchSibling() isFinalizeBatchRequest_BatchSibling { + if x != nil { + return x.BatchSibling } return nil } func (x *FinalizeBatchRequest) GetFullTree() *taprpc.TapscriptFullTree { - if x, ok := x.GetBatchSibling().(*FinalizeBatchRequest_FullTree); ok { - return x.FullTree + if x != nil { + if x, ok := x.BatchSibling.(*FinalizeBatchRequest_FullTree); ok { + return x.FullTree + } } return nil } func (x *FinalizeBatchRequest) GetBranch() *taprpc.TapBranch { - if x, ok := x.GetBatchSibling().(*FinalizeBatchRequest_Branch); ok { - return x.Branch + if x != nil { + if x, ok := x.BatchSibling.(*FinalizeBatchRequest_Branch); ok { + return x.Branch + } } return nil } @@ -1180,21 +1153,18 @@ func (*FinalizeBatchRequest_FullTree) isFinalizeBatchRequest_BatchSibling() {} func (*FinalizeBatchRequest_Branch) isFinalizeBatchRequest_BatchSibling() {} type FinalizeBatchResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The finalized batch. - Batch *MintingBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + Batch *MintingBatch `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *FinalizeBatchResponse) Reset() { *x = FinalizeBatchResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[12] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FinalizeBatchResponse) String() string { @@ -1205,7 +1175,7 @@ func (*FinalizeBatchResponse) ProtoMessage() {} func (x *FinalizeBatchResponse) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[12] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1228,18 +1198,16 @@ func (x *FinalizeBatchResponse) GetBatch() *MintingBatch { } type CancelBatchRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CancelBatchRequest) Reset() { *x = CancelBatchRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[13] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *CancelBatchRequest) String() string { @@ -1250,7 +1218,7 @@ func (*CancelBatchRequest) ProtoMessage() {} func (x *CancelBatchRequest) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[13] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1266,21 +1234,18 @@ func (*CancelBatchRequest) Descriptor() ([]byte, []int) { } type CancelBatchResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The internal public key of the batch. - BatchKey []byte `protobuf:"bytes,1,opt,name=batch_key,json=batchKey,proto3" json:"batch_key,omitempty"` + BatchKey []byte `protobuf:"bytes,1,opt,name=batch_key,json=batchKey,proto3" json:"batch_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CancelBatchResponse) Reset() { *x = CancelBatchResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *CancelBatchResponse) String() string { @@ -1291,7 +1256,7 @@ func (*CancelBatchResponse) ProtoMessage() {} func (x *CancelBatchResponse) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[14] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1314,29 +1279,26 @@ func (x *CancelBatchResponse) GetBatchKey() []byte { } type ListBatchRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The optional batch key of the batch to list. // - // Types that are assignable to Filter: + // Types that are valid to be assigned to Filter: // // *ListBatchRequest_BatchKey // *ListBatchRequest_BatchKeyStr Filter isListBatchRequest_Filter `protobuf_oneof:"filter"` // If true, pending asset group details will be included for any funded, // non-empty pending batch. Unfunded or empty batches will be excluded. - Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"` + Verbose bool `protobuf:"varint,3,opt,name=verbose,proto3" json:"verbose,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *ListBatchRequest) Reset() { *x = ListBatchRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *ListBatchRequest) String() string { @@ -1347,7 +1309,7 @@ func (*ListBatchRequest) ProtoMessage() {} func (x *ListBatchRequest) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[15] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1362,23 +1324,27 @@ func (*ListBatchRequest) Descriptor() ([]byte, []int) { return file_mintrpc_mint_proto_rawDescGZIP(), []int{15} } -func (m *ListBatchRequest) GetFilter() isListBatchRequest_Filter { - if m != nil { - return m.Filter +func (x *ListBatchRequest) GetFilter() isListBatchRequest_Filter { + if x != nil { + return x.Filter } return nil } func (x *ListBatchRequest) GetBatchKey() []byte { - if x, ok := x.GetFilter().(*ListBatchRequest_BatchKey); ok { - return x.BatchKey + if x != nil { + if x, ok := x.Filter.(*ListBatchRequest_BatchKey); ok { + return x.BatchKey + } } return nil } func (x *ListBatchRequest) GetBatchKeyStr() string { - if x, ok := x.GetFilter().(*ListBatchRequest_BatchKeyStr); ok { - return x.BatchKeyStr + if x != nil { + if x, ok := x.Filter.(*ListBatchRequest_BatchKeyStr); ok { + return x.BatchKeyStr + } } return "" } @@ -1411,20 +1377,17 @@ func (*ListBatchRequest_BatchKey) isListBatchRequest_Filter() {} func (*ListBatchRequest_BatchKeyStr) isListBatchRequest_Filter() {} type ListBatchResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Batches []*VerboseBatch `protobuf:"bytes,1,rep,name=batches,proto3" json:"batches,omitempty"` unknownFields protoimpl.UnknownFields - - Batches []*VerboseBatch `protobuf:"bytes,1,rep,name=batches,proto3" json:"batches,omitempty"` + sizeCache protoimpl.SizeCache } func (x *ListBatchResponse) Reset() { *x = ListBatchResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[16] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *ListBatchResponse) String() string { @@ -1435,7 +1398,7 @@ func (*ListBatchResponse) ProtoMessage() {} func (x *ListBatchResponse) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[16] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1458,23 +1421,20 @@ func (x *ListBatchResponse) GetBatches() []*VerboseBatch { } type SubscribeMintEventsRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // If true, then the assets currently in the batch won't be returned in the // event's batch. 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"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SubscribeMintEventsRequest) Reset() { *x = SubscribeMintEventsRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[17] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SubscribeMintEventsRequest) String() string { @@ -1485,7 +1445,7 @@ func (*SubscribeMintEventsRequest) ProtoMessage() {} func (x *SubscribeMintEventsRequest) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[17] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1508,10 +1468,7 @@ func (x *SubscribeMintEventsRequest) GetShortResponse() bool { } type MintEvent struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // Execute timestamp (Unix timestamp in microseconds). Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // The last state of the batch that was successfully executed. If error @@ -1521,16 +1478,16 @@ type MintEvent struct { // The batch that the event is for. Batch *MintingBatch `protobuf:"bytes,3,opt,name=batch,proto3" json:"batch,omitempty"` // An optional error, indicating that executing the batch_state failed. - Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"` + Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MintEvent) Reset() { *x = MintEvent{} - if protoimpl.UnsafeEnabled { - mi := &file_mintrpc_mint_proto_msgTypes[18] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_mintrpc_mint_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *MintEvent) String() string { @@ -1541,7 +1498,7 @@ func (*MintEvent) ProtoMessage() {} func (x *MintEvent) ProtoReflect() protoreflect.Message { mi := &file_mintrpc_mint_proto_msgTypes[18] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1586,281 +1543,138 @@ func (x *MintEvent) GetError() string { var File_mintrpc_mint_proto protoreflect.FileDescriptor -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, 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, - 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, 0x1b, 0x0a, 0x09, 0x67, 0x72, - 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, 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, 0xf1, 0x01, 0x0a, 0x0d, 0x55, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x2b, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x50, - 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x05, 0x61, 0x73, 0x73, - 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, 0x12, 0x2c, 0x0a, 0x12, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x5f, 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x56, 0x69, 0x72, 0x74, - 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 0x22, 0xaf, 0x05, 0x0a, 0x09, 0x4d, 0x69, 0x6e, 0x74, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x39, 0x0a, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x76, - 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x74, - 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, - 0x70, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x6d, 0x65, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x09, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, - 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, - 0x12, 0x2a, 0x0a, 0x11, 0x6e, 0x65, 0x77, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x5f, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x6e, 0x65, 0x77, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x23, 0x0a, 0x0d, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x07, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x08, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x21, - 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x18, 0x09, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6e, 0x63, 0x68, 0x6f, - 0x72, 0x12, 0x43, 0x0a, 0x12, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x4b, 0x65, 0x79, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x6f, 0x72, 0x52, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x4b, 0x65, 0x79, 0x12, 0x30, 0x0a, 0x14, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, - 0x74, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x0b, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x12, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x54, 0x61, 0x70, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x30, 0x0a, 0x0a, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, - 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x52, - 0x09, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, - 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x0d, 0x20, - 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, - 0x6c, 0x61, 0x79, 0x12, 0x41, 0x0a, 0x12, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x13, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x4b, 0x65, 0x79, 0x52, 0x10, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x31, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x0f, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x43, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x63, 0x0a, 0x10, 0x4d, 0x69, 0x6e, - 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x28, 0x0a, - 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x6d, - 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, - 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x0d, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x4f, - 0x0a, 0x11, 0x4d, 0x69, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x0d, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x62, - 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, - 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, - 0x68, 0x52, 0x0c, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x22, - 0x83, 0x02, 0x0a, 0x0c, 0x4d, 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, - 0x12, 0x1b, 0x0a, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0c, 0x52, 0x08, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4b, 0x65, 0x79, 0x12, 0x1d, 0x0a, - 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x74, 0x78, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, 0x68, 0x54, 0x78, 0x69, 0x64, 0x12, 0x29, 0x0a, 0x05, - 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, 0x6d, 0x69, - 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, - 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, - 0x63, 0x2e, 0x50, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x06, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, - 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, - 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x5f, - 0x68, 0x69, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x68, 0x65, 0x69, 0x67, - 0x68, 0x74, 0x48, 0x69, 0x6e, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, - 0x70, 0x73, 0x62, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x62, 0x61, 0x74, 0x63, - 0x68, 0x50, 0x73, 0x62, 0x74, 0x22, 0x7c, 0x0a, 0x0c, 0x56, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, - 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x4d, - 0x69, 0x6e, 0x74, 0x69, 0x6e, 0x67, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, 0x62, 0x61, 0x74, - 0x63, 0x68, 0x12, 0x3f, 0x0a, 0x0f, 0x75, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x6d, 0x69, - 0x6e, 0x74, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x52, 0x0e, 0x75, 0x6e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x73, 0x22, 0xcc, 0x01, 0x0a, 0x10, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, - 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, - 0x74, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x0d, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x19, 0x0a, 0x08, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0d, 0x52, 0x07, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x66, 0x75, - 0x6c, 0x6c, 0x5f, 0x74, 0x72, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x61, 0x70, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x46, 0x75, 0x6c, 0x6c, 0x54, 0x72, 0x65, 0x65, 0x48, 0x00, 0x52, 0x08, 0x66, 0x75, 0x6c, 0x6c, - 0x54, 0x72, 0x65, 0x65, 0x12, 0x2b, 0x0a, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x61, - 0x70, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x48, 0x00, 0x52, 0x06, 0x62, 0x72, 0x61, 0x6e, 0x63, - 0x68, 0x42, 0x0f, 0x0a, 0x0d, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x62, 0x6c, 0x69, - 0x6e, 0x67, 0x22, 0x40, 0x0a, 0x11, 0x46, 0x75, 0x6e, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x05, 0x62, 0x61, 0x74, 0x63, 0x68, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x72, 0x70, 0x63, - 0x2e, 0x56, 0x65, 0x72, 0x62, 0x6f, 0x73, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x05, 0x62, - 0x61, 0x74, 0x63, 0x68, 0x22, 0xb5, 0x01, 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, 0x12, - 0x3b, 0x0a, 0x1a, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, - 0x76, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x70, 0x73, 0x62, 0x74, 0x73, 0x18, 0x03, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x17, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x50, 0x73, 0x62, 0x74, 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, -} +const file_mintrpc_mint_proto_rawDesc = "" + + "\n" + + "\x12mintrpc/mint.proto\x12\amintrpc\x1a\x13taprootassets.proto\"\xee\x03\n" + + "\fPendingAsset\x129\n" + + "\rasset_version\x18\x01 \x01(\x0e2\x14.taprpc.AssetVersionR\fassetVersion\x120\n" + + "\n" + + "asset_type\x18\x02 \x01(\x0e2\x11.taprpc.AssetTypeR\tassetType\x12\x12\n" + + "\x04name\x18\x03 \x01(\tR\x04name\x120\n" + + "\n" + + "asset_meta\x18\x04 \x01(\v2\x11.taprpc.AssetMetaR\tassetMeta\x12\x16\n" + + "\x06amount\x18\x05 \x01(\x04R\x06amount\x12*\n" + + "\x11new_grouped_asset\x18\x06 \x01(\bR\x0fnewGroupedAsset\x12\x1b\n" + + "\tgroup_key\x18\a \x01(\fR\bgroupKey\x12!\n" + + "\fgroup_anchor\x18\b \x01(\tR\vgroupAnchor\x12C\n" + + "\x12group_internal_key\x18\t \x01(\v2\x15.taprpc.KeyDescriptorR\x10groupInternalKey\x120\n" + + "\x14group_tapscript_root\x18\n" + + " \x01(\fR\x12groupTapscriptRoot\x120\n" + + "\n" + + "script_key\x18\v \x01(\v2\x11.taprpc.ScriptKeyR\tscriptKey\"\xf1\x01\n" + + "\rUnsealedAsset\x12+\n" + + "\x05asset\x18\x01 \x01(\v2\x15.mintrpc.PendingAssetR\x05asset\x12C\n" + + "\x11group_key_request\x18\x02 \x01(\v2\x17.taprpc.GroupKeyRequestR\x0fgroupKeyRequest\x12@\n" + + "\x10group_virtual_tx\x18\x03 \x01(\v2\x16.taprpc.GroupVirtualTxR\x0egroupVirtualTx\x12,\n" + + "\x12group_virtual_psbt\x18\x04 \x01(\tR\x10groupVirtualPsbt\"\xaf\x05\n" + + "\tMintAsset\x129\n" + + "\rasset_version\x18\x01 \x01(\x0e2\x14.taprpc.AssetVersionR\fassetVersion\x120\n" + + "\n" + + "asset_type\x18\x02 \x01(\x0e2\x11.taprpc.AssetTypeR\tassetType\x12\x12\n" + + "\x04name\x18\x03 \x01(\tR\x04name\x120\n" + + "\n" + + "asset_meta\x18\x04 \x01(\v2\x11.taprpc.AssetMetaR\tassetMeta\x12\x16\n" + + "\x06amount\x18\x05 \x01(\x04R\x06amount\x12*\n" + + "\x11new_grouped_asset\x18\x06 \x01(\bR\x0fnewGroupedAsset\x12#\n" + + "\rgrouped_asset\x18\a \x01(\bR\fgroupedAsset\x12\x1b\n" + + "\tgroup_key\x18\b \x01(\fR\bgroupKey\x12!\n" + + "\fgroup_anchor\x18\t \x01(\tR\vgroupAnchor\x12C\n" + + "\x12group_internal_key\x18\n" + + " \x01(\v2\x15.taprpc.KeyDescriptorR\x10groupInternalKey\x120\n" + + "\x14group_tapscript_root\x18\v \x01(\fR\x12groupTapscriptRoot\x120\n" + + "\n" + + "script_key\x18\f \x01(\v2\x11.taprpc.ScriptKeyR\tscriptKey\x12'\n" + + "\x0fdecimal_display\x18\r \x01(\rR\x0edecimalDisplay\x12A\n" + + "\x12external_group_key\x18\x0e \x01(\v2\x13.taprpc.ExternalKeyR\x10externalGroupKey\x121\n" + + "\x14universe_commitments\x18\x0f \x01(\bR\x13universeCommitments\"c\n" + + "\x10MintAssetRequest\x12(\n" + + "\x05asset\x18\x01 \x01(\v2\x12.mintrpc.MintAssetR\x05asset\x12%\n" + + "\x0eshort_response\x18\x02 \x01(\bR\rshortResponse\"O\n" + + "\x11MintAssetResponse\x12:\n" + + "\rpending_batch\x18\x01 \x01(\v2\x15.mintrpc.MintingBatchR\fpendingBatch\"\x83\x02\n" + + "\fMintingBatch\x12\x1b\n" + + "\tbatch_key\x18\x01 \x01(\fR\bbatchKey\x12\x1d\n" + + "\n" + + "batch_txid\x18\x02 \x01(\tR\tbatchTxid\x12)\n" + + "\x05state\x18\x03 \x01(\x0e2\x13.mintrpc.BatchStateR\x05state\x12-\n" + + "\x06assets\x18\x04 \x03(\v2\x15.mintrpc.PendingAssetR\x06assets\x12\x1d\n" + + "\n" + + "created_at\x18\x05 \x01(\x03R\tcreatedAt\x12\x1f\n" + + "\vheight_hint\x18\x06 \x01(\rR\n" + + "heightHint\x12\x1d\n" + + "\n" + + "batch_psbt\x18\a \x01(\fR\tbatchPsbt\"|\n" + + "\fVerboseBatch\x12+\n" + + "\x05batch\x18\x01 \x01(\v2\x15.mintrpc.MintingBatchR\x05batch\x12?\n" + + "\x0funsealed_assets\x18\x02 \x03(\v2\x16.mintrpc.UnsealedAssetR\x0eunsealedAssets\"\xcc\x01\n" + + "\x10FundBatchRequest\x12%\n" + + "\x0eshort_response\x18\x01 \x01(\bR\rshortResponse\x12\x19\n" + + "\bfee_rate\x18\x02 \x01(\rR\afeeRate\x128\n" + + "\tfull_tree\x18\x03 \x01(\v2\x19.taprpc.TapscriptFullTreeH\x00R\bfullTree\x12+\n" + + "\x06branch\x18\x04 \x01(\v2\x11.taprpc.TapBranchH\x00R\x06branchB\x0f\n" + + "\rbatch_sibling\"@\n" + + "\x11FundBatchResponse\x12+\n" + + "\x05batch\x18\x01 \x01(\v2\x15.mintrpc.VerboseBatchR\x05batch\"\xb5\x01\n" + + "\x10SealBatchRequest\x12%\n" + + "\x0eshort_response\x18\x01 \x01(\bR\rshortResponse\x12=\n" + + "\x0fgroup_witnesses\x18\x02 \x03(\v2\x14.taprpc.GroupWitnessR\x0egroupWitnesses\x12;\n" + + "\x1asigned_group_virtual_psbts\x18\x03 \x03(\tR\x17signedGroupVirtualPsbts\"@\n" + + "\x11SealBatchResponse\x12+\n" + + "\x05batch\x18\x01 \x01(\v2\x15.mintrpc.MintingBatchR\x05batch\"\xd0\x01\n" + + "\x14FinalizeBatchRequest\x12%\n" + + "\x0eshort_response\x18\x01 \x01(\bR\rshortResponse\x12\x19\n" + + "\bfee_rate\x18\x02 \x01(\rR\afeeRate\x128\n" + + "\tfull_tree\x18\x03 \x01(\v2\x19.taprpc.TapscriptFullTreeH\x00R\bfullTree\x12+\n" + + "\x06branch\x18\x04 \x01(\v2\x11.taprpc.TapBranchH\x00R\x06branchB\x0f\n" + + "\rbatch_sibling\"D\n" + + "\x15FinalizeBatchResponse\x12+\n" + + "\x05batch\x18\x01 \x01(\v2\x15.mintrpc.MintingBatchR\x05batch\"\x14\n" + + "\x12CancelBatchRequest\"2\n" + + "\x13CancelBatchResponse\x12\x1b\n" + + "\tbatch_key\x18\x01 \x01(\fR\bbatchKey\"{\n" + + "\x10ListBatchRequest\x12\x1d\n" + + "\tbatch_key\x18\x01 \x01(\fH\x00R\bbatchKey\x12$\n" + + "\rbatch_key_str\x18\x02 \x01(\tH\x00R\vbatchKeyStr\x12\x18\n" + + "\averbose\x18\x03 \x01(\bR\averboseB\b\n" + + "\x06filter\"D\n" + + "\x11ListBatchResponse\x12/\n" + + "\abatches\x18\x01 \x03(\v2\x15.mintrpc.VerboseBatchR\abatches\"C\n" + + "\x1aSubscribeMintEventsRequest\x12%\n" + + "\x0eshort_response\x18\x01 \x01(\bR\rshortResponse\"\xa2\x01\n" + + "\tMintEvent\x12\x1c\n" + + "\ttimestamp\x18\x01 \x01(\x03R\ttimestamp\x124\n" + + "\vbatch_state\x18\x02 \x01(\x0e2\x13.mintrpc.BatchStateR\n" + + "batchState\x12+\n" + + "\x05batch\x18\x03 \x01(\v2\x15.mintrpc.MintingBatchR\x05batch\x12\x14\n" + + "\x05error\x18\x04 \x01(\tR\x05error*\x88\x02\n" + + "\n" + + "BatchState\x12\x17\n" + + "\x13BATCH_STATE_UNKNOWN\x10\x00\x12\x17\n" + + "\x13BATCH_STATE_PENDING\x10\x01\x12\x16\n" + + "\x12BATCH_STATE_FROZEN\x10\x02\x12\x19\n" + + "\x15BATCH_STATE_COMMITTED\x10\x03\x12\x19\n" + + "\x15BATCH_STATE_BROADCAST\x10\x04\x12\x19\n" + + "\x15BATCH_STATE_CONFIRMED\x10\x05\x12\x19\n" + + "\x15BATCH_STATE_FINALIZED\x10\x06\x12\"\n" + + "\x1eBATCH_STATE_SEEDLING_CANCELLED\x10\a\x12 \n" + + "\x1cBATCH_STATE_SPROUT_CANCELLED\x10\b2\x84\x04\n" + + "\x04Mint\x12B\n" + + "\tMintAsset\x12\x19.mintrpc.MintAssetRequest\x1a\x1a.mintrpc.MintAssetResponse\x12B\n" + + "\tFundBatch\x12\x19.mintrpc.FundBatchRequest\x1a\x1a.mintrpc.FundBatchResponse\x12B\n" + + "\tSealBatch\x12\x19.mintrpc.SealBatchRequest\x1a\x1a.mintrpc.SealBatchResponse\x12N\n" + + "\rFinalizeBatch\x12\x1d.mintrpc.FinalizeBatchRequest\x1a\x1e.mintrpc.FinalizeBatchResponse\x12H\n" + + "\vCancelBatch\x12\x1b.mintrpc.CancelBatchRequest\x1a\x1c.mintrpc.CancelBatchResponse\x12D\n" + + "\vListBatches\x12\x19.mintrpc.ListBatchRequest\x1a\x1a.mintrpc.ListBatchResponse\x12P\n" + + "\x13SubscribeMintEvents\x12#.mintrpc.SubscribeMintEventsRequest\x1a\x12.mintrpc.MintEvent0\x01B8Z6github.com/lightninglabs/taproot-assets/taprpc/mintrpcb\x06proto3" var ( file_mintrpc_mint_proto_rawDescOnce sync.Once - file_mintrpc_mint_proto_rawDescData = file_mintrpc_mint_proto_rawDesc + file_mintrpc_mint_proto_rawDescData []byte ) func file_mintrpc_mint_proto_rawDescGZIP() []byte { file_mintrpc_mint_proto_rawDescOnce.Do(func() { - file_mintrpc_mint_proto_rawDescData = protoimpl.X.CompressGZIP(file_mintrpc_mint_proto_rawDescData) + file_mintrpc_mint_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_mintrpc_mint_proto_rawDesc), len(file_mintrpc_mint_proto_rawDesc))) }) return file_mintrpc_mint_proto_rawDescData } @@ -1958,236 +1772,6 @@ func file_mintrpc_mint_proto_init() { if File_mintrpc_mint_proto != nil { return } - if !protoimpl.UnsafeEnabled { - file_mintrpc_mint_proto_msgTypes[0].Exporter = func(v any, i int) any { - switch v := v.(*PendingAsset); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[1].Exporter = func(v any, i int) any { - switch v := v.(*UnsealedAsset); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[2].Exporter = func(v any, i int) any { - switch v := v.(*MintAsset); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[3].Exporter = func(v any, i int) any { - switch v := v.(*MintAssetRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[4].Exporter = func(v any, i int) any { - switch v := v.(*MintAssetResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[5].Exporter = func(v any, i int) any { - switch v := v.(*MintingBatch); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[6].Exporter = func(v any, i int) any { - switch v := v.(*VerboseBatch); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[7].Exporter = func(v any, i int) any { - switch v := v.(*FundBatchRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[8].Exporter = func(v any, i int) any { - switch v := v.(*FundBatchResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[9].Exporter = func(v any, i int) any { - switch v := v.(*SealBatchRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[10].Exporter = func(v any, i int) any { - switch v := v.(*SealBatchResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[11].Exporter = func(v any, i int) any { - switch v := v.(*FinalizeBatchRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_mintrpc_mint_proto_msgTypes[12].Exporter = func(v any, i int) any { - 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 any, i int) any { - 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 any, i int) any { - 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 any, i int) any { - 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 any, i int) any { - 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 any, i int) any { - 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 any, i int) any { - switch v := v.(*MintEvent); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - } file_mintrpc_mint_proto_msgTypes[7].OneofWrappers = []any{ (*FundBatchRequest_FullTree)(nil), (*FundBatchRequest_Branch)(nil), @@ -2204,7 +1788,7 @@ func file_mintrpc_mint_proto_init() { out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_mintrpc_mint_proto_rawDesc, + RawDescriptor: unsafe.Slice(unsafe.StringData(file_mintrpc_mint_proto_rawDesc), len(file_mintrpc_mint_proto_rawDesc)), NumEnums: 1, NumMessages: 19, NumExtensions: 0, @@ -2216,7 +1800,6 @@ func file_mintrpc_mint_proto_init() { MessageInfos: file_mintrpc_mint_proto_msgTypes, }.Build() File_mintrpc_mint_proto = out.File - file_mintrpc_mint_proto_rawDesc = nil file_mintrpc_mint_proto_goTypes = nil file_mintrpc_mint_proto_depIdxs = nil } diff --git a/taprpc/mintrpc/mint.pb.gw.go b/taprpc/mintrpc/mint.pb.gw.go index 9cca70af2..17634fc26 100644 --- a/taprpc/mintrpc/mint.pb.gw.go +++ b/taprpc/mintrpc/mint.pb.gw.go @@ -10,6 +10,7 @@ package mintrpc import ( "context" + "errors" "io" "net/http" @@ -24,163 +25,149 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = metadata.Join +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = errors.New + _ = runtime.String + _ = utilities.NewDoubleArray + _ = metadata.Join +) func request_Mint_MintAsset_0(ctx context.Context, marshaler runtime.Marshaler, client MintClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq MintAssetRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq MintAssetRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.MintAsset(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Mint_MintAsset_0(ctx context.Context, marshaler runtime.Marshaler, server MintServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq MintAssetRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq MintAssetRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.MintAsset(ctx, &protoReq) return msg, metadata, err - } 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 - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq FundBatchRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(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 - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq FundBatchRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(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 - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SealBatchRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(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 - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SealBatchRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(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 - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq FinalizeBatchRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.FinalizeBatch(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Mint_FinalizeBatch_0(ctx context.Context, marshaler runtime.Marshaler, server MintServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq FinalizeBatchRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq FinalizeBatchRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.FinalizeBatch(ctx, &protoReq) return msg, metadata, err - } func request_Mint_CancelBatch_0(ctx context.Context, marshaler runtime.Marshaler, client MintClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq CancelBatchRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq CancelBatchRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.CancelBatch(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Mint_CancelBatch_0(ctx context.Context, marshaler runtime.Marshaler, server MintServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq CancelBatchRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq CancelBatchRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.CancelBatch(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_Mint_ListBatches_0 = &utilities.DoubleArray{Encoding: map[string]int{"batch_key": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} -) +var filter_Mint_ListBatches_0 = &utilities.DoubleArray{Encoding: map[string]int{"batch_key": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} func request_Mint_ListBatches_0(ctx context.Context, marshaler runtime.Marshaler, client MintClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListBatchRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq ListBatchRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["batch_key"] + io.Copy(io.Discard, req.Body) + val, ok := pathParams["batch_key"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "batch_key") } - if protoReq.Filter == nil { protoReq.Filter = &ListBatchRequest_BatchKey{} } else if _, ok := protoReq.Filter.(*ListBatchRequest_BatchKey); !ok { @@ -190,35 +177,26 @@ func request_Mint_ListBatches_0(ctx context.Context, marshaler runtime.Marshaler if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "batch_key", err) } - if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Mint_ListBatches_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.ListBatches(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Mint_ListBatches_0(ctx context.Context, marshaler runtime.Marshaler, server MintServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListBatchRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq ListBatchRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["batch_key"] + val, ok := pathParams["batch_key"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "batch_key") } - if protoReq.Filter == nil { protoReq.Filter = &ListBatchRequest_BatchKey{} } else if _, ok := protoReq.Filter.(*ListBatchRequest_BatchKey); !ok { @@ -228,27 +206,24 @@ func local_request_Mint_ListBatches_0(ctx context.Context, marshaler runtime.Mar if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "batch_key", err) } - if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Mint_ListBatches_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.ListBatches(ctx, &protoReq) return msg, metadata, err - } func request_Mint_SubscribeMintEvents_0(ctx context.Context, marshaler runtime.Marshaler, client MintClient, req *http.Request, pathParams map[string]string) (Mint_SubscribeMintEventsClient, runtime.ServerMetadata, error) { - var protoReq SubscribeMintEventsRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SubscribeMintEventsRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - stream, err := client.SubscribeMintEvents(ctx, &protoReq) if err != nil { return nil, metadata, err @@ -259,24 +234,21 @@ func request_Mint_SubscribeMintEvents_0(ctx context.Context, marshaler runtime.M } metadata.HeaderMD = header return stream, metadata, nil - } // RegisterMintHandlerServer registers the http handlers for service Mint to "mux". // UnaryRPC :call MintServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMintHandlerFromEndpoint instead. +// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call. func RegisterMintHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MintServer) error { - - mux.Handle("POST", pattern_Mint_MintAsset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Mint_MintAsset_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/MintAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/mintrpc.Mint/MintAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -288,20 +260,15 @@ func RegisterMintHandlerServer(ctx context.Context, mux *runtime.ServeMux, serve runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_MintAsset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Mint_FundBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, 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")) + 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 @@ -313,20 +280,15 @@ func RegisterMintHandlerServer(ctx context.Context, mux *runtime.ServeMux, serve 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) { + mux.Handle(http.MethodPost, 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")) + 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 @@ -338,20 +300,15 @@ func RegisterMintHandlerServer(ctx context.Context, mux *runtime.ServeMux, serve 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) { + mux.Handle(http.MethodPost, pattern_Mint_FinalizeBatch_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/FinalizeBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/finalize")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/mintrpc.Mint/FinalizeBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/finalize")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -363,20 +320,15 @@ func RegisterMintHandlerServer(ctx context.Context, mux *runtime.ServeMux, serve runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_FinalizeBatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Mint_CancelBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Mint_CancelBatch_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/CancelBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/cancel")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/mintrpc.Mint/CancelBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/cancel")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -388,20 +340,15 @@ func RegisterMintHandlerServer(ctx context.Context, mux *runtime.ServeMux, serve runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_CancelBatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_Mint_ListBatches_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_Mint_ListBatches_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/ListBatches", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/batches/{batch_key}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/mintrpc.Mint/ListBatches", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/batches/{batch_key}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -413,12 +360,10 @@ func RegisterMintHandlerServer(ctx context.Context, mux *runtime.ServeMux, serve runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_ListBatches_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - mux.Handle("POST", pattern_Mint_SubscribeMintEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Mint_SubscribeMintEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport") _, outboundMarshaler := runtime.MarshalerForRequest(mux, req) runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) @@ -449,7 +394,6 @@ func RegisterMintHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, } }() }() - return RegisterMintHandler(ctx, mux, conn) } @@ -463,16 +407,13 @@ func RegisterMintHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc. // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MintClient". // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MintClient" // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "MintClient" to call the correct interceptors. +// "MintClient" to call the correct interceptors. This client ignores the HTTP middlewares. func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MintClient) error { - - mux.Handle("POST", pattern_Mint_MintAsset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Mint_MintAsset_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/MintAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/mintrpc.Mint/MintAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -483,18 +424,13 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_MintAsset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Mint_FundBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, 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")) + 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 @@ -505,18 +441,13 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien 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) { + mux.Handle(http.MethodPost, 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")) + 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 @@ -527,18 +458,13 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien 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) { + mux.Handle(http.MethodPost, pattern_Mint_FinalizeBatch_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/FinalizeBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/finalize")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/mintrpc.Mint/FinalizeBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/finalize")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -549,18 +475,13 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_FinalizeBatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Mint_CancelBatch_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Mint_CancelBatch_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/CancelBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/cancel")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/mintrpc.Mint/CancelBatch", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/cancel")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -571,18 +492,13 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_CancelBatch_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_Mint_ListBatches_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_Mint_ListBatches_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/ListBatches", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/batches/{batch_key}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/mintrpc.Mint/ListBatches", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/mint/batches/{batch_key}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -593,18 +509,13 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_ListBatches_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Mint_SubscribeMintEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Mint_SubscribeMintEvents_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/SubscribeMintEvents", runtime.WithHTTPPathPattern("/v1/taproot-assets/events/asset-mint")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/mintrpc.Mint/SubscribeMintEvents", runtime.WithHTTPPathPattern("/v1/taproot-assets/events/asset-mint")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -615,42 +526,27 @@ func RegisterMintHandlerClient(ctx context.Context, mux *runtime.ServeMux, clien runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Mint_SubscribeMintEvents_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) - }) - return nil } 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"}, "")) - - pattern_Mint_ListBatches_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "assets", "mint", "batches", "batch_key"}, "")) - + 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"}, "")) + pattern_Mint_ListBatches_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "assets", "mint", "batches", "batch_key"}, "")) pattern_Mint_SubscribeMintEvents_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "events", "asset-mint"}, "")) ) 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 - - forward_Mint_ListBatches_0 = runtime.ForwardResponseMessage - + 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 + forward_Mint_ListBatches_0 = runtime.ForwardResponseMessage forward_Mint_SubscribeMintEvents_0 = runtime.ForwardResponseStream ) diff --git a/taprpc/mintrpc/mint_grpc.pb.go b/taprpc/mintrpc/mint_grpc.pb.go index b3ee711ab..41e8098da 100644 --- a/taprpc/mintrpc/mint_grpc.pb.go +++ b/taprpc/mintrpc/mint_grpc.pb.go @@ -1,4 +1,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc v3.21.12 +// source: mintrpc/mint.proto package mintrpc @@ -11,8 +15,18 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + Mint_MintAsset_FullMethodName = "/mintrpc.Mint/MintAsset" + Mint_FundBatch_FullMethodName = "/mintrpc.Mint/FundBatch" + Mint_SealBatch_FullMethodName = "/mintrpc.Mint/SealBatch" + Mint_FinalizeBatch_FullMethodName = "/mintrpc.Mint/FinalizeBatch" + Mint_CancelBatch_FullMethodName = "/mintrpc.Mint/CancelBatch" + Mint_ListBatches_FullMethodName = "/mintrpc.Mint/ListBatches" + Mint_SubscribeMintEvents_FullMethodName = "/mintrpc.Mint/SubscribeMintEvents" +) // MintClient is the client API for Mint service. // @@ -52,7 +66,7 @@ type MintClient interface { // tapcli: `events mint` // SubscribeMintEvents allows a caller to subscribe to mint events for asset // creation batches. - SubscribeMintEvents(ctx context.Context, in *SubscribeMintEventsRequest, opts ...grpc.CallOption) (Mint_SubscribeMintEventsClient, error) + SubscribeMintEvents(ctx context.Context, in *SubscribeMintEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[MintEvent], error) } type mintClient struct { @@ -64,8 +78,9 @@ func NewMintClient(cc grpc.ClientConnInterface) MintClient { } func (c *mintClient) MintAsset(ctx context.Context, in *MintAssetRequest, opts ...grpc.CallOption) (*MintAssetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(MintAssetResponse) - err := c.cc.Invoke(ctx, "/mintrpc.Mint/MintAsset", in, out, opts...) + err := c.cc.Invoke(ctx, Mint_MintAsset_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -73,8 +88,9 @@ func (c *mintClient) MintAsset(ctx context.Context, in *MintAssetRequest, opts . } func (c *mintClient) FundBatch(ctx context.Context, in *FundBatchRequest, opts ...grpc.CallOption) (*FundBatchResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(FundBatchResponse) - err := c.cc.Invoke(ctx, "/mintrpc.Mint/FundBatch", in, out, opts...) + err := c.cc.Invoke(ctx, Mint_FundBatch_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -82,8 +98,9 @@ func (c *mintClient) FundBatch(ctx context.Context, in *FundBatchRequest, opts . } func (c *mintClient) SealBatch(ctx context.Context, in *SealBatchRequest, opts ...grpc.CallOption) (*SealBatchResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(SealBatchResponse) - err := c.cc.Invoke(ctx, "/mintrpc.Mint/SealBatch", in, out, opts...) + err := c.cc.Invoke(ctx, Mint_SealBatch_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -91,8 +108,9 @@ func (c *mintClient) SealBatch(ctx context.Context, in *SealBatchRequest, opts . } func (c *mintClient) FinalizeBatch(ctx context.Context, in *FinalizeBatchRequest, opts ...grpc.CallOption) (*FinalizeBatchResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(FinalizeBatchResponse) - err := c.cc.Invoke(ctx, "/mintrpc.Mint/FinalizeBatch", in, out, opts...) + err := c.cc.Invoke(ctx, Mint_FinalizeBatch_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -100,8 +118,9 @@ func (c *mintClient) FinalizeBatch(ctx context.Context, in *FinalizeBatchRequest } func (c *mintClient) CancelBatch(ctx context.Context, in *CancelBatchRequest, opts ...grpc.CallOption) (*CancelBatchResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(CancelBatchResponse) - err := c.cc.Invoke(ctx, "/mintrpc.Mint/CancelBatch", in, out, opts...) + err := c.cc.Invoke(ctx, Mint_CancelBatch_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -109,20 +128,22 @@ func (c *mintClient) CancelBatch(ctx context.Context, in *CancelBatchRequest, op } func (c *mintClient) ListBatches(ctx context.Context, in *ListBatchRequest, opts ...grpc.CallOption) (*ListBatchResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ListBatchResponse) - err := c.cc.Invoke(ctx, "/mintrpc.Mint/ListBatches", in, out, opts...) + err := c.cc.Invoke(ctx, Mint_ListBatches_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *mintClient) SubscribeMintEvents(ctx context.Context, in *SubscribeMintEventsRequest, opts ...grpc.CallOption) (Mint_SubscribeMintEventsClient, error) { - stream, err := c.cc.NewStream(ctx, &Mint_ServiceDesc.Streams[0], "/mintrpc.Mint/SubscribeMintEvents", opts...) +func (c *mintClient) SubscribeMintEvents(ctx context.Context, in *SubscribeMintEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[MintEvent], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Mint_ServiceDesc.Streams[0], Mint_SubscribeMintEvents_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &mintSubscribeMintEventsClient{stream} + x := &grpc.GenericClientStream[SubscribeMintEventsRequest, MintEvent]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -132,26 +153,12 @@ func (c *mintClient) SubscribeMintEvents(ctx context.Context, in *SubscribeMintE return x, nil } -type Mint_SubscribeMintEventsClient interface { - Recv() (*MintEvent, error) - grpc.ClientStream -} - -type mintSubscribeMintEventsClient struct { - grpc.ClientStream -} - -func (x *mintSubscribeMintEventsClient) Recv() (*MintEvent, error) { - m := new(MintEvent) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Mint_SubscribeMintEventsClient = grpc.ServerStreamingClient[MintEvent] // MintServer is the server API for Mint service. // All implementations must embed UnimplementedMintServer -// for forward compatibility +// for forward compatibility. type MintServer interface { // tapcli: `assets mint` // MintAsset will attempt to mint the set of assets (async by default to @@ -187,13 +194,16 @@ type MintServer interface { // tapcli: `events mint` // SubscribeMintEvents allows a caller to subscribe to mint events for asset // creation batches. - SubscribeMintEvents(*SubscribeMintEventsRequest, Mint_SubscribeMintEventsServer) error + SubscribeMintEvents(*SubscribeMintEventsRequest, grpc.ServerStreamingServer[MintEvent]) error mustEmbedUnimplementedMintServer() } -// UnimplementedMintServer must be embedded to have forward compatible implementations. -type UnimplementedMintServer struct { -} +// UnimplementedMintServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedMintServer struct{} func (UnimplementedMintServer) MintAsset(context.Context, *MintAssetRequest) (*MintAssetResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method MintAsset not implemented") @@ -213,10 +223,11 @@ func (UnimplementedMintServer) CancelBatch(context.Context, *CancelBatchRequest) func (UnimplementedMintServer) ListBatches(context.Context, *ListBatchRequest) (*ListBatchResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListBatches not implemented") } -func (UnimplementedMintServer) SubscribeMintEvents(*SubscribeMintEventsRequest, Mint_SubscribeMintEventsServer) error { +func (UnimplementedMintServer) SubscribeMintEvents(*SubscribeMintEventsRequest, grpc.ServerStreamingServer[MintEvent]) error { return status.Errorf(codes.Unimplemented, "method SubscribeMintEvents not implemented") } func (UnimplementedMintServer) mustEmbedUnimplementedMintServer() {} +func (UnimplementedMintServer) testEmbeddedByValue() {} // UnsafeMintServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to MintServer will @@ -226,6 +237,13 @@ type UnsafeMintServer interface { } func RegisterMintServer(s grpc.ServiceRegistrar, srv MintServer) { + // If the following call pancis, it indicates UnimplementedMintServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Mint_ServiceDesc, srv) } @@ -239,7 +257,7 @@ func _Mint_MintAsset_Handler(srv interface{}, ctx context.Context, dec func(inte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mintrpc.Mint/MintAsset", + FullMethod: Mint_MintAsset_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MintServer).MintAsset(ctx, req.(*MintAssetRequest)) @@ -257,7 +275,7 @@ func _Mint_FundBatch_Handler(srv interface{}, ctx context.Context, dec func(inte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mintrpc.Mint/FundBatch", + FullMethod: Mint_FundBatch_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MintServer).FundBatch(ctx, req.(*FundBatchRequest)) @@ -275,7 +293,7 @@ func _Mint_SealBatch_Handler(srv interface{}, ctx context.Context, dec func(inte } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mintrpc.Mint/SealBatch", + FullMethod: Mint_SealBatch_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MintServer).SealBatch(ctx, req.(*SealBatchRequest)) @@ -293,7 +311,7 @@ func _Mint_FinalizeBatch_Handler(srv interface{}, ctx context.Context, dec func( } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mintrpc.Mint/FinalizeBatch", + FullMethod: Mint_FinalizeBatch_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MintServer).FinalizeBatch(ctx, req.(*FinalizeBatchRequest)) @@ -311,7 +329,7 @@ func _Mint_CancelBatch_Handler(srv interface{}, ctx context.Context, dec func(in } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mintrpc.Mint/CancelBatch", + FullMethod: Mint_CancelBatch_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MintServer).CancelBatch(ctx, req.(*CancelBatchRequest)) @@ -329,7 +347,7 @@ func _Mint_ListBatches_Handler(srv interface{}, ctx context.Context, dec func(in } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/mintrpc.Mint/ListBatches", + FullMethod: Mint_ListBatches_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(MintServer).ListBatches(ctx, req.(*ListBatchRequest)) @@ -342,21 +360,11 @@ func _Mint_SubscribeMintEvents_Handler(srv interface{}, stream grpc.ServerStream if err := stream.RecvMsg(m); err != nil { return err } - return srv.(MintServer).SubscribeMintEvents(m, &mintSubscribeMintEventsServer{stream}) -} - -type Mint_SubscribeMintEventsServer interface { - Send(*MintEvent) error - grpc.ServerStream -} - -type mintSubscribeMintEventsServer struct { - grpc.ServerStream + return srv.(MintServer).SubscribeMintEvents(m, &grpc.GenericServerStream[SubscribeMintEventsRequest, MintEvent]{ServerStream: stream}) } -func (x *mintSubscribeMintEventsServer) Send(m *MintEvent) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Mint_SubscribeMintEventsServer = grpc.ServerStreamingServer[MintEvent] // Mint_ServiceDesc is the grpc.ServiceDesc for Mint service. // It's only intended for direct use with grpc.RegisterService, diff --git a/taprpc/priceoraclerpc/price_oracle.pb.go b/taprpc/priceoraclerpc/price_oracle.pb.go index 6becebda0..b98424674 100644 --- a/taprpc/priceoraclerpc/price_oracle.pb.go +++ b/taprpc/priceoraclerpc/price_oracle.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.34.2 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: priceoraclerpc/price_oracle.proto @@ -11,6 +11,7 @@ import ( protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + unsafe "unsafe" ) const ( @@ -92,26 +93,23 @@ func (TransactionType) EnumDescriptor() ([]byte, []int) { // many decimal places `F_c` should be divided by to obtain the fractional // representation. type FixedPoint struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The coefficient is the fractional value scaled-up as an integer. This // integer is represented as a string as it may be too large to fit in a // uint64. Coefficient string `protobuf:"bytes,1,opt,name=coefficient,proto3" json:"coefficient,omitempty"` // The scale is the component that determines how many decimal places // the coefficient should be divided by to obtain the fractional value. - Scale uint32 `protobuf:"varint,2,opt,name=scale,proto3" json:"scale,omitempty"` + Scale uint32 `protobuf:"varint,2,opt,name=scale,proto3" json:"scale,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *FixedPoint) Reset() { *x = FixedPoint{} - if protoimpl.UnsafeEnabled { - mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FixedPoint) String() string { @@ -122,7 +120,7 @@ func (*FixedPoint) ProtoMessage() {} func (x *FixedPoint) ProtoReflect() protoreflect.Message { mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -156,10 +154,7 @@ func (x *FixedPoint) GetScale() uint32 { // for both assets and an expiration timestamp indicating when the rates // are no longer valid. type AssetRates struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // subjectAssetRate is the number of subject asset units per BTC represented // as a fixed-point number. This field is also commonly referred to as the // subject asset to BTC (conversion) rate. When the subject asset is BTC, @@ -175,15 +170,15 @@ type AssetRates struct { // expiry_timestamp is the Unix timestamp in seconds after which the asset // rates are no longer valid. ExpiryTimestamp uint64 `protobuf:"varint,3,opt,name=expiry_timestamp,json=expiryTimestamp,proto3" json:"expiry_timestamp,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetRates) Reset() { *x = AssetRates{} - if protoimpl.UnsafeEnabled { - mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetRates) String() string { @@ -194,7 +189,7 @@ func (*AssetRates) ProtoMessage() {} func (x *AssetRates) ProtoReflect() protoreflect.Message { mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[1] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -233,26 +228,23 @@ func (x *AssetRates) GetExpiryTimestamp() uint64 { // AssetSpecifier is a union type for specifying an asset by either its asset ID // or group key. type AssetSpecifier struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Id: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Id: // // *AssetSpecifier_AssetId // *AssetSpecifier_AssetIdStr // *AssetSpecifier_GroupKey // *AssetSpecifier_GroupKeyStr - Id isAssetSpecifier_Id `protobuf_oneof:"id"` + Id isAssetSpecifier_Id `protobuf_oneof:"id"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetSpecifier) Reset() { *x = AssetSpecifier{} - if protoimpl.UnsafeEnabled { - mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetSpecifier) String() string { @@ -263,7 +255,7 @@ func (*AssetSpecifier) ProtoMessage() {} func (x *AssetSpecifier) ProtoReflect() protoreflect.Message { mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -278,37 +270,45 @@ func (*AssetSpecifier) Descriptor() ([]byte, []int) { return file_priceoraclerpc_price_oracle_proto_rawDescGZIP(), []int{2} } -func (m *AssetSpecifier) GetId() isAssetSpecifier_Id { - if m != nil { - return m.Id +func (x *AssetSpecifier) GetId() isAssetSpecifier_Id { + if x != nil { + return x.Id } return nil } func (x *AssetSpecifier) GetAssetId() []byte { - if x, ok := x.GetId().(*AssetSpecifier_AssetId); ok { - return x.AssetId + if x != nil { + if x, ok := x.Id.(*AssetSpecifier_AssetId); ok { + return x.AssetId + } } return nil } func (x *AssetSpecifier) GetAssetIdStr() string { - if x, ok := x.GetId().(*AssetSpecifier_AssetIdStr); ok { - return x.AssetIdStr + if x != nil { + if x, ok := x.Id.(*AssetSpecifier_AssetIdStr); ok { + return x.AssetIdStr + } } return "" } func (x *AssetSpecifier) GetGroupKey() []byte { - if x, ok := x.GetId().(*AssetSpecifier_GroupKey); ok { - return x.GroupKey + if x != nil { + if x, ok := x.Id.(*AssetSpecifier_GroupKey); ok { + return x.GroupKey + } } return nil } func (x *AssetSpecifier) GetGroupKeyStr() string { - if x, ok := x.GetId().(*AssetSpecifier_GroupKeyStr); ok { - return x.GroupKeyStr + if x != nil { + if x, ok := x.Id.(*AssetSpecifier_GroupKeyStr); ok { + return x.GroupKeyStr + } } return "" } @@ -350,10 +350,7 @@ func (*AssetSpecifier_GroupKeyStr) isAssetSpecifier_Id() {} // rates in a transaction. It includes the transaction type, details about the // subject and payment assets, and an optional hint for expected asset rates. type QueryAssetRatesRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // transaction_type indicates whether the transaction is a purchase or a // sale. TransactionType TransactionType `protobuf:"varint,1,opt,name=transaction_type,json=transactionType,proto3,enum=priceoraclerpc.TransactionType" json:"transaction_type,omitempty"` @@ -375,15 +372,15 @@ type QueryAssetRatesRequest struct { // asset_rates_hint is an optional suggestion of asset rates for the // transaction, intended to provide guidance on expected pricing. AssetRatesHint *AssetRates `protobuf:"bytes,6,opt,name=asset_rates_hint,json=assetRatesHint,proto3" json:"asset_rates_hint,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryAssetRatesRequest) Reset() { *x = QueryAssetRatesRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryAssetRatesRequest) String() string { @@ -394,7 +391,7 @@ func (*QueryAssetRatesRequest) ProtoMessage() {} func (x *QueryAssetRatesRequest) ProtoReflect() protoreflect.Message { mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[3] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -454,21 +451,18 @@ func (x *QueryAssetRatesRequest) GetAssetRatesHint() *AssetRates { // QueryAssetRatesOkResponse is the successful response to a // QueryAssetRates call. type QueryAssetRatesOkResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // asset_rates is the asset exchange rates for the transaction. - AssetRates *AssetRates `protobuf:"bytes,1,opt,name=asset_rates,json=assetRates,proto3" json:"asset_rates,omitempty"` + AssetRates *AssetRates `protobuf:"bytes,1,opt,name=asset_rates,json=assetRates,proto3" json:"asset_rates,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryAssetRatesOkResponse) Reset() { *x = QueryAssetRatesOkResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryAssetRatesOkResponse) String() string { @@ -479,7 +473,7 @@ func (*QueryAssetRatesOkResponse) ProtoMessage() {} func (x *QueryAssetRatesOkResponse) ProtoReflect() protoreflect.Message { mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -503,23 +497,20 @@ func (x *QueryAssetRatesOkResponse) GetAssetRates() *AssetRates { // QueryAssetRatesErrResponse is the error response to a QueryAssetRates call. type QueryAssetRatesErrResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // error is the error message. Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` // code is the error code. - Code uint32 `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"` + Code uint32 `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryAssetRatesErrResponse) Reset() { *x = QueryAssetRatesErrResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryAssetRatesErrResponse) String() string { @@ -530,7 +521,7 @@ func (*QueryAssetRatesErrResponse) ProtoMessage() {} func (x *QueryAssetRatesErrResponse) ProtoReflect() protoreflect.Message { mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[5] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -561,24 +552,21 @@ func (x *QueryAssetRatesErrResponse) GetCode() uint32 { // QueryAssetRatesResponse is the response from a QueryAssetRates RPC call. type QueryAssetRatesResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Result: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Result: // // *QueryAssetRatesResponse_Ok // *QueryAssetRatesResponse_Error - Result isQueryAssetRatesResponse_Result `protobuf_oneof:"result"` + Result isQueryAssetRatesResponse_Result `protobuf_oneof:"result"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryAssetRatesResponse) Reset() { *x = QueryAssetRatesResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryAssetRatesResponse) String() string { @@ -589,7 +577,7 @@ func (*QueryAssetRatesResponse) ProtoMessage() {} func (x *QueryAssetRatesResponse) ProtoReflect() protoreflect.Message { mi := &file_priceoraclerpc_price_oracle_proto_msgTypes[6] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -604,23 +592,27 @@ func (*QueryAssetRatesResponse) Descriptor() ([]byte, []int) { return file_priceoraclerpc_price_oracle_proto_rawDescGZIP(), []int{6} } -func (m *QueryAssetRatesResponse) GetResult() isQueryAssetRatesResponse_Result { - if m != nil { - return m.Result +func (x *QueryAssetRatesResponse) GetResult() isQueryAssetRatesResponse_Result { + if x != nil { + return x.Result } return nil } func (x *QueryAssetRatesResponse) GetOk() *QueryAssetRatesOkResponse { - if x, ok := x.GetResult().(*QueryAssetRatesResponse_Ok); ok { - return x.Ok + if x != nil { + if x, ok := x.Result.(*QueryAssetRatesResponse_Ok); ok { + return x.Ok + } } return nil } func (x *QueryAssetRatesResponse) GetError() *QueryAssetRatesErrResponse { - if x, ok := x.GetResult().(*QueryAssetRatesResponse_Error); ok { - return x.Error + if x != nil { + if x, ok := x.Result.(*QueryAssetRatesResponse_Error); ok { + return x.Error + } } return nil } @@ -645,109 +637,56 @@ func (*QueryAssetRatesResponse_Error) isQueryAssetRatesResponse_Result() {} var File_priceoraclerpc_price_oracle_proto protoreflect.FileDescriptor -var file_priceoraclerpc_price_oracle_proto_rawDesc = []byte{ - 0x0a, 0x21, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, - 0x2f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x12, 0x0e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, - 0x72, 0x70, 0x63, 0x22, 0x44, 0x0a, 0x0a, 0x46, 0x69, 0x78, 0x65, 0x64, 0x50, 0x6f, 0x69, 0x6e, - 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, - 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x22, 0xc7, 0x01, 0x0a, 0x0a, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x46, 0x0a, 0x10, 0x73, 0x75, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, - 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x10, - 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, - 0x12, 0x46, 0x0a, 0x10, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x52, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x70, 0x72, 0x69, - 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x78, 0x65, - 0x64, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x10, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x78, 0x70, 0x69, - 0x72, 0x79, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x04, 0x52, 0x0f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, - 0x61, 0x6d, 0x70, 0x22, 0x9c, 0x01, 0x0a, 0x0e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, 0x65, - 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x08, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, - 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0a, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x49, 0x64, 0x53, 0x74, 0x72, 0x12, 0x1d, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, - 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x08, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, - 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, - 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x72, 0x42, 0x04, 0x0a, 0x02, - 0x69, 0x64, 0x22, 0xa6, 0x03, 0x0a, 0x16, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4a, 0x0a, - 0x10, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, - 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x43, 0x0a, 0x0d, 0x73, 0x75, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1e, 0x2e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, - 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, - 0x52, 0x0c, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x37, - 0x0a, 0x18, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, - 0x52, 0x15, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x61, - 0x78, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x43, 0x0a, 0x0d, 0x70, 0x61, 0x79, 0x6d, 0x65, - 0x6e, 0x74, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, - 0x2e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0c, - 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x37, 0x0a, 0x18, - 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6d, 0x61, - 0x78, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x15, - 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x61, 0x78, 0x41, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x44, 0x0a, 0x10, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x72, - 0x61, 0x74, 0x65, 0x73, 0x5f, 0x68, 0x69, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1a, 0x2e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, - 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x0e, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x48, 0x69, 0x6e, 0x74, 0x22, 0x58, 0x0a, 0x19, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x4f, 0x6b, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0b, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x5f, 0x72, 0x61, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, - 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x52, 0x61, 0x74, 0x65, 0x73, 0x22, 0x4a, 0x0a, 0x1a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x45, 0x72, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, - 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x63, 0x6f, 0x64, - 0x65, 0x22, 0xa4, 0x01, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, - 0x02, 0x6f, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x70, 0x72, 0x69, 0x63, - 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x4f, 0x6b, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x02, 0x6f, 0x6b, 0x12, 0x42, 0x0a, 0x05, 0x65, 0x72, - 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x70, 0x72, 0x69, 0x63, - 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x45, 0x72, 0x72, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x42, 0x08, - 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2a, 0x29, 0x0a, 0x0f, 0x54, 0x72, 0x61, 0x6e, - 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x50, - 0x55, 0x52, 0x43, 0x48, 0x41, 0x53, 0x45, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x53, 0x41, 0x4c, - 0x45, 0x10, 0x01, 0x32, 0x71, 0x0a, 0x0b, 0x50, 0x72, 0x69, 0x63, 0x65, 0x4f, 0x72, 0x61, 0x63, - 0x6c, 0x65, 0x12, 0x62, 0x0a, 0x0f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x52, 0x61, 0x74, 0x65, 0x73, 0x12, 0x26, 0x2e, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, - 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, - 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3f, 0x5a, 0x3d, 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, 0x70, 0x72, 0x69, 0x63, 0x65, 0x6f, 0x72, - 0x61, 0x63, 0x6c, 0x65, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, -} +const file_priceoraclerpc_price_oracle_proto_rawDesc = "" + + "\n" + + "!priceoraclerpc/price_oracle.proto\x12\x0epriceoraclerpc\"D\n" + + "\n" + + "FixedPoint\x12 \n" + + "\vcoefficient\x18\x01 \x01(\tR\vcoefficient\x12\x14\n" + + "\x05scale\x18\x02 \x01(\rR\x05scale\"\xc7\x01\n" + + "\n" + + "AssetRates\x12F\n" + + "\x10subjectAssetRate\x18\x01 \x01(\v2\x1a.priceoraclerpc.FixedPointR\x10subjectAssetRate\x12F\n" + + "\x10paymentAssetRate\x18\x02 \x01(\v2\x1a.priceoraclerpc.FixedPointR\x10paymentAssetRate\x12)\n" + + "\x10expiry_timestamp\x18\x03 \x01(\x04R\x0fexpiryTimestamp\"\x9c\x01\n" + + "\x0eAssetSpecifier\x12\x1b\n" + + "\basset_id\x18\x01 \x01(\fH\x00R\aassetId\x12\"\n" + + "\fasset_id_str\x18\x02 \x01(\tH\x00R\n" + + "assetIdStr\x12\x1d\n" + + "\tgroup_key\x18\x03 \x01(\fH\x00R\bgroupKey\x12$\n" + + "\rgroup_key_str\x18\x04 \x01(\tH\x00R\vgroupKeyStrB\x04\n" + + "\x02id\"\xa6\x03\n" + + "\x16QueryAssetRatesRequest\x12J\n" + + "\x10transaction_type\x18\x01 \x01(\x0e2\x1f.priceoraclerpc.TransactionTypeR\x0ftransactionType\x12C\n" + + "\rsubject_asset\x18\x02 \x01(\v2\x1e.priceoraclerpc.AssetSpecifierR\fsubjectAsset\x127\n" + + "\x18subject_asset_max_amount\x18\x03 \x01(\x04R\x15subjectAssetMaxAmount\x12C\n" + + "\rpayment_asset\x18\x04 \x01(\v2\x1e.priceoraclerpc.AssetSpecifierR\fpaymentAsset\x127\n" + + "\x18payment_asset_max_amount\x18\x05 \x01(\x04R\x15paymentAssetMaxAmount\x12D\n" + + "\x10asset_rates_hint\x18\x06 \x01(\v2\x1a.priceoraclerpc.AssetRatesR\x0eassetRatesHint\"X\n" + + "\x19QueryAssetRatesOkResponse\x12;\n" + + "\vasset_rates\x18\x01 \x01(\v2\x1a.priceoraclerpc.AssetRatesR\n" + + "assetRates\"J\n" + + "\x1aQueryAssetRatesErrResponse\x12\x18\n" + + "\amessage\x18\x01 \x01(\tR\amessage\x12\x12\n" + + "\x04code\x18\x02 \x01(\rR\x04code\"\xa4\x01\n" + + "\x17QueryAssetRatesResponse\x12;\n" + + "\x02ok\x18\x01 \x01(\v2).priceoraclerpc.QueryAssetRatesOkResponseH\x00R\x02ok\x12B\n" + + "\x05error\x18\x02 \x01(\v2*.priceoraclerpc.QueryAssetRatesErrResponseH\x00R\x05errorB\b\n" + + "\x06result*)\n" + + "\x0fTransactionType\x12\f\n" + + "\bPURCHASE\x10\x00\x12\b\n" + + "\x04SALE\x10\x012q\n" + + "\vPriceOracle\x12b\n" + + "\x0fQueryAssetRates\x12&.priceoraclerpc.QueryAssetRatesRequest\x1a'.priceoraclerpc.QueryAssetRatesResponseB?Z=github.com/lightninglabs/taproot-assets/taprpc/priceoraclerpcb\x06proto3" var ( file_priceoraclerpc_price_oracle_proto_rawDescOnce sync.Once - file_priceoraclerpc_price_oracle_proto_rawDescData = file_priceoraclerpc_price_oracle_proto_rawDesc + file_priceoraclerpc_price_oracle_proto_rawDescData []byte ) func file_priceoraclerpc_price_oracle_proto_rawDescGZIP() []byte { file_priceoraclerpc_price_oracle_proto_rawDescOnce.Do(func() { - file_priceoraclerpc_price_oracle_proto_rawDescData = protoimpl.X.CompressGZIP(file_priceoraclerpc_price_oracle_proto_rawDescData) + file_priceoraclerpc_price_oracle_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_priceoraclerpc_price_oracle_proto_rawDesc), len(file_priceoraclerpc_price_oracle_proto_rawDesc))) }) return file_priceoraclerpc_price_oracle_proto_rawDescData } @@ -788,92 +727,6 @@ func file_priceoraclerpc_price_oracle_proto_init() { if File_priceoraclerpc_price_oracle_proto != nil { return } - if !protoimpl.UnsafeEnabled { - file_priceoraclerpc_price_oracle_proto_msgTypes[0].Exporter = func(v any, i int) any { - switch v := v.(*FixedPoint); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_priceoraclerpc_price_oracle_proto_msgTypes[1].Exporter = func(v any, i int) any { - switch v := v.(*AssetRates); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_priceoraclerpc_price_oracle_proto_msgTypes[2].Exporter = func(v any, i int) any { - switch v := v.(*AssetSpecifier); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_priceoraclerpc_price_oracle_proto_msgTypes[3].Exporter = func(v any, i int) any { - switch v := v.(*QueryAssetRatesRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_priceoraclerpc_price_oracle_proto_msgTypes[4].Exporter = func(v any, i int) any { - switch v := v.(*QueryAssetRatesOkResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_priceoraclerpc_price_oracle_proto_msgTypes[5].Exporter = func(v any, i int) any { - switch v := v.(*QueryAssetRatesErrResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_priceoraclerpc_price_oracle_proto_msgTypes[6].Exporter = func(v any, i int) any { - switch v := v.(*QueryAssetRatesResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - } file_priceoraclerpc_price_oracle_proto_msgTypes[2].OneofWrappers = []any{ (*AssetSpecifier_AssetId)(nil), (*AssetSpecifier_AssetIdStr)(nil), @@ -888,7 +741,7 @@ func file_priceoraclerpc_price_oracle_proto_init() { out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_priceoraclerpc_price_oracle_proto_rawDesc, + RawDescriptor: unsafe.Slice(unsafe.StringData(file_priceoraclerpc_price_oracle_proto_rawDesc), len(file_priceoraclerpc_price_oracle_proto_rawDesc)), NumEnums: 1, NumMessages: 7, NumExtensions: 0, @@ -900,7 +753,6 @@ func file_priceoraclerpc_price_oracle_proto_init() { MessageInfos: file_priceoraclerpc_price_oracle_proto_msgTypes, }.Build() File_priceoraclerpc_price_oracle_proto = out.File - file_priceoraclerpc_price_oracle_proto_rawDesc = nil file_priceoraclerpc_price_oracle_proto_goTypes = nil file_priceoraclerpc_price_oracle_proto_depIdxs = nil } diff --git a/taprpc/priceoraclerpc/price_oracle.pb.gw.go b/taprpc/priceoraclerpc/price_oracle.pb.gw.go index 2f9501573..ce81412f3 100644 --- a/taprpc/priceoraclerpc/price_oracle.pb.gw.go +++ b/taprpc/priceoraclerpc/price_oracle.pb.gw.go @@ -10,6 +10,7 @@ package priceoraclerpc import ( "context" + "errors" "io" "net/http" @@ -24,64 +25,62 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = metadata.Join - var ( - filter_PriceOracle_QueryAssetRates_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + _ codes.Code + _ io.Reader + _ status.Status + _ = errors.New + _ = runtime.String + _ = utilities.NewDoubleArray + _ = metadata.Join ) -func request_PriceOracle_QueryAssetRates_0(ctx context.Context, marshaler runtime.Marshaler, client PriceOracleClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryAssetRatesRequest - var metadata runtime.ServerMetadata +var filter_PriceOracle_QueryAssetRates_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +func request_PriceOracle_QueryAssetRates_0(ctx context.Context, marshaler runtime.Marshaler, client PriceOracleClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq QueryAssetRatesRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_PriceOracle_QueryAssetRates_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.QueryAssetRates(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_PriceOracle_QueryAssetRates_0(ctx context.Context, marshaler runtime.Marshaler, server PriceOracleServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryAssetRatesRequest - var metadata runtime.ServerMetadata - + var ( + protoReq QueryAssetRatesRequest + metadata runtime.ServerMetadata + ) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_PriceOracle_QueryAssetRates_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.QueryAssetRates(ctx, &protoReq) return msg, metadata, err - } // RegisterPriceOracleHandlerServer registers the http handlers for service PriceOracle to "mux". // UnaryRPC :call PriceOracleServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterPriceOracleHandlerFromEndpoint instead. +// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call. func RegisterPriceOracleHandlerServer(ctx context.Context, mux *runtime.ServeMux, server PriceOracleServer) error { - - mux.Handle("GET", pattern_PriceOracle_QueryAssetRates_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_PriceOracle_QueryAssetRates_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, "/priceoraclerpc.PriceOracle/QueryAssetRates", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/priceoracle/assetrates")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/priceoraclerpc.PriceOracle/QueryAssetRates", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/priceoracle/assetrates")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -93,9 +92,7 @@ func RegisterPriceOracleHandlerServer(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_PriceOracle_QueryAssetRates_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil @@ -122,7 +119,6 @@ func RegisterPriceOracleHandlerFromEndpoint(ctx context.Context, mux *runtime.Se } }() }() - return RegisterPriceOracleHandler(ctx, mux, conn) } @@ -136,16 +132,13 @@ func RegisterPriceOracleHandler(ctx context.Context, mux *runtime.ServeMux, conn // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "PriceOracleClient". // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "PriceOracleClient" // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "PriceOracleClient" to call the correct interceptors. +// "PriceOracleClient" to call the correct interceptors. This client ignores the HTTP middlewares. func RegisterPriceOracleHandlerClient(ctx context.Context, mux *runtime.ServeMux, client PriceOracleClient) error { - - mux.Handle("GET", pattern_PriceOracle_QueryAssetRates_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_PriceOracle_QueryAssetRates_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, "/priceoraclerpc.PriceOracle/QueryAssetRates", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/priceoracle/assetrates")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/priceoraclerpc.PriceOracle/QueryAssetRates", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/priceoracle/assetrates")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -156,11 +149,8 @@ func RegisterPriceOracleHandlerClient(ctx context.Context, mux *runtime.ServeMux runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_PriceOracle_QueryAssetRates_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - return nil } diff --git a/taprpc/priceoraclerpc/price_oracle_grpc.pb.go b/taprpc/priceoraclerpc/price_oracle_grpc.pb.go index 42ebd263a..95ccdc3f1 100644 --- a/taprpc/priceoraclerpc/price_oracle_grpc.pb.go +++ b/taprpc/priceoraclerpc/price_oracle_grpc.pb.go @@ -1,4 +1,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc v3.21.12 +// source: priceoraclerpc/price_oracle.proto package priceoraclerpc @@ -11,8 +15,12 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + PriceOracle_QueryAssetRates_FullMethodName = "/priceoraclerpc.PriceOracle/QueryAssetRates" +) // PriceOracleClient is the client API for PriceOracle service. // @@ -33,8 +41,9 @@ func NewPriceOracleClient(cc grpc.ClientConnInterface) PriceOracleClient { } func (c *priceOracleClient) QueryAssetRates(ctx context.Context, in *QueryAssetRatesRequest, opts ...grpc.CallOption) (*QueryAssetRatesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(QueryAssetRatesResponse) - err := c.cc.Invoke(ctx, "/priceoraclerpc.PriceOracle/QueryAssetRates", in, out, opts...) + err := c.cc.Invoke(ctx, PriceOracle_QueryAssetRates_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -43,7 +52,7 @@ func (c *priceOracleClient) QueryAssetRates(ctx context.Context, in *QueryAssetR // PriceOracleServer is the server API for PriceOracle service. // All implementations must embed UnimplementedPriceOracleServer -// for forward compatibility +// for forward compatibility. type PriceOracleServer interface { // QueryAssetRates retrieves the exchange rate between a tap asset and BTC for // a specified transaction type, subject asset, and payment asset. The asset @@ -52,14 +61,18 @@ type PriceOracleServer interface { mustEmbedUnimplementedPriceOracleServer() } -// UnimplementedPriceOracleServer must be embedded to have forward compatible implementations. -type UnimplementedPriceOracleServer struct { -} +// UnimplementedPriceOracleServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedPriceOracleServer struct{} func (UnimplementedPriceOracleServer) QueryAssetRates(context.Context, *QueryAssetRatesRequest) (*QueryAssetRatesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryAssetRates not implemented") } func (UnimplementedPriceOracleServer) mustEmbedUnimplementedPriceOracleServer() {} +func (UnimplementedPriceOracleServer) testEmbeddedByValue() {} // UnsafePriceOracleServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to PriceOracleServer will @@ -69,6 +82,13 @@ type UnsafePriceOracleServer interface { } func RegisterPriceOracleServer(s grpc.ServiceRegistrar, srv PriceOracleServer) { + // If the following call pancis, it indicates UnimplementedPriceOracleServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&PriceOracle_ServiceDesc, srv) } @@ -82,7 +102,7 @@ func _PriceOracle_QueryAssetRates_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/priceoraclerpc.PriceOracle/QueryAssetRates", + FullMethod: PriceOracle_QueryAssetRates_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(PriceOracleServer).QueryAssetRates(ctx, req.(*QueryAssetRatesRequest)) diff --git a/taprpc/rfqrpc/rfq.pb.go b/taprpc/rfqrpc/rfq.pb.go index 985a2a0bd..3e4dafe29 100644 --- a/taprpc/rfqrpc/rfq.pb.go +++ b/taprpc/rfqrpc/rfq.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.34.2 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: rfqrpc/rfq.proto @@ -11,6 +11,7 @@ import ( protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + unsafe "unsafe" ) const ( @@ -77,26 +78,23 @@ func (QuoteRespStatus) EnumDescriptor() ([]byte, []int) { } type AssetSpecifier struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Id: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Id: // // *AssetSpecifier_AssetId // *AssetSpecifier_AssetIdStr // *AssetSpecifier_GroupKey // *AssetSpecifier_GroupKeyStr - Id isAssetSpecifier_Id `protobuf_oneof:"id"` + Id isAssetSpecifier_Id `protobuf_oneof:"id"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetSpecifier) Reset() { *x = AssetSpecifier{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetSpecifier) String() string { @@ -107,7 +105,7 @@ func (*AssetSpecifier) ProtoMessage() {} func (x *AssetSpecifier) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -122,37 +120,45 @@ func (*AssetSpecifier) Descriptor() ([]byte, []int) { return file_rfqrpc_rfq_proto_rawDescGZIP(), []int{0} } -func (m *AssetSpecifier) GetId() isAssetSpecifier_Id { - if m != nil { - return m.Id +func (x *AssetSpecifier) GetId() isAssetSpecifier_Id { + if x != nil { + return x.Id } return nil } func (x *AssetSpecifier) GetAssetId() []byte { - if x, ok := x.GetId().(*AssetSpecifier_AssetId); ok { - return x.AssetId + if x != nil { + if x, ok := x.Id.(*AssetSpecifier_AssetId); ok { + return x.AssetId + } } return nil } func (x *AssetSpecifier) GetAssetIdStr() string { - if x, ok := x.GetId().(*AssetSpecifier_AssetIdStr); ok { - return x.AssetIdStr + if x != nil { + if x, ok := x.Id.(*AssetSpecifier_AssetIdStr); ok { + return x.AssetIdStr + } } return "" } func (x *AssetSpecifier) GetGroupKey() []byte { - if x, ok := x.GetId().(*AssetSpecifier_GroupKey); ok { - return x.GroupKey + if x != nil { + if x, ok := x.Id.(*AssetSpecifier_GroupKey); ok { + return x.GroupKey + } } return nil } func (x *AssetSpecifier) GetGroupKeyStr() string { - if x, ok := x.GetId().(*AssetSpecifier_GroupKeyStr); ok { - return x.GroupKeyStr + if x != nil { + if x, ok := x.Id.(*AssetSpecifier_GroupKeyStr); ok { + return x.GroupKeyStr + } } return "" } @@ -213,26 +219,23 @@ func (*AssetSpecifier_GroupKeyStr) isAssetSpecifier_Id() {} // many decimal places `F_c` should be divided by to obtain the fractional // representation. type FixedPoint struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The coefficient is the fractional value scaled-up as an integer. This // integer is represented as a string as it may be too large to fit in a // uint64. Coefficient string `protobuf:"bytes,1,opt,name=coefficient,proto3" json:"coefficient,omitempty"` // The scale is the component that determines how many decimal places // the coefficient should be divided by to obtain the fractional value. - Scale uint32 `protobuf:"varint,2,opt,name=scale,proto3" json:"scale,omitempty"` + Scale uint32 `protobuf:"varint,2,opt,name=scale,proto3" json:"scale,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *FixedPoint) Reset() { *x = FixedPoint{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FixedPoint) String() string { @@ -243,7 +246,7 @@ func (*FixedPoint) ProtoMessage() {} func (x *FixedPoint) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[1] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -273,10 +276,7 @@ func (x *FixedPoint) GetScale() uint32 { } type AddAssetBuyOrderRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // asset_specifier is the subject asset. AssetSpecifier *AssetSpecifier `protobuf:"bytes,1,opt,name=asset_specifier,json=assetSpecifier,proto3" json:"asset_specifier,omitempty"` // The maximum amount of the asset that the provider must be willing to @@ -295,15 +295,15 @@ type AddAssetBuyOrderRequest struct { // the RFQ negotiation to work. This flag shouldn't be set outside of test // scenarios. SkipAssetChannelCheck bool `protobuf:"varint,6,opt,name=skip_asset_channel_check,json=skipAssetChannelCheck,proto3" json:"skip_asset_channel_check,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddAssetBuyOrderRequest) Reset() { *x = AddAssetBuyOrderRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddAssetBuyOrderRequest) String() string { @@ -314,7 +314,7 @@ func (*AddAssetBuyOrderRequest) ProtoMessage() {} func (x *AddAssetBuyOrderRequest) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -372,25 +372,22 @@ func (x *AddAssetBuyOrderRequest) GetSkipAssetChannelCheck() bool { } type AddAssetBuyOrderResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Response: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Response: // // *AddAssetBuyOrderResponse_AcceptedQuote // *AddAssetBuyOrderResponse_InvalidQuote // *AddAssetBuyOrderResponse_RejectedQuote - Response isAddAssetBuyOrderResponse_Response `protobuf_oneof:"response"` + Response isAddAssetBuyOrderResponse_Response `protobuf_oneof:"response"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddAssetBuyOrderResponse) Reset() { *x = AddAssetBuyOrderResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddAssetBuyOrderResponse) String() string { @@ -401,7 +398,7 @@ func (*AddAssetBuyOrderResponse) ProtoMessage() {} func (x *AddAssetBuyOrderResponse) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[3] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -416,30 +413,36 @@ func (*AddAssetBuyOrderResponse) Descriptor() ([]byte, []int) { return file_rfqrpc_rfq_proto_rawDescGZIP(), []int{3} } -func (m *AddAssetBuyOrderResponse) GetResponse() isAddAssetBuyOrderResponse_Response { - if m != nil { - return m.Response +func (x *AddAssetBuyOrderResponse) GetResponse() isAddAssetBuyOrderResponse_Response { + if x != nil { + return x.Response } return nil } func (x *AddAssetBuyOrderResponse) GetAcceptedQuote() *PeerAcceptedBuyQuote { - if x, ok := x.GetResponse().(*AddAssetBuyOrderResponse_AcceptedQuote); ok { - return x.AcceptedQuote + if x != nil { + if x, ok := x.Response.(*AddAssetBuyOrderResponse_AcceptedQuote); ok { + return x.AcceptedQuote + } } return nil } func (x *AddAssetBuyOrderResponse) GetInvalidQuote() *InvalidQuoteResponse { - if x, ok := x.GetResponse().(*AddAssetBuyOrderResponse_InvalidQuote); ok { - return x.InvalidQuote + if x != nil { + if x, ok := x.Response.(*AddAssetBuyOrderResponse_InvalidQuote); ok { + return x.InvalidQuote + } } return nil } func (x *AddAssetBuyOrderResponse) GetRejectedQuote() *RejectedQuoteResponse { - if x, ok := x.GetResponse().(*AddAssetBuyOrderResponse_RejectedQuote); ok { - return x.RejectedQuote + if x != nil { + if x, ok := x.Response.(*AddAssetBuyOrderResponse_RejectedQuote); ok { + return x.RejectedQuote + } } return nil } @@ -473,10 +476,7 @@ func (*AddAssetBuyOrderResponse_InvalidQuote) isAddAssetBuyOrderResponse_Respons func (*AddAssetBuyOrderResponse_RejectedQuote) isAddAssetBuyOrderResponse_Response() {} type AddAssetSellOrderRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // asset_specifier is the subject asset. AssetSpecifier *AssetSpecifier `protobuf:"bytes,1,opt,name=asset_specifier,json=assetSpecifier,proto3" json:"asset_specifier,omitempty"` // The maximum msat amount that the responding peer must agree to pay @@ -495,15 +495,15 @@ type AddAssetSellOrderRequest struct { // the RFQ negotiation to work. This flag shouldn't be set outside of test // scenarios. SkipAssetChannelCheck bool `protobuf:"varint,6,opt,name=skip_asset_channel_check,json=skipAssetChannelCheck,proto3" json:"skip_asset_channel_check,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddAssetSellOrderRequest) Reset() { *x = AddAssetSellOrderRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddAssetSellOrderRequest) String() string { @@ -514,7 +514,7 @@ func (*AddAssetSellOrderRequest) ProtoMessage() {} func (x *AddAssetSellOrderRequest) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -572,25 +572,22 @@ func (x *AddAssetSellOrderRequest) GetSkipAssetChannelCheck() bool { } type AddAssetSellOrderResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Response: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Response: // // *AddAssetSellOrderResponse_AcceptedQuote // *AddAssetSellOrderResponse_InvalidQuote // *AddAssetSellOrderResponse_RejectedQuote - Response isAddAssetSellOrderResponse_Response `protobuf_oneof:"response"` + Response isAddAssetSellOrderResponse_Response `protobuf_oneof:"response"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddAssetSellOrderResponse) Reset() { *x = AddAssetSellOrderResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddAssetSellOrderResponse) String() string { @@ -601,7 +598,7 @@ func (*AddAssetSellOrderResponse) ProtoMessage() {} func (x *AddAssetSellOrderResponse) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[5] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -616,30 +613,36 @@ func (*AddAssetSellOrderResponse) Descriptor() ([]byte, []int) { return file_rfqrpc_rfq_proto_rawDescGZIP(), []int{5} } -func (m *AddAssetSellOrderResponse) GetResponse() isAddAssetSellOrderResponse_Response { - if m != nil { - return m.Response +func (x *AddAssetSellOrderResponse) GetResponse() isAddAssetSellOrderResponse_Response { + if x != nil { + return x.Response } return nil } func (x *AddAssetSellOrderResponse) GetAcceptedQuote() *PeerAcceptedSellQuote { - if x, ok := x.GetResponse().(*AddAssetSellOrderResponse_AcceptedQuote); ok { - return x.AcceptedQuote + if x != nil { + if x, ok := x.Response.(*AddAssetSellOrderResponse_AcceptedQuote); ok { + return x.AcceptedQuote + } } return nil } func (x *AddAssetSellOrderResponse) GetInvalidQuote() *InvalidQuoteResponse { - if x, ok := x.GetResponse().(*AddAssetSellOrderResponse_InvalidQuote); ok { - return x.InvalidQuote + if x != nil { + if x, ok := x.Response.(*AddAssetSellOrderResponse_InvalidQuote); ok { + return x.InvalidQuote + } } return nil } func (x *AddAssetSellOrderResponse) GetRejectedQuote() *RejectedQuoteResponse { - if x, ok := x.GetResponse().(*AddAssetSellOrderResponse_RejectedQuote); ok { - return x.RejectedQuote + if x != nil { + if x, ok := x.Response.(*AddAssetSellOrderResponse_RejectedQuote); ok { + return x.RejectedQuote + } } return nil } @@ -673,23 +676,20 @@ func (*AddAssetSellOrderResponse_InvalidQuote) isAddAssetSellOrderResponse_Respo func (*AddAssetSellOrderResponse_RejectedQuote) isAddAssetSellOrderResponse_Response() {} type AddAssetSellOfferRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // asset_specifier is the subject asset. AssetSpecifier *AssetSpecifier `protobuf:"bytes,1,opt,name=asset_specifier,json=assetSpecifier,proto3" json:"asset_specifier,omitempty"` // max_units is the maximum amount of the asset to sell. - MaxUnits uint64 `protobuf:"varint,2,opt,name=max_units,json=maxUnits,proto3" json:"max_units,omitempty"` + MaxUnits uint64 `protobuf:"varint,2,opt,name=max_units,json=maxUnits,proto3" json:"max_units,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddAssetSellOfferRequest) Reset() { *x = AddAssetSellOfferRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddAssetSellOfferRequest) String() string { @@ -700,7 +700,7 @@ func (*AddAssetSellOfferRequest) ProtoMessage() {} func (x *AddAssetSellOfferRequest) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[6] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -730,18 +730,16 @@ func (x *AddAssetSellOfferRequest) GetMaxUnits() uint64 { } type AddAssetSellOfferResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddAssetSellOfferResponse) Reset() { *x = AddAssetSellOfferResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddAssetSellOfferResponse) String() string { @@ -752,7 +750,7 @@ func (*AddAssetSellOfferResponse) ProtoMessage() {} func (x *AddAssetSellOfferResponse) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[7] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -768,23 +766,20 @@ func (*AddAssetSellOfferResponse) Descriptor() ([]byte, []int) { } type AddAssetBuyOfferRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // asset_specifier is the subject asset. AssetSpecifier *AssetSpecifier `protobuf:"bytes,1,opt,name=asset_specifier,json=assetSpecifier,proto3" json:"asset_specifier,omitempty"` // max_units is the maximum amount of the asset to buy. - MaxUnits uint64 `protobuf:"varint,2,opt,name=max_units,json=maxUnits,proto3" json:"max_units,omitempty"` + MaxUnits uint64 `protobuf:"varint,2,opt,name=max_units,json=maxUnits,proto3" json:"max_units,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddAssetBuyOfferRequest) Reset() { *x = AddAssetBuyOfferRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddAssetBuyOfferRequest) String() string { @@ -795,7 +790,7 @@ func (*AddAssetBuyOfferRequest) ProtoMessage() {} func (x *AddAssetBuyOfferRequest) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[8] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -825,18 +820,16 @@ func (x *AddAssetBuyOfferRequest) GetMaxUnits() uint64 { } type AddAssetBuyOfferResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddAssetBuyOfferResponse) Reset() { *x = AddAssetBuyOfferResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddAssetBuyOfferResponse) String() string { @@ -847,7 +840,7 @@ func (*AddAssetBuyOfferResponse) ProtoMessage() {} func (x *AddAssetBuyOfferResponse) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[9] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -863,18 +856,16 @@ func (*AddAssetBuyOfferResponse) Descriptor() ([]byte, []int) { } type QueryPeerAcceptedQuotesRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryPeerAcceptedQuotesRequest) Reset() { *x = QueryPeerAcceptedQuotesRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[10] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryPeerAcceptedQuotesRequest) String() string { @@ -885,7 +876,7 @@ func (*QueryPeerAcceptedQuotesRequest) ProtoMessage() {} func (x *QueryPeerAcceptedQuotesRequest) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[10] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -901,10 +892,7 @@ func (*QueryPeerAcceptedQuotesRequest) Descriptor() ([]byte, []int) { } type PeerAcceptedBuyQuote struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // Quote counterparty peer. Peer string `protobuf:"bytes,1,opt,name=peer,proto3" json:"peer,omitempty"` // The unique identifier of the quote request. @@ -927,15 +915,15 @@ type PeerAcceptedBuyQuote struct { // asset unit equivalent of 354 satoshis, which is the minimum amount for an // HTLC to be above the dust limit. MinTransportableUnits uint64 `protobuf:"varint,7,opt,name=min_transportable_units,json=minTransportableUnits,proto3" json:"min_transportable_units,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PeerAcceptedBuyQuote) Reset() { *x = PeerAcceptedBuyQuote{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PeerAcceptedBuyQuote) String() string { @@ -946,7 +934,7 @@ func (*PeerAcceptedBuyQuote) ProtoMessage() {} func (x *PeerAcceptedBuyQuote) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[11] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1011,10 +999,7 @@ func (x *PeerAcceptedBuyQuote) GetMinTransportableUnits() uint64 { } type PeerAcceptedSellQuote struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // Quote counterparty peer. Peer string `protobuf:"bytes,1,opt,name=peer,proto3" json:"peer,omitempty"` // The unique identifier of the quote request. @@ -1035,15 +1020,15 @@ type PeerAcceptedSellQuote struct { // amount for a non-dust HTLC) plus the equivalent of one asset unit in // milli-satoshis. MinTransportableMsat uint64 `protobuf:"varint,7,opt,name=min_transportable_msat,json=minTransportableMsat,proto3" json:"min_transportable_msat,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PeerAcceptedSellQuote) Reset() { *x = PeerAcceptedSellQuote{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[12] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PeerAcceptedSellQuote) String() string { @@ -1054,7 +1039,7 @@ func (*PeerAcceptedSellQuote) ProtoMessage() {} func (x *PeerAcceptedSellQuote) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[12] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1121,25 +1106,22 @@ func (x *PeerAcceptedSellQuote) GetMinTransportableMsat() uint64 { // InvalidQuoteResponse is a message that is returned when a quote response is // invalid or insufficient. type InvalidQuoteResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // status is the status of the quote response. Status QuoteRespStatus `protobuf:"varint,1,opt,name=status,proto3,enum=rfqrpc.QuoteRespStatus" json:"status,omitempty"` // peer is the quote counterparty peer. Peer string `protobuf:"bytes,2,opt,name=peer,proto3" json:"peer,omitempty"` // id is the unique identifier of the quote request. - Id []byte `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"` + Id []byte `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *InvalidQuoteResponse) Reset() { *x = InvalidQuoteResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[13] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *InvalidQuoteResponse) String() string { @@ -1150,7 +1132,7 @@ func (*InvalidQuoteResponse) ProtoMessage() {} func (x *InvalidQuoteResponse) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[13] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1189,10 +1171,7 @@ func (x *InvalidQuoteResponse) GetId() []byte { // RejectedQuoteResponse is a message that is returned when a quote request is // rejected by the peer. type RejectedQuoteResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // peer is the quote counterparty peer. Peer string `protobuf:"bytes,1,opt,name=peer,proto3" json:"peer,omitempty"` // id is the unique identifier of the quote request. @@ -1200,16 +1179,16 @@ type RejectedQuoteResponse struct { // error_message is a human-readable error message. ErrorMessage string `protobuf:"bytes,3,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"` // error_code is a machine-readable error code. - ErrorCode uint32 `protobuf:"varint,4,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"` + ErrorCode uint32 `protobuf:"varint,4,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *RejectedQuoteResponse) Reset() { *x = RejectedQuoteResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *RejectedQuoteResponse) String() string { @@ -1220,7 +1199,7 @@ func (*RejectedQuoteResponse) ProtoMessage() {} func (x *RejectedQuoteResponse) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[14] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1264,25 +1243,22 @@ func (x *RejectedQuoteResponse) GetErrorCode() uint32 { } type QueryPeerAcceptedQuotesResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // buy_quotes is a list of asset buy quotes which were requested by our // node and have been accepted by our peers. BuyQuotes []*PeerAcceptedBuyQuote `protobuf:"bytes,1,rep,name=buy_quotes,json=buyQuotes,proto3" json:"buy_quotes,omitempty"` // sell_quotes is a list of asset sell quotes which were requested by our // node and have been accepted by our peers. - SellQuotes []*PeerAcceptedSellQuote `protobuf:"bytes,2,rep,name=sell_quotes,json=sellQuotes,proto3" json:"sell_quotes,omitempty"` + SellQuotes []*PeerAcceptedSellQuote `protobuf:"bytes,2,rep,name=sell_quotes,json=sellQuotes,proto3" json:"sell_quotes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryPeerAcceptedQuotesResponse) Reset() { *x = QueryPeerAcceptedQuotesResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryPeerAcceptedQuotesResponse) String() string { @@ -1293,7 +1269,7 @@ func (*QueryPeerAcceptedQuotesResponse) ProtoMessage() {} func (x *QueryPeerAcceptedQuotesResponse) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[15] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1323,18 +1299,16 @@ func (x *QueryPeerAcceptedQuotesResponse) GetSellQuotes() []*PeerAcceptedSellQuo } type SubscribeRfqEventNtfnsRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SubscribeRfqEventNtfnsRequest) Reset() { *x = SubscribeRfqEventNtfnsRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[16] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SubscribeRfqEventNtfnsRequest) String() string { @@ -1345,7 +1319,7 @@ func (*SubscribeRfqEventNtfnsRequest) ProtoMessage() {} func (x *SubscribeRfqEventNtfnsRequest) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[16] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1361,23 +1335,20 @@ func (*SubscribeRfqEventNtfnsRequest) Descriptor() ([]byte, []int) { } type PeerAcceptedBuyQuoteEvent struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // Unix timestamp in microseconds. Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // The asset buy quote that was accepted by out peer. PeerAcceptedBuyQuote *PeerAcceptedBuyQuote `protobuf:"bytes,2,opt,name=peer_accepted_buy_quote,json=peerAcceptedBuyQuote,proto3" json:"peer_accepted_buy_quote,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PeerAcceptedBuyQuoteEvent) Reset() { *x = PeerAcceptedBuyQuoteEvent{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[17] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PeerAcceptedBuyQuoteEvent) String() string { @@ -1388,7 +1359,7 @@ func (*PeerAcceptedBuyQuoteEvent) ProtoMessage() {} func (x *PeerAcceptedBuyQuoteEvent) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[17] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1418,23 +1389,20 @@ func (x *PeerAcceptedBuyQuoteEvent) GetPeerAcceptedBuyQuote() *PeerAcceptedBuyQu } type PeerAcceptedSellQuoteEvent struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // Unix timestamp in microseconds. Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // The asset sell quote that was accepted by out peer. PeerAcceptedSellQuote *PeerAcceptedSellQuote `protobuf:"bytes,2,opt,name=peer_accepted_sell_quote,json=peerAcceptedSellQuote,proto3" json:"peer_accepted_sell_quote,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PeerAcceptedSellQuoteEvent) Reset() { *x = PeerAcceptedSellQuoteEvent{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[18] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PeerAcceptedSellQuoteEvent) String() string { @@ -1445,7 +1413,7 @@ func (*PeerAcceptedSellQuoteEvent) ProtoMessage() {} func (x *PeerAcceptedSellQuoteEvent) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[18] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1475,24 +1443,21 @@ func (x *PeerAcceptedSellQuoteEvent) GetPeerAcceptedSellQuote() *PeerAcceptedSel } type AcceptHtlcEvent struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // Unix timestamp in microseconds. Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // scid is the short channel ID of the channel over which the payment for // the quote is made. - Scid uint64 `protobuf:"varint,2,opt,name=scid,proto3" json:"scid,omitempty"` + Scid uint64 `protobuf:"varint,2,opt,name=scid,proto3" json:"scid,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AcceptHtlcEvent) Reset() { *x = AcceptHtlcEvent{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[19] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AcceptHtlcEvent) String() string { @@ -1503,7 +1468,7 @@ func (*AcceptHtlcEvent) ProtoMessage() {} func (x *AcceptHtlcEvent) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[19] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1533,25 +1498,22 @@ func (x *AcceptHtlcEvent) GetScid() uint64 { } type RfqEvent struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Event: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Event: // // *RfqEvent_PeerAcceptedBuyQuote // *RfqEvent_PeerAcceptedSellQuote // *RfqEvent_AcceptHtlc - Event isRfqEvent_Event `protobuf_oneof:"event"` + Event isRfqEvent_Event `protobuf_oneof:"event"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *RfqEvent) Reset() { *x = RfqEvent{} - if protoimpl.UnsafeEnabled { - mi := &file_rfqrpc_rfq_proto_msgTypes[20] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_rfqrpc_rfq_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *RfqEvent) String() string { @@ -1562,7 +1524,7 @@ func (*RfqEvent) ProtoMessage() {} func (x *RfqEvent) ProtoReflect() protoreflect.Message { mi := &file_rfqrpc_rfq_proto_msgTypes[20] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1577,30 +1539,36 @@ func (*RfqEvent) Descriptor() ([]byte, []int) { return file_rfqrpc_rfq_proto_rawDescGZIP(), []int{20} } -func (m *RfqEvent) GetEvent() isRfqEvent_Event { - if m != nil { - return m.Event +func (x *RfqEvent) GetEvent() isRfqEvent_Event { + if x != nil { + return x.Event } return nil } func (x *RfqEvent) GetPeerAcceptedBuyQuote() *PeerAcceptedBuyQuoteEvent { - if x, ok := x.GetEvent().(*RfqEvent_PeerAcceptedBuyQuote); ok { - return x.PeerAcceptedBuyQuote + if x != nil { + if x, ok := x.Event.(*RfqEvent_PeerAcceptedBuyQuote); ok { + return x.PeerAcceptedBuyQuote + } } return nil } func (x *RfqEvent) GetPeerAcceptedSellQuote() *PeerAcceptedSellQuoteEvent { - if x, ok := x.GetEvent().(*RfqEvent_PeerAcceptedSellQuote); ok { - return x.PeerAcceptedSellQuote + if x != nil { + if x, ok := x.Event.(*RfqEvent_PeerAcceptedSellQuote); ok { + return x.PeerAcceptedSellQuote + } } return nil } func (x *RfqEvent) GetAcceptHtlc() *AcceptHtlcEvent { - if x, ok := x.GetEvent().(*RfqEvent_AcceptHtlc); ok { - return x.AcceptHtlc + if x != nil { + if x, ok := x.Event.(*RfqEvent_AcceptHtlc); ok { + return x.AcceptHtlc + } } return nil } @@ -1635,265 +1603,124 @@ func (*RfqEvent_AcceptHtlc) isRfqEvent_Event() {} var File_rfqrpc_rfq_proto protoreflect.FileDescriptor -var file_rfqrpc_rfq_proto_rawDesc = []byte{ - 0x0a, 0x10, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2f, 0x72, 0x66, 0x71, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x12, 0x06, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x22, 0x9c, 0x01, 0x0a, 0x0e, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, - 0x08, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, - 0x00, 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x48, 0x00, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x53, 0x74, 0x72, 0x12, 0x1d, - 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x0c, 0x48, 0x00, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x24, 0x0a, - 0x0d, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, - 0x53, 0x74, 0x72, 0x42, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x22, 0x44, 0x0a, 0x0a, 0x46, 0x69, 0x78, - 0x65, 0x64, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x65, 0x66, 0x66, - 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6f, - 0x65, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x61, - 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x73, 0x63, 0x61, 0x6c, 0x65, 0x22, - 0x9a, 0x02, 0x0a, 0x17, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, 0x4f, - 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0f, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0e, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0d, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x6d, 0x74, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x04, 0x52, 0x0b, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x61, 0x78, 0x41, 0x6d, 0x74, - 0x12, 0x16, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, - 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x20, 0x0a, 0x0c, 0x70, 0x65, 0x65, 0x72, - 0x5f, 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, - 0x70, 0x65, 0x65, 0x72, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x69, - 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x53, 0x65, 0x63, 0x6f, - 0x6e, 0x64, 0x73, 0x12, 0x37, 0x0a, 0x18, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x73, 0x6b, 0x69, 0x70, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x22, 0xfa, 0x01, 0x0a, - 0x18, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0e, 0x61, 0x63, 0x63, - 0x65, 0x70, 0x74, 0x65, 0x64, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, - 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x48, - 0x00, 0x52, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, - 0x12, 0x43, 0x0a, 0x0d, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x5f, 0x71, 0x75, 0x6f, 0x74, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, - 0x2e, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, - 0x51, 0x75, 0x6f, 0x74, 0x65, 0x12, 0x46, 0x0a, 0x0e, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65, - 0x64, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, - 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x51, - 0x75, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x0d, - 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x42, 0x0a, 0x0a, - 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x9f, 0x02, 0x0a, 0x18, 0x41, 0x64, - 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x16, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, - 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, - 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x61, 0x79, 0x6d, 0x65, - 0x6e, 0x74, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x6d, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, - 0x52, 0x0d, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x4d, 0x61, 0x78, 0x41, 0x6d, 0x74, 0x12, - 0x16, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, - 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x20, 0x0a, 0x0c, 0x70, 0x65, 0x65, 0x72, 0x5f, - 0x70, 0x75, 0x62, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, - 0x65, 0x65, 0x72, 0x50, 0x75, 0x62, 0x4b, 0x65, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x69, 0x6d, - 0x65, 0x6f, 0x75, 0x74, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x0e, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x53, 0x65, 0x63, 0x6f, 0x6e, - 0x64, 0x73, 0x12, 0x37, 0x0a, 0x18, 0x73, 0x6b, 0x69, 0x70, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x18, 0x06, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x73, 0x6b, 0x69, 0x70, 0x41, 0x73, 0x73, 0x65, 0x74, 0x43, - 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x22, 0xfc, 0x01, 0x0a, 0x19, - 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, - 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0e, 0x61, 0x63, 0x63, - 0x65, 0x70, 0x74, 0x65, 0x64, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, - 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, - 0x48, 0x00, 0x52, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x51, 0x75, 0x6f, 0x74, - 0x65, 0x12, 0x43, 0x0a, 0x0d, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x5f, 0x71, 0x75, 0x6f, - 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, - 0x63, 0x2e, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x69, 0x6e, 0x76, 0x61, 0x6c, 0x69, - 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x12, 0x46, 0x0a, 0x0e, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, - 0x65, 0x64, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, - 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, - 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, - 0x0d, 0x72, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x42, 0x0a, - 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x78, 0x0a, 0x18, 0x41, 0x64, - 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x16, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, - 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, - 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x75, - 0x6e, 0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x55, - 0x6e, 0x69, 0x74, 0x73, 0x22, 0x1b, 0x0a, 0x19, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x77, 0x0a, 0x17, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, - 0x4f, 0x66, 0x66, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3f, 0x0a, 0x0f, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0e, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x1b, 0x0a, - 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, - 0x52, 0x08, 0x6d, 0x61, 0x78, 0x55, 0x6e, 0x69, 0x74, 0x73, 0x22, 0x1a, 0x0a, 0x18, 0x41, 0x64, - 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x20, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, - 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x82, 0x02, 0x0a, 0x14, 0x50, 0x65, 0x65, - 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, 0x51, 0x75, 0x6f, 0x74, - 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x04, 0x70, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x63, 0x69, 0x64, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x04, 0x52, 0x04, 0x73, 0x63, 0x69, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x04, 0x52, 0x0e, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x61, 0x78, 0x41, 0x6d, 0x6f, - 0x75, 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x0e, 0x61, 0x73, 0x6b, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x72, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x72, 0x66, - 0x71, 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, - 0x0c, 0x61, 0x73, 0x6b, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, - 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x65, - 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x36, 0x0a, 0x17, 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x72, 0x61, - 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x73, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x15, 0x6d, 0x69, 0x6e, 0x54, 0x72, 0x61, 0x6e, 0x73, - 0x70, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x55, 0x6e, 0x69, 0x74, 0x73, 0x22, 0xfa, 0x01, - 0x0a, 0x15, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, - 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, - 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x73, - 0x63, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x73, 0x63, 0x69, 0x64, 0x12, - 0x21, 0x0a, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x61, 0x73, 0x73, 0x65, 0x74, 0x41, 0x6d, 0x6f, 0x75, - 0x6e, 0x74, 0x12, 0x38, 0x0a, 0x0e, 0x62, 0x69, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x72, 0x61, 0x74, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x72, 0x66, 0x71, - 0x72, 0x70, 0x63, 0x2e, 0x46, 0x69, 0x78, 0x65, 0x64, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x52, 0x0c, - 0x62, 0x69, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, - 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x65, 0x78, - 0x70, 0x69, 0x72, 0x79, 0x12, 0x34, 0x0a, 0x16, 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x72, 0x61, 0x6e, - 0x73, 0x70, 0x6f, 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6d, 0x73, 0x61, 0x74, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x04, 0x52, 0x14, 0x6d, 0x69, 0x6e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, - 0x72, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x73, 0x61, 0x74, 0x22, 0x6b, 0x0a, 0x14, 0x49, 0x6e, - 0x76, 0x61, 0x6c, 0x69, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0e, 0x32, 0x17, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x6f, 0x74, - 0x65, 0x52, 0x65, 0x73, 0x70, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x70, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x22, 0x7f, 0x0a, 0x15, 0x52, 0x65, 0x6a, 0x65, 0x63, - 0x74, 0x65, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x12, 0x0a, 0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, - 0x70, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, - 0x52, 0x02, 0x69, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x6d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x65, 0x72, 0x72, - 0x6f, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x72, 0x72, - 0x6f, 0x72, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x65, - 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x22, 0x9e, 0x01, 0x0a, 0x1f, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x51, 0x75, - 0x6f, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x0a, - 0x62, 0x75, 0x79, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x1c, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, - 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x09, - 0x62, 0x75, 0x79, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x73, 0x12, 0x3e, 0x0a, 0x0b, 0x73, 0x65, 0x6c, - 0x6c, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, - 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, - 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x0a, 0x73, - 0x65, 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x73, 0x22, 0x1f, 0x0a, 0x1d, 0x53, 0x75, 0x62, - 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x66, 0x71, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x74, - 0x66, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x8e, 0x01, 0x0a, 0x19, 0x50, - 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, 0x51, 0x75, - 0x6f, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, - 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, - 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x53, 0x0a, 0x17, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x61, - 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x75, 0x79, 0x5f, 0x71, 0x75, 0x6f, 0x74, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, - 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, - 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x14, 0x70, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, - 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x22, 0x92, 0x01, 0x0a, 0x1a, - 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, 0x6c, 0x6c, - 0x51, 0x75, 0x6f, 0x74, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, - 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, - 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x56, 0x0a, 0x18, 0x70, 0x65, 0x65, 0x72, - 0x5f, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x6c, 0x6c, 0x5f, 0x71, - 0x75, 0x6f, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x66, 0x71, - 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, - 0x53, 0x65, 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x15, 0x70, 0x65, 0x65, 0x72, 0x41, - 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, - 0x22, 0x43, 0x0a, 0x0f, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x48, 0x74, 0x6c, 0x63, 0x45, 0x76, - 0x65, 0x6e, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, - 0x70, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x63, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, - 0x04, 0x73, 0x63, 0x69, 0x64, 0x22, 0x8a, 0x02, 0x0a, 0x08, 0x52, 0x66, 0x71, 0x45, 0x76, 0x65, - 0x6e, 0x74, 0x12, 0x5a, 0x0a, 0x17, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x70, - 0x74, 0x65, 0x64, 0x5f, 0x62, 0x75, 0x79, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, - 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, 0x51, 0x75, 0x6f, 0x74, - 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x14, 0x70, 0x65, 0x65, 0x72, 0x41, 0x63, - 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x12, 0x5d, - 0x0a, 0x18, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x5f, - 0x73, 0x65, 0x6c, 0x6c, 0x5f, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x22, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, - 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x45, - 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x15, 0x70, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, - 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x12, 0x3a, 0x0a, - 0x0b, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x5f, 0x68, 0x74, 0x6c, 0x63, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x63, 0x63, 0x65, - 0x70, 0x74, 0x48, 0x74, 0x6c, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x0a, 0x61, - 0x63, 0x63, 0x65, 0x70, 0x74, 0x48, 0x74, 0x6c, 0x63, 0x42, 0x07, 0x0a, 0x05, 0x65, 0x76, 0x65, - 0x6e, 0x74, 0x2a, 0x5a, 0x0a, 0x0f, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x17, 0x0a, 0x13, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, - 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x52, 0x41, 0x54, 0x45, 0x53, 0x10, 0x00, 0x12, 0x12, - 0x0a, 0x0e, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x5f, 0x45, 0x58, 0x50, 0x49, 0x52, 0x59, - 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x50, 0x52, 0x49, 0x43, 0x45, 0x5f, 0x4f, 0x52, 0x41, 0x43, - 0x4c, 0x45, 0x5f, 0x51, 0x55, 0x45, 0x52, 0x59, 0x5f, 0x45, 0x52, 0x52, 0x10, 0x02, 0x32, 0xa8, - 0x04, 0x0a, 0x03, 0x52, 0x66, 0x71, 0x12, 0x55, 0x0a, 0x10, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x42, 0x75, 0x79, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x72, 0x66, 0x71, - 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, 0x4f, - 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x72, 0x66, - 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, - 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, - 0x11, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x72, 0x64, - 0x65, 0x72, 0x12, 0x20, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, - 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x11, 0x41, 0x64, 0x64, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x72, - 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x65, - 0x6c, 0x6c, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, - 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x53, 0x65, 0x6c, 0x6c, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x55, 0x0a, 0x10, 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, - 0x4f, 0x66, 0x66, 0x65, 0x72, 0x12, 0x1f, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, 0x4f, 0x66, 0x66, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x64, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x75, 0x79, 0x4f, 0x66, 0x66, 0x65, 0x72, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6a, 0x0a, 0x17, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x51, 0x75, 0x6f, - 0x74, 0x65, 0x73, 0x12, 0x26, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x51, 0x75, - 0x6f, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x72, 0x66, - 0x71, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, - 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x53, 0x0a, 0x16, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, - 0x65, 0x52, 0x66, 0x71, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x74, 0x66, 0x6e, 0x73, 0x12, 0x25, - 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, - 0x65, 0x52, 0x66, 0x71, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x4e, 0x74, 0x66, 0x6e, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x10, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x52, - 0x66, 0x71, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x01, 0x42, 0x37, 0x5a, 0x35, 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, 0x72, 0x66, 0x71, 0x72, - 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, -} +const file_rfqrpc_rfq_proto_rawDesc = "" + + "\n" + + "\x10rfqrpc/rfq.proto\x12\x06rfqrpc\"\x9c\x01\n" + + "\x0eAssetSpecifier\x12\x1b\n" + + "\basset_id\x18\x01 \x01(\fH\x00R\aassetId\x12\"\n" + + "\fasset_id_str\x18\x02 \x01(\tH\x00R\n" + + "assetIdStr\x12\x1d\n" + + "\tgroup_key\x18\x03 \x01(\fH\x00R\bgroupKey\x12$\n" + + "\rgroup_key_str\x18\x04 \x01(\tH\x00R\vgroupKeyStrB\x04\n" + + "\x02id\"D\n" + + "\n" + + "FixedPoint\x12 \n" + + "\vcoefficient\x18\x01 \x01(\tR\vcoefficient\x12\x14\n" + + "\x05scale\x18\x02 \x01(\rR\x05scale\"\x9a\x02\n" + + "\x17AddAssetBuyOrderRequest\x12?\n" + + "\x0fasset_specifier\x18\x01 \x01(\v2\x16.rfqrpc.AssetSpecifierR\x0eassetSpecifier\x12\"\n" + + "\rasset_max_amt\x18\x02 \x01(\x04R\vassetMaxAmt\x12\x16\n" + + "\x06expiry\x18\x03 \x01(\x04R\x06expiry\x12 \n" + + "\fpeer_pub_key\x18\x04 \x01(\fR\n" + + "peerPubKey\x12'\n" + + "\x0ftimeout_seconds\x18\x05 \x01(\rR\x0etimeoutSeconds\x127\n" + + "\x18skip_asset_channel_check\x18\x06 \x01(\bR\x15skipAssetChannelCheck\"\xfa\x01\n" + + "\x18AddAssetBuyOrderResponse\x12E\n" + + "\x0eaccepted_quote\x18\x01 \x01(\v2\x1c.rfqrpc.PeerAcceptedBuyQuoteH\x00R\racceptedQuote\x12C\n" + + "\rinvalid_quote\x18\x02 \x01(\v2\x1c.rfqrpc.InvalidQuoteResponseH\x00R\finvalidQuote\x12F\n" + + "\x0erejected_quote\x18\x03 \x01(\v2\x1d.rfqrpc.RejectedQuoteResponseH\x00R\rrejectedQuoteB\n" + + "\n" + + "\bresponse\"\x9f\x02\n" + + "\x18AddAssetSellOrderRequest\x12?\n" + + "\x0fasset_specifier\x18\x01 \x01(\v2\x16.rfqrpc.AssetSpecifierR\x0eassetSpecifier\x12&\n" + + "\x0fpayment_max_amt\x18\x02 \x01(\x04R\rpaymentMaxAmt\x12\x16\n" + + "\x06expiry\x18\x03 \x01(\x04R\x06expiry\x12 \n" + + "\fpeer_pub_key\x18\x04 \x01(\fR\n" + + "peerPubKey\x12'\n" + + "\x0ftimeout_seconds\x18\x05 \x01(\rR\x0etimeoutSeconds\x127\n" + + "\x18skip_asset_channel_check\x18\x06 \x01(\bR\x15skipAssetChannelCheck\"\xfc\x01\n" + + "\x19AddAssetSellOrderResponse\x12F\n" + + "\x0eaccepted_quote\x18\x01 \x01(\v2\x1d.rfqrpc.PeerAcceptedSellQuoteH\x00R\racceptedQuote\x12C\n" + + "\rinvalid_quote\x18\x02 \x01(\v2\x1c.rfqrpc.InvalidQuoteResponseH\x00R\finvalidQuote\x12F\n" + + "\x0erejected_quote\x18\x03 \x01(\v2\x1d.rfqrpc.RejectedQuoteResponseH\x00R\rrejectedQuoteB\n" + + "\n" + + "\bresponse\"x\n" + + "\x18AddAssetSellOfferRequest\x12?\n" + + "\x0fasset_specifier\x18\x01 \x01(\v2\x16.rfqrpc.AssetSpecifierR\x0eassetSpecifier\x12\x1b\n" + + "\tmax_units\x18\x02 \x01(\x04R\bmaxUnits\"\x1b\n" + + "\x19AddAssetSellOfferResponse\"w\n" + + "\x17AddAssetBuyOfferRequest\x12?\n" + + "\x0fasset_specifier\x18\x01 \x01(\v2\x16.rfqrpc.AssetSpecifierR\x0eassetSpecifier\x12\x1b\n" + + "\tmax_units\x18\x02 \x01(\x04R\bmaxUnits\"\x1a\n" + + "\x18AddAssetBuyOfferResponse\" \n" + + "\x1eQueryPeerAcceptedQuotesRequest\"\x82\x02\n" + + "\x14PeerAcceptedBuyQuote\x12\x12\n" + + "\x04peer\x18\x01 \x01(\tR\x04peer\x12\x0e\n" + + "\x02id\x18\x02 \x01(\fR\x02id\x12\x12\n" + + "\x04scid\x18\x03 \x01(\x04R\x04scid\x12(\n" + + "\x10asset_max_amount\x18\x04 \x01(\x04R\x0eassetMaxAmount\x128\n" + + "\x0eask_asset_rate\x18\x05 \x01(\v2\x12.rfqrpc.FixedPointR\faskAssetRate\x12\x16\n" + + "\x06expiry\x18\x06 \x01(\x04R\x06expiry\x126\n" + + "\x17min_transportable_units\x18\a \x01(\x04R\x15minTransportableUnits\"\xfa\x01\n" + + "\x15PeerAcceptedSellQuote\x12\x12\n" + + "\x04peer\x18\x01 \x01(\tR\x04peer\x12\x0e\n" + + "\x02id\x18\x02 \x01(\fR\x02id\x12\x12\n" + + "\x04scid\x18\x03 \x01(\x04R\x04scid\x12!\n" + + "\fasset_amount\x18\x04 \x01(\x04R\vassetAmount\x128\n" + + "\x0ebid_asset_rate\x18\x05 \x01(\v2\x12.rfqrpc.FixedPointR\fbidAssetRate\x12\x16\n" + + "\x06expiry\x18\x06 \x01(\x04R\x06expiry\x124\n" + + "\x16min_transportable_msat\x18\a \x01(\x04R\x14minTransportableMsat\"k\n" + + "\x14InvalidQuoteResponse\x12/\n" + + "\x06status\x18\x01 \x01(\x0e2\x17.rfqrpc.QuoteRespStatusR\x06status\x12\x12\n" + + "\x04peer\x18\x02 \x01(\tR\x04peer\x12\x0e\n" + + "\x02id\x18\x03 \x01(\fR\x02id\"\x7f\n" + + "\x15RejectedQuoteResponse\x12\x12\n" + + "\x04peer\x18\x01 \x01(\tR\x04peer\x12\x0e\n" + + "\x02id\x18\x02 \x01(\fR\x02id\x12#\n" + + "\rerror_message\x18\x03 \x01(\tR\ferrorMessage\x12\x1d\n" + + "\n" + + "error_code\x18\x04 \x01(\rR\terrorCode\"\x9e\x01\n" + + "\x1fQueryPeerAcceptedQuotesResponse\x12;\n" + + "\n" + + "buy_quotes\x18\x01 \x03(\v2\x1c.rfqrpc.PeerAcceptedBuyQuoteR\tbuyQuotes\x12>\n" + + "\vsell_quotes\x18\x02 \x03(\v2\x1d.rfqrpc.PeerAcceptedSellQuoteR\n" + + "sellQuotes\"\x1f\n" + + "\x1dSubscribeRfqEventNtfnsRequest\"\x8e\x01\n" + + "\x19PeerAcceptedBuyQuoteEvent\x12\x1c\n" + + "\ttimestamp\x18\x01 \x01(\x04R\ttimestamp\x12S\n" + + "\x17peer_accepted_buy_quote\x18\x02 \x01(\v2\x1c.rfqrpc.PeerAcceptedBuyQuoteR\x14peerAcceptedBuyQuote\"\x92\x01\n" + + "\x1aPeerAcceptedSellQuoteEvent\x12\x1c\n" + + "\ttimestamp\x18\x01 \x01(\x04R\ttimestamp\x12V\n" + + "\x18peer_accepted_sell_quote\x18\x02 \x01(\v2\x1d.rfqrpc.PeerAcceptedSellQuoteR\x15peerAcceptedSellQuote\"C\n" + + "\x0fAcceptHtlcEvent\x12\x1c\n" + + "\ttimestamp\x18\x01 \x01(\x04R\ttimestamp\x12\x12\n" + + "\x04scid\x18\x02 \x01(\x04R\x04scid\"\x8a\x02\n" + + "\bRfqEvent\x12Z\n" + + "\x17peer_accepted_buy_quote\x18\x01 \x01(\v2!.rfqrpc.PeerAcceptedBuyQuoteEventH\x00R\x14peerAcceptedBuyQuote\x12]\n" + + "\x18peer_accepted_sell_quote\x18\x02 \x01(\v2\".rfqrpc.PeerAcceptedSellQuoteEventH\x00R\x15peerAcceptedSellQuote\x12:\n" + + "\vaccept_htlc\x18\x03 \x01(\v2\x17.rfqrpc.AcceptHtlcEventH\x00R\n" + + "acceptHtlcB\a\n" + + "\x05event*Z\n" + + "\x0fQuoteRespStatus\x12\x17\n" + + "\x13INVALID_ASSET_RATES\x10\x00\x12\x12\n" + + "\x0eINVALID_EXPIRY\x10\x01\x12\x1a\n" + + "\x16PRICE_ORACLE_QUERY_ERR\x10\x022\xa8\x04\n" + + "\x03Rfq\x12U\n" + + "\x10AddAssetBuyOrder\x12\x1f.rfqrpc.AddAssetBuyOrderRequest\x1a .rfqrpc.AddAssetBuyOrderResponse\x12X\n" + + "\x11AddAssetSellOrder\x12 .rfqrpc.AddAssetSellOrderRequest\x1a!.rfqrpc.AddAssetSellOrderResponse\x12X\n" + + "\x11AddAssetSellOffer\x12 .rfqrpc.AddAssetSellOfferRequest\x1a!.rfqrpc.AddAssetSellOfferResponse\x12U\n" + + "\x10AddAssetBuyOffer\x12\x1f.rfqrpc.AddAssetBuyOfferRequest\x1a .rfqrpc.AddAssetBuyOfferResponse\x12j\n" + + "\x17QueryPeerAcceptedQuotes\x12&.rfqrpc.QueryPeerAcceptedQuotesRequest\x1a'.rfqrpc.QueryPeerAcceptedQuotesResponse\x12S\n" + + "\x16SubscribeRfqEventNtfns\x12%.rfqrpc.SubscribeRfqEventNtfnsRequest\x1a\x10.rfqrpc.RfqEvent0\x01B7Z5github.com/lightninglabs/taproot-assets/taprpc/rfqrpcb\x06proto3" var ( file_rfqrpc_rfq_proto_rawDescOnce sync.Once - file_rfqrpc_rfq_proto_rawDescData = file_rfqrpc_rfq_proto_rawDesc + file_rfqrpc_rfq_proto_rawDescData []byte ) func file_rfqrpc_rfq_proto_rawDescGZIP() []byte { file_rfqrpc_rfq_proto_rawDescOnce.Do(func() { - file_rfqrpc_rfq_proto_rawDescData = protoimpl.X.CompressGZIP(file_rfqrpc_rfq_proto_rawDescData) + file_rfqrpc_rfq_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_rfqrpc_rfq_proto_rawDesc), len(file_rfqrpc_rfq_proto_rawDesc))) }) return file_rfqrpc_rfq_proto_rawDescData } @@ -1969,260 +1796,6 @@ func file_rfqrpc_rfq_proto_init() { if File_rfqrpc_rfq_proto != nil { return } - if !protoimpl.UnsafeEnabled { - file_rfqrpc_rfq_proto_msgTypes[0].Exporter = func(v any, i int) any { - switch v := v.(*AssetSpecifier); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[1].Exporter = func(v any, i int) any { - switch v := v.(*FixedPoint); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[2].Exporter = func(v any, i int) any { - switch v := v.(*AddAssetBuyOrderRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[3].Exporter = func(v any, i int) any { - switch v := v.(*AddAssetBuyOrderResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[4].Exporter = func(v any, i int) any { - switch v := v.(*AddAssetSellOrderRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[5].Exporter = func(v any, i int) any { - switch v := v.(*AddAssetSellOrderResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[6].Exporter = func(v any, i int) any { - switch v := v.(*AddAssetSellOfferRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[7].Exporter = func(v any, i int) any { - switch v := v.(*AddAssetSellOfferResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[8].Exporter = func(v any, i int) any { - switch v := v.(*AddAssetBuyOfferRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[9].Exporter = func(v any, i int) any { - switch v := v.(*AddAssetBuyOfferResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[10].Exporter = func(v any, i int) any { - switch v := v.(*QueryPeerAcceptedQuotesRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[11].Exporter = func(v any, i int) any { - switch v := v.(*PeerAcceptedBuyQuote); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[12].Exporter = func(v any, i int) any { - switch v := v.(*PeerAcceptedSellQuote); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[13].Exporter = func(v any, i int) any { - switch v := v.(*InvalidQuoteResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[14].Exporter = func(v any, i int) any { - switch v := v.(*RejectedQuoteResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[15].Exporter = func(v any, i int) any { - switch v := v.(*QueryPeerAcceptedQuotesResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[16].Exporter = func(v any, i int) any { - switch v := v.(*SubscribeRfqEventNtfnsRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[17].Exporter = func(v any, i int) any { - switch v := v.(*PeerAcceptedBuyQuoteEvent); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[18].Exporter = func(v any, i int) any { - switch v := v.(*PeerAcceptedSellQuoteEvent); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[19].Exporter = func(v any, i int) any { - switch v := v.(*AcceptHtlcEvent); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_rfqrpc_rfq_proto_msgTypes[20].Exporter = func(v any, i int) any { - switch v := v.(*RfqEvent); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - } file_rfqrpc_rfq_proto_msgTypes[0].OneofWrappers = []any{ (*AssetSpecifier_AssetId)(nil), (*AssetSpecifier_AssetIdStr)(nil), @@ -2248,7 +1821,7 @@ func file_rfqrpc_rfq_proto_init() { out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_rfqrpc_rfq_proto_rawDesc, + RawDescriptor: unsafe.Slice(unsafe.StringData(file_rfqrpc_rfq_proto_rawDesc), len(file_rfqrpc_rfq_proto_rawDesc)), NumEnums: 1, NumMessages: 21, NumExtensions: 0, @@ -2260,7 +1833,6 @@ func file_rfqrpc_rfq_proto_init() { MessageInfos: file_rfqrpc_rfq_proto_msgTypes, }.Build() File_rfqrpc_rfq_proto = out.File - file_rfqrpc_rfq_proto_rawDesc = nil file_rfqrpc_rfq_proto_goTypes = nil file_rfqrpc_rfq_proto_depIdxs = nil } diff --git a/taprpc/rfqrpc/rfq.pb.gw.go b/taprpc/rfqrpc/rfq.pb.gw.go index 57abbcc24..3b5c6b1f3 100644 --- a/taprpc/rfqrpc/rfq.pb.gw.go +++ b/taprpc/rfqrpc/rfq.pb.gw.go @@ -10,6 +10,7 @@ package rfqrpc import ( "context" + "errors" "io" "net/http" @@ -24,519 +25,379 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = metadata.Join +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = errors.New + _ = runtime.String + _ = utilities.NewDoubleArray + _ = metadata.Join +) func request_Rfq_AddAssetBuyOrder_0(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetBuyOrderRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetBuyOrderRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.asset_id_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.asset_id_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.asset_id_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.asset_id_str", err) } - msg, err := client.AddAssetBuyOrder(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_AddAssetBuyOrder_0(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetBuyOrderRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetBuyOrderRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.asset_id_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.asset_id_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.asset_id_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.asset_id_str", err) } - msg, err := server.AddAssetBuyOrder(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_AddAssetBuyOrder_1(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetBuyOrderRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetBuyOrderRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.group_key_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.group_key_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.group_key_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.group_key_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.group_key_str", err) } - msg, err := client.AddAssetBuyOrder(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_AddAssetBuyOrder_1(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetBuyOrderRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetBuyOrderRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.group_key_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.group_key_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.group_key_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.group_key_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.group_key_str", err) } - msg, err := server.AddAssetBuyOrder(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_AddAssetSellOrder_0(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetSellOrderRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetSellOrderRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.asset_id_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.asset_id_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.asset_id_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.asset_id_str", err) } - msg, err := client.AddAssetSellOrder(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_AddAssetSellOrder_0(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetSellOrderRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetSellOrderRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.asset_id_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.asset_id_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.asset_id_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.asset_id_str", err) } - msg, err := server.AddAssetSellOrder(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_AddAssetSellOrder_1(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetSellOrderRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetSellOrderRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.group_key_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.group_key_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.group_key_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.group_key_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.group_key_str", err) } - msg, err := client.AddAssetSellOrder(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_AddAssetSellOrder_1(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetSellOrderRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetSellOrderRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.group_key_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.group_key_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.group_key_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.group_key_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.group_key_str", err) } - msg, err := server.AddAssetSellOrder(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_AddAssetSellOffer_0(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetSellOfferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetSellOfferRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.asset_id_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.asset_id_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.asset_id_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.asset_id_str", err) } - msg, err := client.AddAssetSellOffer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_AddAssetSellOffer_0(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetSellOfferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetSellOfferRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.asset_id_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.asset_id_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.asset_id_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.asset_id_str", err) } - msg, err := server.AddAssetSellOffer(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_AddAssetSellOffer_1(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetSellOfferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetSellOfferRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.group_key_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.group_key_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.group_key_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.group_key_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.group_key_str", err) } - msg, err := client.AddAssetSellOffer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_AddAssetSellOffer_1(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetSellOfferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetSellOfferRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.group_key_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.group_key_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.group_key_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.group_key_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.group_key_str", err) } - msg, err := server.AddAssetSellOffer(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_AddAssetBuyOffer_0(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetBuyOfferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetBuyOfferRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.asset_id_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.asset_id_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.asset_id_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.asset_id_str", err) } - msg, err := client.AddAssetBuyOffer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_AddAssetBuyOffer_0(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetBuyOfferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetBuyOfferRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.asset_id_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.asset_id_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.asset_id_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.asset_id_str", err) } - msg, err := server.AddAssetBuyOffer(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_AddAssetBuyOffer_1(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetBuyOfferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetBuyOfferRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.group_key_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.group_key_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.group_key_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.group_key_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.group_key_str", err) } - msg, err := client.AddAssetBuyOffer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_AddAssetBuyOffer_1(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddAssetBuyOfferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - var ( - val string - ok bool - err error - _ = err + protoReq AddAssetBuyOfferRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_specifier.group_key_str"] + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["asset_specifier.group_key_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_specifier.group_key_str") } - err = runtime.PopulateFieldFromPath(&protoReq, "asset_specifier.group_key_str", val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_specifier.group_key_str", err) } - msg, err := server.AddAssetBuyOffer(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_QueryPeerAcceptedQuotes_0(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryPeerAcceptedQuotesRequest - var metadata runtime.ServerMetadata - + var ( + protoReq QueryPeerAcceptedQuotesRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) msg, err := client.QueryPeerAcceptedQuotes(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_Rfq_QueryPeerAcceptedQuotes_0(ctx context.Context, marshaler runtime.Marshaler, server RfqServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryPeerAcceptedQuotesRequest - var metadata runtime.ServerMetadata - + var ( + protoReq QueryPeerAcceptedQuotesRequest + metadata runtime.ServerMetadata + ) msg, err := server.QueryPeerAcceptedQuotes(ctx, &protoReq) return msg, metadata, err - } func request_Rfq_SubscribeRfqEventNtfns_0(ctx context.Context, marshaler runtime.Marshaler, client RfqClient, req *http.Request, pathParams map[string]string) (Rfq_SubscribeRfqEventNtfnsClient, runtime.ServerMetadata, error) { - var protoReq SubscribeRfqEventNtfnsRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SubscribeRfqEventNtfnsRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - stream, err := client.SubscribeRfqEventNtfns(ctx, &protoReq) if err != nil { return nil, metadata, err @@ -547,24 +408,21 @@ func request_Rfq_SubscribeRfqEventNtfns_0(ctx context.Context, marshaler runtime } metadata.HeaderMD = header return stream, metadata, nil - } // RegisterRfqHandlerServer registers the http handlers for service Rfq to "mux". // UnaryRPC :call RfqServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterRfqHandlerFromEndpoint instead. +// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call. func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server RfqServer) error { - - mux.Handle("POST", pattern_Rfq_AddAssetBuyOrder_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetBuyOrder_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, "/rfqrpc.Rfq/AddAssetBuyOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyorder/asset-id/{asset_specifier.asset_id_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetBuyOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyorder/asset-id/{asset_specifier.asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -576,20 +434,15 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetBuyOrder_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetBuyOrder_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetBuyOrder_1, 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, "/rfqrpc.Rfq/AddAssetBuyOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyorder/group-key/{asset_specifier.group_key_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetBuyOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyorder/group-key/{asset_specifier.group_key_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -601,20 +454,15 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetBuyOrder_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetSellOrder_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetSellOrder_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, "/rfqrpc.Rfq/AddAssetSellOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/sellorder/asset-id/{asset_specifier.asset_id_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetSellOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/sellorder/asset-id/{asset_specifier.asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -626,20 +474,15 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetSellOrder_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetSellOrder_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetSellOrder_1, 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, "/rfqrpc.Rfq/AddAssetSellOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/sellorder/group-key/{asset_specifier.group_key_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetSellOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/sellorder/group-key/{asset_specifier.group_key_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -651,20 +494,15 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetSellOrder_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetSellOffer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetSellOffer_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, "/rfqrpc.Rfq/AddAssetSellOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/selloffer/asset-id/{asset_specifier.asset_id_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetSellOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/selloffer/asset-id/{asset_specifier.asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -676,20 +514,15 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetSellOffer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetSellOffer_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetSellOffer_1, 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, "/rfqrpc.Rfq/AddAssetSellOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/selloffer/group-key/{asset_specifier.group_key_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetSellOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/selloffer/group-key/{asset_specifier.group_key_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -701,20 +534,15 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetSellOffer_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetBuyOffer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetBuyOffer_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, "/rfqrpc.Rfq/AddAssetBuyOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyoffer/asset-id/{asset_specifier.asset_id_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetBuyOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyoffer/asset-id/{asset_specifier.asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -726,20 +554,15 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetBuyOffer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetBuyOffer_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetBuyOffer_1, 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, "/rfqrpc.Rfq/AddAssetBuyOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyoffer/group-key/{asset_specifier.group_key_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetBuyOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyoffer/group-key/{asset_specifier.group_key_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -751,20 +574,15 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetBuyOffer_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_Rfq_QueryPeerAcceptedQuotes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_Rfq_QueryPeerAcceptedQuotes_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, "/rfqrpc.Rfq/QueryPeerAcceptedQuotes", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/quotes/peeraccepted")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/rfqrpc.Rfq/QueryPeerAcceptedQuotes", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/quotes/peeraccepted")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -776,12 +594,10 @@ func RegisterRfqHandlerServer(ctx context.Context, mux *runtime.ServeMux, server runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_QueryPeerAcceptedQuotes_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - mux.Handle("POST", pattern_Rfq_SubscribeRfqEventNtfns_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_SubscribeRfqEventNtfns_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport") _, outboundMarshaler := runtime.MarshalerForRequest(mux, req) runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) @@ -812,7 +628,6 @@ func RegisterRfqHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, } }() }() - return RegisterRfqHandler(ctx, mux, conn) } @@ -826,16 +641,13 @@ func RegisterRfqHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.C // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "RfqClient". // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "RfqClient" // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "RfqClient" to call the correct interceptors. +// "RfqClient" to call the correct interceptors. This client ignores the HTTP middlewares. func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client RfqClient) error { - - mux.Handle("POST", pattern_Rfq_AddAssetBuyOrder_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetBuyOrder_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, "/rfqrpc.Rfq/AddAssetBuyOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyorder/asset-id/{asset_specifier.asset_id_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetBuyOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyorder/asset-id/{asset_specifier.asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -846,18 +658,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetBuyOrder_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetBuyOrder_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetBuyOrder_1, 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, "/rfqrpc.Rfq/AddAssetBuyOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyorder/group-key/{asset_specifier.group_key_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetBuyOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyorder/group-key/{asset_specifier.group_key_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -868,18 +675,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetBuyOrder_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetSellOrder_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetSellOrder_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, "/rfqrpc.Rfq/AddAssetSellOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/sellorder/asset-id/{asset_specifier.asset_id_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetSellOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/sellorder/asset-id/{asset_specifier.asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -890,18 +692,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetSellOrder_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetSellOrder_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetSellOrder_1, 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, "/rfqrpc.Rfq/AddAssetSellOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/sellorder/group-key/{asset_specifier.group_key_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetSellOrder", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/sellorder/group-key/{asset_specifier.group_key_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -912,18 +709,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetSellOrder_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetSellOffer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetSellOffer_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, "/rfqrpc.Rfq/AddAssetSellOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/selloffer/asset-id/{asset_specifier.asset_id_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetSellOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/selloffer/asset-id/{asset_specifier.asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -934,18 +726,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetSellOffer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetSellOffer_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetSellOffer_1, 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, "/rfqrpc.Rfq/AddAssetSellOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/selloffer/group-key/{asset_specifier.group_key_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetSellOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/selloffer/group-key/{asset_specifier.group_key_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -956,18 +743,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetSellOffer_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetBuyOffer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetBuyOffer_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, "/rfqrpc.Rfq/AddAssetBuyOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyoffer/asset-id/{asset_specifier.asset_id_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetBuyOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyoffer/asset-id/{asset_specifier.asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -978,18 +760,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetBuyOffer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_AddAssetBuyOffer_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_AddAssetBuyOffer_1, 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, "/rfqrpc.Rfq/AddAssetBuyOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyoffer/group-key/{asset_specifier.group_key_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/AddAssetBuyOffer", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/buyoffer/group-key/{asset_specifier.group_key_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1000,18 +777,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_AddAssetBuyOffer_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_Rfq_QueryPeerAcceptedQuotes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_Rfq_QueryPeerAcceptedQuotes_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, "/rfqrpc.Rfq/QueryPeerAcceptedQuotes", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/quotes/peeraccepted")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/QueryPeerAcceptedQuotes", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/quotes/peeraccepted")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1022,18 +794,13 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_QueryPeerAcceptedQuotes_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_Rfq_SubscribeRfqEventNtfns_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_Rfq_SubscribeRfqEventNtfns_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, "/rfqrpc.Rfq/SubscribeRfqEventNtfns", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/ntfs")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/rfqrpc.Rfq/SubscribeRfqEventNtfns", runtime.WithHTTPPathPattern("/v1/taproot-assets/rfq/ntfs")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1044,54 +811,33 @@ func RegisterRfqHandlerClient(ctx context.Context, mux *runtime.ServeMux, client runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_Rfq_SubscribeRfqEventNtfns_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) - }) - return nil } var ( - pattern_Rfq_AddAssetBuyOrder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "buyorder", "asset-id", "asset_specifier.asset_id_str"}, "")) - - pattern_Rfq_AddAssetBuyOrder_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "buyorder", "group-key", "asset_specifier.group_key_str"}, "")) - - pattern_Rfq_AddAssetSellOrder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "sellorder", "asset-id", "asset_specifier.asset_id_str"}, "")) - - pattern_Rfq_AddAssetSellOrder_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "sellorder", "group-key", "asset_specifier.group_key_str"}, "")) - - pattern_Rfq_AddAssetSellOffer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "selloffer", "asset-id", "asset_specifier.asset_id_str"}, "")) - - pattern_Rfq_AddAssetSellOffer_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "selloffer", "group-key", "asset_specifier.group_key_str"}, "")) - - pattern_Rfq_AddAssetBuyOffer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "buyoffer", "asset-id", "asset_specifier.asset_id_str"}, "")) - - pattern_Rfq_AddAssetBuyOffer_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "buyoffer", "group-key", "asset_specifier.group_key_str"}, "")) - + pattern_Rfq_AddAssetBuyOrder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "buyorder", "asset-id", "asset_specifier.asset_id_str"}, "")) + pattern_Rfq_AddAssetBuyOrder_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "buyorder", "group-key", "asset_specifier.group_key_str"}, "")) + pattern_Rfq_AddAssetSellOrder_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "sellorder", "asset-id", "asset_specifier.asset_id_str"}, "")) + pattern_Rfq_AddAssetSellOrder_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "sellorder", "group-key", "asset_specifier.group_key_str"}, "")) + pattern_Rfq_AddAssetSellOffer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "selloffer", "asset-id", "asset_specifier.asset_id_str"}, "")) + pattern_Rfq_AddAssetSellOffer_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "selloffer", "group-key", "asset_specifier.group_key_str"}, "")) + pattern_Rfq_AddAssetBuyOffer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "buyoffer", "asset-id", "asset_specifier.asset_id_str"}, "")) + pattern_Rfq_AddAssetBuyOffer_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "rfq", "buyoffer", "group-key", "asset_specifier.group_key_str"}, "")) pattern_Rfq_QueryPeerAcceptedQuotes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "rfq", "quotes", "peeraccepted"}, "")) - - pattern_Rfq_SubscribeRfqEventNtfns_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "rfq", "ntfs"}, "")) + pattern_Rfq_SubscribeRfqEventNtfns_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "rfq", "ntfs"}, "")) ) var ( - forward_Rfq_AddAssetBuyOrder_0 = runtime.ForwardResponseMessage - - forward_Rfq_AddAssetBuyOrder_1 = runtime.ForwardResponseMessage - - forward_Rfq_AddAssetSellOrder_0 = runtime.ForwardResponseMessage - - forward_Rfq_AddAssetSellOrder_1 = runtime.ForwardResponseMessage - - forward_Rfq_AddAssetSellOffer_0 = runtime.ForwardResponseMessage - - forward_Rfq_AddAssetSellOffer_1 = runtime.ForwardResponseMessage - - forward_Rfq_AddAssetBuyOffer_0 = runtime.ForwardResponseMessage - - forward_Rfq_AddAssetBuyOffer_1 = runtime.ForwardResponseMessage - + forward_Rfq_AddAssetBuyOrder_0 = runtime.ForwardResponseMessage + forward_Rfq_AddAssetBuyOrder_1 = runtime.ForwardResponseMessage + forward_Rfq_AddAssetSellOrder_0 = runtime.ForwardResponseMessage + forward_Rfq_AddAssetSellOrder_1 = runtime.ForwardResponseMessage + forward_Rfq_AddAssetSellOffer_0 = runtime.ForwardResponseMessage + forward_Rfq_AddAssetSellOffer_1 = runtime.ForwardResponseMessage + forward_Rfq_AddAssetBuyOffer_0 = runtime.ForwardResponseMessage + forward_Rfq_AddAssetBuyOffer_1 = runtime.ForwardResponseMessage forward_Rfq_QueryPeerAcceptedQuotes_0 = runtime.ForwardResponseMessage - - forward_Rfq_SubscribeRfqEventNtfns_0 = runtime.ForwardResponseStream + forward_Rfq_SubscribeRfqEventNtfns_0 = runtime.ForwardResponseStream ) diff --git a/taprpc/rfqrpc/rfq_grpc.pb.go b/taprpc/rfqrpc/rfq_grpc.pb.go index f3adbe75d..15b2845e7 100644 --- a/taprpc/rfqrpc/rfq_grpc.pb.go +++ b/taprpc/rfqrpc/rfq_grpc.pb.go @@ -1,4 +1,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc v3.21.12 +// source: rfqrpc/rfq.proto package rfqrpc @@ -11,8 +15,17 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + Rfq_AddAssetBuyOrder_FullMethodName = "/rfqrpc.Rfq/AddAssetBuyOrder" + Rfq_AddAssetSellOrder_FullMethodName = "/rfqrpc.Rfq/AddAssetSellOrder" + Rfq_AddAssetSellOffer_FullMethodName = "/rfqrpc.Rfq/AddAssetSellOffer" + Rfq_AddAssetBuyOffer_FullMethodName = "/rfqrpc.Rfq/AddAssetBuyOffer" + Rfq_QueryPeerAcceptedQuotes_FullMethodName = "/rfqrpc.Rfq/QueryPeerAcceptedQuotes" + Rfq_SubscribeRfqEventNtfns_FullMethodName = "/rfqrpc.Rfq/SubscribeRfqEventNtfns" +) // RfqClient is the client API for Rfq service. // @@ -62,7 +75,7 @@ type RfqClient interface { // our node and have been accepted our peers. QueryPeerAcceptedQuotes(ctx context.Context, in *QueryPeerAcceptedQuotesRequest, opts ...grpc.CallOption) (*QueryPeerAcceptedQuotesResponse, error) // SubscribeRfqEventNtfns is used to subscribe to RFQ events. - SubscribeRfqEventNtfns(ctx context.Context, in *SubscribeRfqEventNtfnsRequest, opts ...grpc.CallOption) (Rfq_SubscribeRfqEventNtfnsClient, error) + SubscribeRfqEventNtfns(ctx context.Context, in *SubscribeRfqEventNtfnsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[RfqEvent], error) } type rfqClient struct { @@ -74,8 +87,9 @@ func NewRfqClient(cc grpc.ClientConnInterface) RfqClient { } func (c *rfqClient) AddAssetBuyOrder(ctx context.Context, in *AddAssetBuyOrderRequest, opts ...grpc.CallOption) (*AddAssetBuyOrderResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(AddAssetBuyOrderResponse) - err := c.cc.Invoke(ctx, "/rfqrpc.Rfq/AddAssetBuyOrder", in, out, opts...) + err := c.cc.Invoke(ctx, Rfq_AddAssetBuyOrder_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -83,8 +97,9 @@ func (c *rfqClient) AddAssetBuyOrder(ctx context.Context, in *AddAssetBuyOrderRe } func (c *rfqClient) AddAssetSellOrder(ctx context.Context, in *AddAssetSellOrderRequest, opts ...grpc.CallOption) (*AddAssetSellOrderResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(AddAssetSellOrderResponse) - err := c.cc.Invoke(ctx, "/rfqrpc.Rfq/AddAssetSellOrder", in, out, opts...) + err := c.cc.Invoke(ctx, Rfq_AddAssetSellOrder_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -92,8 +107,9 @@ func (c *rfqClient) AddAssetSellOrder(ctx context.Context, in *AddAssetSellOrder } func (c *rfqClient) AddAssetSellOffer(ctx context.Context, in *AddAssetSellOfferRequest, opts ...grpc.CallOption) (*AddAssetSellOfferResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(AddAssetSellOfferResponse) - err := c.cc.Invoke(ctx, "/rfqrpc.Rfq/AddAssetSellOffer", in, out, opts...) + err := c.cc.Invoke(ctx, Rfq_AddAssetSellOffer_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -101,8 +117,9 @@ func (c *rfqClient) AddAssetSellOffer(ctx context.Context, in *AddAssetSellOffer } func (c *rfqClient) AddAssetBuyOffer(ctx context.Context, in *AddAssetBuyOfferRequest, opts ...grpc.CallOption) (*AddAssetBuyOfferResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(AddAssetBuyOfferResponse) - err := c.cc.Invoke(ctx, "/rfqrpc.Rfq/AddAssetBuyOffer", in, out, opts...) + err := c.cc.Invoke(ctx, Rfq_AddAssetBuyOffer_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -110,20 +127,22 @@ func (c *rfqClient) AddAssetBuyOffer(ctx context.Context, in *AddAssetBuyOfferRe } func (c *rfqClient) QueryPeerAcceptedQuotes(ctx context.Context, in *QueryPeerAcceptedQuotesRequest, opts ...grpc.CallOption) (*QueryPeerAcceptedQuotesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(QueryPeerAcceptedQuotesResponse) - err := c.cc.Invoke(ctx, "/rfqrpc.Rfq/QueryPeerAcceptedQuotes", in, out, opts...) + err := c.cc.Invoke(ctx, Rfq_QueryPeerAcceptedQuotes_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *rfqClient) SubscribeRfqEventNtfns(ctx context.Context, in *SubscribeRfqEventNtfnsRequest, opts ...grpc.CallOption) (Rfq_SubscribeRfqEventNtfnsClient, error) { - stream, err := c.cc.NewStream(ctx, &Rfq_ServiceDesc.Streams[0], "/rfqrpc.Rfq/SubscribeRfqEventNtfns", opts...) +func (c *rfqClient) SubscribeRfqEventNtfns(ctx context.Context, in *SubscribeRfqEventNtfnsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[RfqEvent], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Rfq_ServiceDesc.Streams[0], Rfq_SubscribeRfqEventNtfns_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &rfqSubscribeRfqEventNtfnsClient{stream} + x := &grpc.GenericClientStream[SubscribeRfqEventNtfnsRequest, RfqEvent]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -133,26 +152,12 @@ func (c *rfqClient) SubscribeRfqEventNtfns(ctx context.Context, in *SubscribeRfq return x, nil } -type Rfq_SubscribeRfqEventNtfnsClient interface { - Recv() (*RfqEvent, error) - grpc.ClientStream -} - -type rfqSubscribeRfqEventNtfnsClient struct { - grpc.ClientStream -} - -func (x *rfqSubscribeRfqEventNtfnsClient) Recv() (*RfqEvent, error) { - m := new(RfqEvent) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Rfq_SubscribeRfqEventNtfnsClient = grpc.ServerStreamingClient[RfqEvent] // RfqServer is the server API for Rfq service. // All implementations must embed UnimplementedRfqServer -// for forward compatibility +// for forward compatibility. type RfqServer interface { // tapcli: `rfq buyorder` // AddAssetBuyOrder is used to add a buy order for a specific asset. If a buy @@ -198,13 +203,16 @@ type RfqServer interface { // our node and have been accepted our peers. QueryPeerAcceptedQuotes(context.Context, *QueryPeerAcceptedQuotesRequest) (*QueryPeerAcceptedQuotesResponse, error) // SubscribeRfqEventNtfns is used to subscribe to RFQ events. - SubscribeRfqEventNtfns(*SubscribeRfqEventNtfnsRequest, Rfq_SubscribeRfqEventNtfnsServer) error + SubscribeRfqEventNtfns(*SubscribeRfqEventNtfnsRequest, grpc.ServerStreamingServer[RfqEvent]) error mustEmbedUnimplementedRfqServer() } -// UnimplementedRfqServer must be embedded to have forward compatible implementations. -type UnimplementedRfqServer struct { -} +// UnimplementedRfqServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedRfqServer struct{} func (UnimplementedRfqServer) AddAssetBuyOrder(context.Context, *AddAssetBuyOrderRequest) (*AddAssetBuyOrderResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AddAssetBuyOrder not implemented") @@ -221,10 +229,11 @@ func (UnimplementedRfqServer) AddAssetBuyOffer(context.Context, *AddAssetBuyOffe func (UnimplementedRfqServer) QueryPeerAcceptedQuotes(context.Context, *QueryPeerAcceptedQuotesRequest) (*QueryPeerAcceptedQuotesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryPeerAcceptedQuotes not implemented") } -func (UnimplementedRfqServer) SubscribeRfqEventNtfns(*SubscribeRfqEventNtfnsRequest, Rfq_SubscribeRfqEventNtfnsServer) error { +func (UnimplementedRfqServer) SubscribeRfqEventNtfns(*SubscribeRfqEventNtfnsRequest, grpc.ServerStreamingServer[RfqEvent]) error { return status.Errorf(codes.Unimplemented, "method SubscribeRfqEventNtfns not implemented") } func (UnimplementedRfqServer) mustEmbedUnimplementedRfqServer() {} +func (UnimplementedRfqServer) testEmbeddedByValue() {} // UnsafeRfqServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to RfqServer will @@ -234,6 +243,13 @@ type UnsafeRfqServer interface { } func RegisterRfqServer(s grpc.ServiceRegistrar, srv RfqServer) { + // If the following call pancis, it indicates UnimplementedRfqServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&Rfq_ServiceDesc, srv) } @@ -247,7 +263,7 @@ func _Rfq_AddAssetBuyOrder_Handler(srv interface{}, ctx context.Context, dec fun } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/rfqrpc.Rfq/AddAssetBuyOrder", + FullMethod: Rfq_AddAssetBuyOrder_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RfqServer).AddAssetBuyOrder(ctx, req.(*AddAssetBuyOrderRequest)) @@ -265,7 +281,7 @@ func _Rfq_AddAssetSellOrder_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/rfqrpc.Rfq/AddAssetSellOrder", + FullMethod: Rfq_AddAssetSellOrder_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RfqServer).AddAssetSellOrder(ctx, req.(*AddAssetSellOrderRequest)) @@ -283,7 +299,7 @@ func _Rfq_AddAssetSellOffer_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/rfqrpc.Rfq/AddAssetSellOffer", + FullMethod: Rfq_AddAssetSellOffer_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RfqServer).AddAssetSellOffer(ctx, req.(*AddAssetSellOfferRequest)) @@ -301,7 +317,7 @@ func _Rfq_AddAssetBuyOffer_Handler(srv interface{}, ctx context.Context, dec fun } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/rfqrpc.Rfq/AddAssetBuyOffer", + FullMethod: Rfq_AddAssetBuyOffer_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RfqServer).AddAssetBuyOffer(ctx, req.(*AddAssetBuyOfferRequest)) @@ -319,7 +335,7 @@ func _Rfq_QueryPeerAcceptedQuotes_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/rfqrpc.Rfq/QueryPeerAcceptedQuotes", + FullMethod: Rfq_QueryPeerAcceptedQuotes_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RfqServer).QueryPeerAcceptedQuotes(ctx, req.(*QueryPeerAcceptedQuotesRequest)) @@ -332,21 +348,11 @@ func _Rfq_SubscribeRfqEventNtfns_Handler(srv interface{}, stream grpc.ServerStre if err := stream.RecvMsg(m); err != nil { return err } - return srv.(RfqServer).SubscribeRfqEventNtfns(m, &rfqSubscribeRfqEventNtfnsServer{stream}) -} - -type Rfq_SubscribeRfqEventNtfnsServer interface { - Send(*RfqEvent) error - grpc.ServerStream -} - -type rfqSubscribeRfqEventNtfnsServer struct { - grpc.ServerStream + return srv.(RfqServer).SubscribeRfqEventNtfns(m, &grpc.GenericServerStream[SubscribeRfqEventNtfnsRequest, RfqEvent]{ServerStream: stream}) } -func (x *rfqSubscribeRfqEventNtfnsServer) Send(m *RfqEvent) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Rfq_SubscribeRfqEventNtfnsServer = grpc.ServerStreamingServer[RfqEvent] // Rfq_ServiceDesc is the grpc.ServiceDesc for Rfq service. // It's only intended for direct use with grpc.RegisterService, diff --git a/taprpc/tapchannelrpc/tapchannel.pb.go b/taprpc/tapchannelrpc/tapchannel.pb.go index b2ced05c8..e2a3d6658 100644 --- a/taprpc/tapchannelrpc/tapchannel.pb.go +++ b/taprpc/tapchannelrpc/tapchannel.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.34.2 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: tapchannelrpc/tapchannel.proto @@ -15,6 +15,7 @@ import ( protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + unsafe "unsafe" ) const ( @@ -25,10 +26,7 @@ const ( ) type FundChannelRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The asset amount to fund the channel with. The BTC amount is fixed and // cannot be customized (for now). AssetAmount uint64 `protobuf:"varint,1,opt,name=asset_amount,json=assetAmount,proto3" json:"asset_amount,omitempty"` @@ -48,16 +46,16 @@ type FundChannelRequest struct { // The group key to use for the channel. This can be used instead of the // asset_id to allow assets from a fungible group to be used for the channel // funding instead of just assets from a single minting tranche (asset_id). - GroupKey []byte `protobuf:"bytes,6,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + GroupKey []byte `protobuf:"bytes,6,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *FundChannelRequest) Reset() { *x = FundChannelRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FundChannelRequest) String() string { @@ -68,7 +66,7 @@ func (*FundChannelRequest) ProtoMessage() {} func (x *FundChannelRequest) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -126,23 +124,20 @@ func (x *FundChannelRequest) GetGroupKey() []byte { } type FundChannelResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The channel funding transaction ID. Txid string `protobuf:"bytes,1,opt,name=txid,proto3" json:"txid,omitempty"` // The index of the channel funding output in the funding transaction. - OutputIndex int32 `protobuf:"varint,2,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"` + OutputIndex int32 `protobuf:"varint,2,opt,name=output_index,json=outputIndex,proto3" json:"output_index,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *FundChannelResponse) Reset() { *x = FundChannelResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *FundChannelResponse) String() string { @@ -153,7 +148,7 @@ func (*FundChannelResponse) ProtoMessage() {} func (x *FundChannelResponse) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[1] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -183,26 +178,23 @@ func (x *FundChannelResponse) GetOutputIndex() int32 { } type RouterSendPaymentData struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The string encoded asset ID to amount mapping. Instructs the router to // use these assets in the given amounts for the payment. Can be empty for // a payment of an invoice, if the RFQ ID is set instead. - AssetAmounts map[string]uint64 `protobuf:"bytes,1,rep,name=asset_amounts,json=assetAmounts,proto3" json:"asset_amounts,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + AssetAmounts map[string]uint64 `protobuf:"bytes,1,rep,name=asset_amounts,json=assetAmounts,proto3" json:"asset_amounts,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` // The RFQ ID to use for the payment. Can be empty for a direct keysend // payment that doesn't involve any conversion (and thus no RFQ). - RfqId []byte `protobuf:"bytes,2,opt,name=rfq_id,json=rfqId,proto3" json:"rfq_id,omitempty"` + RfqId []byte `protobuf:"bytes,2,opt,name=rfq_id,json=rfqId,proto3" json:"rfq_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *RouterSendPaymentData) Reset() { *x = RouterSendPaymentData{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *RouterSendPaymentData) String() string { @@ -213,7 +205,7 @@ func (*RouterSendPaymentData) ProtoMessage() {} func (x *RouterSendPaymentData) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -243,23 +235,20 @@ func (x *RouterSendPaymentData) GetRfqId() []byte { } type EncodeCustomRecordsRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Input: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Input: // // *EncodeCustomRecordsRequest_RouterSendPayment - Input isEncodeCustomRecordsRequest_Input `protobuf_oneof:"input"` + Input isEncodeCustomRecordsRequest_Input `protobuf_oneof:"input"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *EncodeCustomRecordsRequest) Reset() { *x = EncodeCustomRecordsRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *EncodeCustomRecordsRequest) String() string { @@ -270,7 +259,7 @@ func (*EncodeCustomRecordsRequest) ProtoMessage() {} func (x *EncodeCustomRecordsRequest) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[3] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -285,16 +274,18 @@ func (*EncodeCustomRecordsRequest) Descriptor() ([]byte, []int) { return file_tapchannelrpc_tapchannel_proto_rawDescGZIP(), []int{3} } -func (m *EncodeCustomRecordsRequest) GetInput() isEncodeCustomRecordsRequest_Input { - if m != nil { - return m.Input +func (x *EncodeCustomRecordsRequest) GetInput() isEncodeCustomRecordsRequest_Input { + if x != nil { + return x.Input } return nil } func (x *EncodeCustomRecordsRequest) GetRouterSendPayment() *RouterSendPaymentData { - if x, ok := x.GetInput().(*EncodeCustomRecordsRequest_RouterSendPayment); ok { - return x.RouterSendPayment + if x != nil { + if x, ok := x.Input.(*EncodeCustomRecordsRequest_RouterSendPayment); ok { + return x.RouterSendPayment + } } return nil } @@ -310,21 +301,18 @@ type EncodeCustomRecordsRequest_RouterSendPayment struct { func (*EncodeCustomRecordsRequest_RouterSendPayment) isEncodeCustomRecordsRequest_Input() {} type EncodeCustomRecordsResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The encoded custom records in TLV format. - CustomRecords map[uint64][]byte `protobuf:"bytes,1,rep,name=custom_records,json=customRecords,proto3" json:"custom_records,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + CustomRecords map[uint64][]byte `protobuf:"bytes,1,rep,name=custom_records,json=customRecords,proto3" json:"custom_records,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *EncodeCustomRecordsResponse) Reset() { *x = EncodeCustomRecordsResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *EncodeCustomRecordsResponse) String() string { @@ -335,7 +323,7 @@ func (*EncodeCustomRecordsResponse) ProtoMessage() {} func (x *EncodeCustomRecordsResponse) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -358,10 +346,7 @@ func (x *EncodeCustomRecordsResponse) GetCustomRecords() map[uint64][]byte { } type SendPaymentRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The asset ID to use for the payment. This must be set for both invoice // and keysend payments, unless RFQ negotiation was already done beforehand // and payment_request.first_hop_custom_records already contains valid RFQ @@ -398,16 +383,16 @@ type SendPaymentRequest struct { AllowOverpay bool `protobuf:"varint,6,opt,name=allow_overpay,json=allowOverpay,proto3" json:"allow_overpay,omitempty"` // The group key which dictates which assets may be used for this payment. // Mutually exclusive to asset_id. - GroupKey []byte `protobuf:"bytes,7,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + GroupKey []byte `protobuf:"bytes,7,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SendPaymentRequest) Reset() { *x = SendPaymentRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SendPaymentRequest) String() string { @@ -418,7 +403,7 @@ func (*SendPaymentRequest) ProtoMessage() {} func (x *SendPaymentRequest) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[5] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -483,24 +468,21 @@ func (x *SendPaymentRequest) GetGroupKey() []byte { } type SendPaymentResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Result: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Result: // // *SendPaymentResponse_AcceptedSellOrder // *SendPaymentResponse_PaymentResult - Result isSendPaymentResponse_Result `protobuf_oneof:"result"` + Result isSendPaymentResponse_Result `protobuf_oneof:"result"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SendPaymentResponse) Reset() { *x = SendPaymentResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SendPaymentResponse) String() string { @@ -511,7 +493,7 @@ func (*SendPaymentResponse) ProtoMessage() {} func (x *SendPaymentResponse) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[6] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -526,23 +508,27 @@ func (*SendPaymentResponse) Descriptor() ([]byte, []int) { return file_tapchannelrpc_tapchannel_proto_rawDescGZIP(), []int{6} } -func (m *SendPaymentResponse) GetResult() isSendPaymentResponse_Result { - if m != nil { - return m.Result +func (x *SendPaymentResponse) GetResult() isSendPaymentResponse_Result { + if x != nil { + return x.Result } return nil } func (x *SendPaymentResponse) GetAcceptedSellOrder() *rfqrpc.PeerAcceptedSellQuote { - if x, ok := x.GetResult().(*SendPaymentResponse_AcceptedSellOrder); ok { - return x.AcceptedSellOrder + if x != nil { + if x, ok := x.Result.(*SendPaymentResponse_AcceptedSellOrder); ok { + return x.AcceptedSellOrder + } } return nil } func (x *SendPaymentResponse) GetPaymentResult() *lnrpc.Payment { - if x, ok := x.GetResult().(*SendPaymentResponse_PaymentResult); ok { - return x.PaymentResult + if x != nil { + if x, ok := x.Result.(*SendPaymentResponse_PaymentResult); ok { + return x.PaymentResult + } } return nil } @@ -571,20 +557,17 @@ func (*SendPaymentResponse_AcceptedSellOrder) isSendPaymentResponse_Result() {} func (*SendPaymentResponse_PaymentResult) isSendPaymentResponse_Result() {} type HodlInvoice struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + PaymentHash []byte `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` unknownFields protoimpl.UnknownFields - - PaymentHash []byte `protobuf:"bytes,1,opt,name=payment_hash,json=paymentHash,proto3" json:"payment_hash,omitempty"` + sizeCache protoimpl.SizeCache } func (x *HodlInvoice) Reset() { *x = HodlInvoice{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *HodlInvoice) String() string { @@ -595,7 +578,7 @@ func (*HodlInvoice) ProtoMessage() {} func (x *HodlInvoice) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[7] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -618,10 +601,7 @@ func (x *HodlInvoice) GetPaymentHash() []byte { } type AddInvoiceRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The asset ID to use for the invoice. Mutually exclusive to group_key. AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` // The asset amount to receive. @@ -651,16 +631,16 @@ type AddInvoiceRequest struct { // The group key which dictates which assets may be accepted for this // invoice. If set, any asset that belongs to this group may be accepted to // settle this invoice. Mutually exclusive to asset_id. - GroupKey []byte `protobuf:"bytes,6,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + GroupKey []byte `protobuf:"bytes,6,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddInvoiceRequest) Reset() { *x = AddInvoiceRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddInvoiceRequest) String() string { @@ -671,7 +651,7 @@ func (*AddInvoiceRequest) ProtoMessage() {} func (x *AddInvoiceRequest) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[8] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -729,23 +709,20 @@ func (x *AddInvoiceRequest) GetGroupKey() []byte { } type AddInvoiceResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The quote for the purchase of assets that was accepted by the peer. AcceptedBuyQuote *rfqrpc.PeerAcceptedBuyQuote `protobuf:"bytes,1,opt,name=accepted_buy_quote,json=acceptedBuyQuote,proto3" json:"accepted_buy_quote,omitempty"` // The result of the invoice creation. InvoiceResult *lnrpc.AddInvoiceResponse `protobuf:"bytes,2,opt,name=invoice_result,json=invoiceResult,proto3" json:"invoice_result,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddInvoiceResponse) Reset() { *x = AddInvoiceResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddInvoiceResponse) String() string { @@ -756,7 +733,7 @@ func (*AddInvoiceResponse) ProtoMessage() {} func (x *AddInvoiceResponse) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[9] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -786,10 +763,7 @@ func (x *AddInvoiceResponse) GetInvoiceResult() *lnrpc.AddInvoiceResponse { } type AssetPayReq struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The asset ID that will be used to resolve the invoice's satoshi amount. // Mutually exclusive to group_key. AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` @@ -798,16 +772,16 @@ type AssetPayReq struct { PayReqString string `protobuf:"bytes,2,opt,name=pay_req_string,json=payReqString,proto3" json:"pay_req_string,omitempty"` // The group key that will be used to resolve the invoice's satoshi amount. // Mutually exclusive to asset_id. - GroupKey []byte `protobuf:"bytes,3,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + GroupKey []byte `protobuf:"bytes,3,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetPayReq) Reset() { *x = AssetPayReq{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[10] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetPayReq) String() string { @@ -818,7 +792,7 @@ func (*AssetPayReq) ProtoMessage() {} func (x *AssetPayReq) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[10] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -855,10 +829,7 @@ func (x *AssetPayReq) GetGroupKey() []byte { } type AssetPayReqResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The invoice amount, expressed in asset units. AssetAmount uint64 `protobuf:"varint,1,opt,name=asset_amount,json=assetAmount,proto3" json:"asset_amount,omitempty"` // The decimal display corresponding to the asset_id. @@ -871,16 +842,16 @@ type AssetPayReqResponse struct { // different minting events or genesis infos). GenesisInfo *taprpc.GenesisInfo `protobuf:"bytes,4,opt,name=genesis_info,json=genesisInfo,proto3" json:"genesis_info,omitempty"` // The normal decoded payment request. - PayReq *lnrpc.PayReq `protobuf:"bytes,5,opt,name=pay_req,json=payReq,proto3" json:"pay_req,omitempty"` + PayReq *lnrpc.PayReq `protobuf:"bytes,5,opt,name=pay_req,json=payReq,proto3" json:"pay_req,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetPayReqResponse) Reset() { *x = AssetPayReqResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetPayReqResponse) String() string { @@ -891,7 +862,7 @@ func (*AssetPayReqResponse) ProtoMessage() {} func (x *AssetPayReqResponse) ProtoReflect() protoreflect.Message { mi := &file_tapchannelrpc_tapchannel_proto_msgTypes[11] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -943,194 +914,87 @@ func (x *AssetPayReqResponse) GetPayReq() *lnrpc.PayReq { var File_tapchannelrpc_tapchannel_proto protoreflect.FileDescriptor -var file_tapchannelrpc_tapchannel_proto_rawDesc = []byte{ - 0x0a, 0x1e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2f, - 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x12, 0x0d, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x1a, - 0x10, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2f, 0x72, 0x66, 0x71, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x1a, 0x0f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x1a, 0x16, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x72, 0x70, 0x63, 0x2f, 0x72, 0x6f, - 0x75, 0x74, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x13, 0x74, 0x61, 0x70, 0x72, - 0x6f, 0x6f, 0x74, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, - 0xdf, 0x01, 0x0a, 0x12, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x41, 0x6d, 0x6f, 0x75, 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, 0x1f, 0x0a, 0x0b, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x70, 0x75, 0x62, - 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x65, 0x65, 0x72, 0x50, - 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x32, 0x0a, 0x16, 0x66, 0x65, 0x65, 0x5f, 0x72, 0x61, 0x74, - 0x65, 0x5f, 0x73, 0x61, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x5f, 0x76, 0x62, 0x79, 0x74, 0x65, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x12, 0x66, 0x65, 0x65, 0x52, 0x61, 0x74, 0x65, 0x53, 0x61, - 0x74, 0x50, 0x65, 0x72, 0x56, 0x62, 0x79, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x70, 0x75, 0x73, - 0x68, 0x5f, 0x73, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x70, 0x75, 0x73, - 0x68, 0x53, 0x61, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, - 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, - 0x79, 0x22, 0x4c, 0x0a, 0x13, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x78, 0x69, 0x64, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 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, 0x05, 0x52, 0x0b, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x22, - 0xcc, 0x01, 0x0a, 0x15, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, - 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x5b, 0x0a, 0x0d, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x36, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, - 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, - 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x41, 0x6d, 0x6f, 0x75, - 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x41, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x15, 0x0a, 0x06, 0x72, 0x66, 0x71, 0x5f, 0x69, 0x64, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x72, 0x66, 0x71, 0x49, 0x64, 0x1a, 0x3f, 0x0a, - 0x11, 0x41, 0x73, 0x73, 0x65, 0x74, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, - 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x7d, - 0x0a, 0x1a, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, - 0x63, 0x6f, 0x72, 0x64, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x56, 0x0a, 0x13, - 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x6e, 0x64, 0x5f, 0x70, 0x61, 0x79, 0x6d, - 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x61, 0x70, 0x63, - 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, - 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, - 0x00, 0x52, 0x11, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, - 0x6d, 0x65, 0x6e, 0x74, 0x42, 0x07, 0x0a, 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, 0xc5, 0x01, - 0x0a, 0x1b, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, - 0x63, 0x6f, 0x72, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x64, 0x0a, - 0x0e, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3d, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, - 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x43, 0x75, 0x73, 0x74, - 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x63, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, - 0x72, 0x64, 0x73, 0x1a, 0x40, 0x0a, 0x12, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, - 0x6f, 0x72, 0x64, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x94, 0x02, 0x0a, 0x12, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, - 0x79, 0x6d, 0x65, 0x6e, 0x74, 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, 0x21, 0x0a, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x65, - 0x65, 0x72, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x0a, 0x70, 0x65, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, 0x46, 0x0a, 0x0f, 0x70, - 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x72, 0x70, 0x63, - 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x52, 0x0e, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x15, 0x0a, 0x06, 0x72, 0x66, 0x71, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x0c, 0x52, 0x05, 0x72, 0x66, 0x71, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x61, 0x6c, - 0x6c, 0x6f, 0x77, 0x5f, 0x6f, 0x76, 0x65, 0x72, 0x70, 0x61, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0c, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x4f, 0x76, 0x65, 0x72, 0x70, 0x61, 0x79, 0x12, - 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x22, 0xa9, 0x01, 0x0a, - 0x13, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4f, 0x0a, 0x13, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, - 0x5f, 0x73, 0x65, 0x6c, 0x6c, 0x5f, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1d, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, - 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, 0x6c, 0x6c, 0x51, 0x75, 0x6f, 0x74, 0x65, - 0x48, 0x00, 0x52, 0x11, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x53, 0x65, 0x6c, 0x6c, - 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x37, 0x0a, 0x0e, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, - 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, - 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x00, 0x52, - 0x0d, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x42, 0x08, - 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x30, 0x0a, 0x0b, 0x48, 0x6f, 0x64, 0x6c, - 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x79, 0x6d, 0x65, - 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x70, - 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x22, 0x87, 0x02, 0x0a, 0x11, 0x41, - 0x64, 0x64, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 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, 0x21, 0x0a, 0x0c, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x04, 0x52, 0x0b, 0x61, 0x73, 0x73, 0x65, 0x74, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1f, - 0x0a, 0x0b, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x70, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x65, 0x65, 0x72, 0x50, 0x75, 0x62, 0x6b, 0x65, 0x79, 0x12, - 0x37, 0x0a, 0x0f, 0x69, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, - 0x2e, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x0e, 0x69, 0x6e, 0x76, 0x6f, 0x69, 0x63, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x0c, 0x68, 0x6f, 0x64, 0x6c, - 0x5f, 0x69, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, - 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x48, - 0x6f, 0x64, 0x6c, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x0b, 0x68, 0x6f, 0x64, 0x6c, - 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, - 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, - 0x70, 0x4b, 0x65, 0x79, 0x22, 0xa2, 0x01, 0x0a, 0x12, 0x41, 0x64, 0x64, 0x49, 0x6e, 0x76, 0x6f, - 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x12, 0x61, - 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x5f, 0x62, 0x75, 0x79, 0x5f, 0x71, 0x75, 0x6f, 0x74, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x72, 0x66, 0x71, 0x72, 0x70, 0x63, - 0x2e, 0x50, 0x65, 0x65, 0x72, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, 0x75, 0x79, - 0x51, 0x75, 0x6f, 0x74, 0x65, 0x52, 0x10, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x65, 0x64, 0x42, - 0x75, 0x79, 0x51, 0x75, 0x6f, 0x74, 0x65, 0x12, 0x40, 0x0a, 0x0e, 0x69, 0x6e, 0x76, 0x6f, 0x69, - 0x63, 0x65, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x19, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x49, 0x6e, 0x76, 0x6f, 0x69, - 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0d, 0x69, 0x6e, 0x76, 0x6f, - 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x6b, 0x0a, 0x0b, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 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, 0x24, 0x0a, 0x0e, 0x70, 0x61, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x5f, 0x73, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x61, 0x79, - 0x52, 0x65, 0x71, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x22, 0x8e, 0x02, 0x0a, 0x13, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x21, - 0x0a, 0x0c, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x61, 0x73, 0x73, 0x65, 0x74, 0x41, 0x6d, 0x6f, 0x75, 0x6e, - 0x74, 0x12, 0x3f, 0x0a, 0x0f, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, - 0x70, 0x6c, 0x61, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x74, 0x61, 0x70, - 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, 0x6c, - 0x61, 0x79, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, 0x6c, - 0x61, 0x79, 0x12, 0x33, 0x0a, 0x0b, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x67, 0x72, 0x6f, 0x75, - 0x70, 0x18, 0x03, 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, 0x36, 0x0a, 0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, - 0x69, 0x73, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x04, 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, 0x0b, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x12, - 0x26, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x5f, 0x72, 0x65, 0x71, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x0d, 0x2e, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x52, - 0x06, 0x70, 0x61, 0x79, 0x52, 0x65, 0x71, 0x32, 0xda, 0x03, 0x0a, 0x14, 0x54, 0x61, 0x70, 0x72, - 0x6f, 0x6f, 0x74, 0x41, 0x73, 0x73, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, - 0x12, 0x54, 0x0a, 0x0b, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, - 0x21, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, - 0x46, 0x75, 0x6e, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, - 0x70, 0x63, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6c, 0x0a, 0x13, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, - 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x12, 0x29, 0x2e, - 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x6e, - 0x63, 0x6f, 0x64, 0x65, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, - 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x43, - 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x52, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x0b, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, - 0x65, 0x6e, 0x74, 0x12, 0x21, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, - 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6d, 0x65, - 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x51, 0x0a, 0x0a, - 0x41, 0x64, 0x64, 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x20, 0x2e, 0x74, 0x61, 0x70, - 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x49, 0x6e, - 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x74, - 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, - 0x49, 0x6e, 0x76, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x53, 0x0a, 0x11, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x61, - 0x79, 0x52, 0x65, 0x71, 0x12, 0x1a, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, - 0x6c, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, - 0x1a, 0x22, 0x2e, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x72, 0x70, 0x63, - 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x61, 0x79, 0x52, 0x65, 0x71, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3e, 0x5a, 0x3c, 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, 0x74, 0x61, 0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, - 0x6c, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, -} +const file_tapchannelrpc_tapchannel_proto_rawDesc = "" + + "\n" + + "\x1etapchannelrpc/tapchannel.proto\x12\rtapchannelrpc\x1a\x10rfqrpc/rfq.proto\x1a\x0flightning.proto\x1a\x16routerrpc/router.proto\x1a\x13taprootassets.proto\"\xdf\x01\n" + + "\x12FundChannelRequest\x12!\n" + + "\fasset_amount\x18\x01 \x01(\x04R\vassetAmount\x12\x19\n" + + "\basset_id\x18\x02 \x01(\fR\aassetId\x12\x1f\n" + + "\vpeer_pubkey\x18\x03 \x01(\fR\n" + + "peerPubkey\x122\n" + + "\x16fee_rate_sat_per_vbyte\x18\x04 \x01(\rR\x12feeRateSatPerVbyte\x12\x19\n" + + "\bpush_sat\x18\x05 \x01(\x03R\apushSat\x12\x1b\n" + + "\tgroup_key\x18\x06 \x01(\fR\bgroupKey\"L\n" + + "\x13FundChannelResponse\x12\x12\n" + + "\x04txid\x18\x01 \x01(\tR\x04txid\x12!\n" + + "\foutput_index\x18\x02 \x01(\x05R\voutputIndex\"\xcc\x01\n" + + "\x15RouterSendPaymentData\x12[\n" + + "\rasset_amounts\x18\x01 \x03(\v26.tapchannelrpc.RouterSendPaymentData.AssetAmountsEntryR\fassetAmounts\x12\x15\n" + + "\x06rfq_id\x18\x02 \x01(\fR\x05rfqId\x1a?\n" + + "\x11AssetAmountsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01\"}\n" + + "\x1aEncodeCustomRecordsRequest\x12V\n" + + "\x13router_send_payment\x18\x01 \x01(\v2$.tapchannelrpc.RouterSendPaymentDataH\x00R\x11routerSendPaymentB\a\n" + + "\x05input\"\xc5\x01\n" + + "\x1bEncodeCustomRecordsResponse\x12d\n" + + "\x0ecustom_records\x18\x01 \x03(\v2=.tapchannelrpc.EncodeCustomRecordsResponse.CustomRecordsEntryR\rcustomRecords\x1a@\n" + + "\x12CustomRecordsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\x04R\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\"\x94\x02\n" + + "\x12SendPaymentRequest\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12!\n" + + "\fasset_amount\x18\x02 \x01(\x04R\vassetAmount\x12\x1f\n" + + "\vpeer_pubkey\x18\x03 \x01(\fR\n" + + "peerPubkey\x12F\n" + + "\x0fpayment_request\x18\x04 \x01(\v2\x1d.routerrpc.SendPaymentRequestR\x0epaymentRequest\x12\x15\n" + + "\x06rfq_id\x18\x05 \x01(\fR\x05rfqId\x12#\n" + + "\rallow_overpay\x18\x06 \x01(\bR\fallowOverpay\x12\x1b\n" + + "\tgroup_key\x18\a \x01(\fR\bgroupKey\"\xa9\x01\n" + + "\x13SendPaymentResponse\x12O\n" + + "\x13accepted_sell_order\x18\x01 \x01(\v2\x1d.rfqrpc.PeerAcceptedSellQuoteH\x00R\x11acceptedSellOrder\x127\n" + + "\x0epayment_result\x18\x02 \x01(\v2\x0e.lnrpc.PaymentH\x00R\rpaymentResultB\b\n" + + "\x06result\"0\n" + + "\vHodlInvoice\x12!\n" + + "\fpayment_hash\x18\x01 \x01(\fR\vpaymentHash\"\x87\x02\n" + + "\x11AddInvoiceRequest\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12!\n" + + "\fasset_amount\x18\x02 \x01(\x04R\vassetAmount\x12\x1f\n" + + "\vpeer_pubkey\x18\x03 \x01(\fR\n" + + "peerPubkey\x127\n" + + "\x0finvoice_request\x18\x04 \x01(\v2\x0e.lnrpc.InvoiceR\x0einvoiceRequest\x12=\n" + + "\fhodl_invoice\x18\x05 \x01(\v2\x1a.tapchannelrpc.HodlInvoiceR\vhodlInvoice\x12\x1b\n" + + "\tgroup_key\x18\x06 \x01(\fR\bgroupKey\"\xa2\x01\n" + + "\x12AddInvoiceResponse\x12J\n" + + "\x12accepted_buy_quote\x18\x01 \x01(\v2\x1c.rfqrpc.PeerAcceptedBuyQuoteR\x10acceptedBuyQuote\x12@\n" + + "\x0einvoice_result\x18\x02 \x01(\v2\x19.lnrpc.AddInvoiceResponseR\rinvoiceResult\"k\n" + + "\vAssetPayReq\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12$\n" + + "\x0epay_req_string\x18\x02 \x01(\tR\fpayReqString\x12\x1b\n" + + "\tgroup_key\x18\x03 \x01(\fR\bgroupKey\"\x8e\x02\n" + + "\x13AssetPayReqResponse\x12!\n" + + "\fasset_amount\x18\x01 \x01(\x04R\vassetAmount\x12?\n" + + "\x0fdecimal_display\x18\x02 \x01(\v2\x16.taprpc.DecimalDisplayR\x0edecimalDisplay\x123\n" + + "\vasset_group\x18\x03 \x01(\v2\x12.taprpc.AssetGroupR\n" + + "assetGroup\x126\n" + + "\fgenesis_info\x18\x04 \x01(\v2\x13.taprpc.GenesisInfoR\vgenesisInfo\x12&\n" + + "\apay_req\x18\x05 \x01(\v2\r.lnrpc.PayReqR\x06payReq2\xda\x03\n" + + "\x14TaprootAssetChannels\x12T\n" + + "\vFundChannel\x12!.tapchannelrpc.FundChannelRequest\x1a\".tapchannelrpc.FundChannelResponse\x12l\n" + + "\x13EncodeCustomRecords\x12).tapchannelrpc.EncodeCustomRecordsRequest\x1a*.tapchannelrpc.EncodeCustomRecordsResponse\x12V\n" + + "\vSendPayment\x12!.tapchannelrpc.SendPaymentRequest\x1a\".tapchannelrpc.SendPaymentResponse0\x01\x12Q\n" + + "\n" + + "AddInvoice\x12 .tapchannelrpc.AddInvoiceRequest\x1a!.tapchannelrpc.AddInvoiceResponse\x12S\n" + + "\x11DecodeAssetPayReq\x12\x1a.tapchannelrpc.AssetPayReq\x1a\".tapchannelrpc.AssetPayReqResponseB>Z\n" + + "\x06groups\x18\x01 \x03(\v2&.taprpc.ListGroupsResponse.GroupsEntryR\x06groups\x1aP\n" + + "\vGroupsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12+\n" + + "\x05value\x18\x02 \x01(\v2\x15.taprpc.GroupedAssetsR\x05value:\x028\x01\"\x95\x02\n" + + "\x13ListBalancesRequest\x12\x1b\n" + + "\basset_id\x18\x01 \x01(\bH\x00R\aassetId\x12\x1d\n" + + "\tgroup_key\x18\x02 \x01(\bH\x00R\bgroupKey\x12!\n" + + "\fasset_filter\x18\x03 \x01(\fR\vassetFilter\x12(\n" + + "\x10group_key_filter\x18\x04 \x01(\fR\x0egroupKeyFilter\x12%\n" + + "\x0einclude_leased\x18\x05 \x01(\bR\rincludeLeased\x12B\n" + + "\x0fscript_key_type\x18\x06 \x01(\v2\x1a.taprpc.ScriptKeyTypeQueryR\rscriptKeyTypeB\n" + + "\n" + + "\bgroup_by\"b\n" + + "\fAssetBalance\x128\n" + + "\rasset_genesis\x18\x01 \x01(\v2\x13.taprpc.GenesisInfoR\fassetGenesis\x12\x18\n" + + "\abalance\x18\x03 \x01(\x04R\abalance\"J\n" + + "\x11AssetGroupBalance\x12\x1b\n" + + "\tgroup_key\x18\x01 \x01(\fR\bgroupKey\x12\x18\n" + + "\abalance\x18\x02 \x01(\x04R\abalance\"\x90\x03\n" + + "\x14ListBalancesResponse\x12V\n" + + "\x0easset_balances\x18\x01 \x03(\v2/.taprpc.ListBalancesResponse.AssetBalancesEntryR\rassetBalances\x12f\n" + + "\x14asset_group_balances\x18\x02 \x03(\v24.taprpc.ListBalancesResponse.AssetGroupBalancesEntryR\x12assetGroupBalances\x1aV\n" + + "\x12AssetBalancesEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12*\n" + + "\x05value\x18\x02 \x01(\v2\x14.taprpc.AssetBalanceR\x05value:\x028\x01\x1a`\n" + + "\x17AssetGroupBalancesEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12/\n" + + "\x05value\x18\x02 \x01(\v2\x19.taprpc.AssetGroupBalanceR\x05value:\x028\x01\"7\n" + + "\x14ListTransfersRequest\x12\x1f\n" + + "\vanchor_txid\x18\x01 \x01(\tR\n" + + "anchorTxid\"L\n" + + "\x15ListTransfersResponse\x123\n" + + "\ttransfers\x18\x01 \x03(\v2\x15.taprpc.AssetTransferR\ttransfers\":\n" + + "\tChainHash\x12\x12\n" + + "\x04hash\x18\x01 \x01(\fR\x04hash\x12\x19\n" + + "\bhash_str\x18\x02 \x01(\tR\ahashStr\"\xd5\x03\n" + + "\rAssetTransfer\x12-\n" + + "\x12transfer_timestamp\x18\x01 \x01(\x03R\x11transferTimestamp\x12$\n" + + "\x0eanchor_tx_hash\x18\x02 \x01(\fR\fanchorTxHash\x121\n" + + "\x15anchor_tx_height_hint\x18\x03 \x01(\rR\x12anchorTxHeightHint\x12/\n" + + "\x14anchor_tx_chain_fees\x18\x04 \x01(\x03R\x11anchorTxChainFees\x12-\n" + + "\x06inputs\x18\x05 \x03(\v2\x15.taprpc.TransferInputR\x06inputs\x120\n" + + "\aoutputs\x18\x06 \x03(\v2\x16.taprpc.TransferOutputR\aoutputs\x12B\n" + + "\x14anchor_tx_block_hash\x18\a \x01(\v2\x11.taprpc.ChainHashR\x11anchorTxBlockHash\x123\n" + + "\x16anchor_tx_block_height\x18\b \x01(\rR\x13anchorTxBlockHeight\x12\x14\n" + + "\x05label\x18\t \x01(\tR\x05label\x12\x1b\n" + + "\tanchor_tx\x18\n" + + " \x01(\fR\banchorTx\"\x84\x01\n" + + "\rTransferInput\x12!\n" + + "\fanchor_point\x18\x01 \x01(\tR\vanchorPoint\x12\x19\n" + + "\basset_id\x18\x02 \x01(\fR\aassetId\x12\x1d\n" + + "\n" + + "script_key\x18\x03 \x01(\fR\tscriptKey\x12\x16\n" + + "\x06amount\x18\x04 \x01(\x04R\x06amount\"\xb2\x02\n" + + "\x14TransferOutputAnchor\x12\x1a\n" + + "\boutpoint\x18\x01 \x01(\tR\boutpoint\x12\x14\n" + + "\x05value\x18\x02 \x01(\x03R\x05value\x12!\n" + + "\finternal_key\x18\x03 \x01(\fR\vinternalKey\x12,\n" + + "\x12taproot_asset_root\x18\x04 \x01(\fR\x10taprootAssetRoot\x12\x1f\n" + + "\vmerkle_root\x18\x05 \x01(\fR\n" + + "merkleRoot\x12+\n" + + "\x11tapscript_sibling\x18\x06 \x01(\fR\x10tapscriptSibling\x12,\n" + + "\x12num_passive_assets\x18\a \x01(\rR\x10numPassiveAssets\x12\x1b\n" + + "\tpk_script\x18\b \x01(\fR\bpkScript\"\xae\x04\n" + + "\x0eTransferOutput\x124\n" + + "\x06anchor\x18\x01 \x01(\v2\x1c.taprpc.TransferOutputAnchorR\x06anchor\x12\x1d\n" + + "\n" + + "script_key\x18\x02 \x01(\fR\tscriptKey\x12-\n" + + "\x13script_key_is_local\x18\x03 \x01(\bR\x10scriptKeyIsLocal\x12\x16\n" + + "\x06amount\x18\x04 \x01(\x04R\x06amount\x12$\n" + + "\x0enew_proof_blob\x18\x05 \x01(\fR\fnewProofBlob\x123\n" + + "\x16split_commit_root_hash\x18\x06 \x01(\fR\x13splitCommitRootHash\x123\n" + + "\voutput_type\x18\a \x01(\x0e2\x12.taprpc.OutputTypeR\n" + + "outputType\x129\n" + + "\rasset_version\x18\b \x01(\x0e2\x14.taprpc.AssetVersionR\fassetVersion\x12\x1b\n" + + "\tlock_time\x18\t \x01(\x04R\blockTime\x12,\n" + + "\x12relative_lock_time\x18\n" + + " \x01(\x04R\x10relativeLockTime\x12O\n" + + "\x15proof_delivery_status\x18\v \x01(\x0e2\x1b.taprpc.ProofDeliveryStatusR\x13proofDeliveryStatus\x12\x19\n" + + "\basset_id\x18\f \x01(\fR\aassetId\"\r\n" + + "\vStopRequest\"\x0e\n" + + "\fStopResponse\"F\n" + + "\x11DebugLevelRequest\x12\x12\n" + + "\x04show\x18\x01 \x01(\bR\x04show\x12\x1d\n" + + "\n" + + "level_spec\x18\x02 \x01(\tR\tlevelSpec\"5\n" + + "\x12DebugLevelResponse\x12\x1f\n" + + "\vsub_systems\x18\x01 \x01(\tR\n" + + "subSystems\"\xe6\x03\n" + + "\x04Addr\x12\x18\n" + + "\aencoded\x18\x01 \x01(\tR\aencoded\x12\x19\n" + + "\basset_id\x18\x02 \x01(\fR\aassetId\x120\n" + + "\n" + + "asset_type\x18\x03 \x01(\x0e2\x11.taprpc.AssetTypeR\tassetType\x12\x16\n" + + "\x06amount\x18\x04 \x01(\x04R\x06amount\x12\x1b\n" + + "\tgroup_key\x18\x05 \x01(\fR\bgroupKey\x12\x1d\n" + + "\n" + + "script_key\x18\x06 \x01(\fR\tscriptKey\x12!\n" + + "\finternal_key\x18\a \x01(\fR\vinternalKey\x12+\n" + + "\x11tapscript_sibling\x18\b \x01(\fR\x10tapscriptSibling\x12,\n" + + "\x12taproot_output_key\x18\t \x01(\fR\x10taprootOutputKey\x12,\n" + + "\x12proof_courier_addr\x18\n" + + " \x01(\tR\x10proofCourierAddr\x129\n" + + "\rasset_version\x18\v \x01(\x0e2\x14.taprpc.AssetVersionR\fassetVersion\x12<\n" + + "\x0faddress_version\x18\f \x01(\x0e2\x13.taprpc.AddrVersionR\x0eaddressVersion\"\x8c\x01\n" + + "\x10QueryAddrRequest\x12#\n" + + "\rcreated_after\x18\x01 \x01(\x03R\fcreatedAfter\x12%\n" + + "\x0ecreated_before\x18\x02 \x01(\x03R\rcreatedBefore\x12\x14\n" + + "\x05limit\x18\x03 \x01(\x05R\x05limit\x12\x16\n" + + "\x06offset\x18\x04 \x01(\x05R\x06offset\"7\n" + + "\x11QueryAddrResponse\x12\"\n" + + "\x05addrs\x18\x01 \x03(\v2\f.taprpc.AddrR\x05addrs\"\xfd\x02\n" + + "\x0eNewAddrRequest\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12\x10\n" + + "\x03amt\x18\x02 \x01(\x04R\x03amt\x120\n" + + "\n" + + "script_key\x18\x03 \x01(\v2\x11.taprpc.ScriptKeyR\tscriptKey\x128\n" + + "\finternal_key\x18\x04 \x01(\v2\x15.taprpc.KeyDescriptorR\vinternalKey\x12+\n" + + "\x11tapscript_sibling\x18\x05 \x01(\fR\x10tapscriptSibling\x12,\n" + + "\x12proof_courier_addr\x18\x06 \x01(\tR\x10proofCourierAddr\x129\n" + + "\rasset_version\x18\a \x01(\x0e2\x14.taprpc.AssetVersionR\fassetVersion\x12<\n" + + "\x0faddress_version\x18\b \x01(\x0e2\x13.taprpc.AddrVersionR\x0eaddressVersion\"y\n" + + "\x12ScriptKeyTypeQuery\x12<\n" + + "\rexplicit_type\x18\x01 \x01(\x0e2\x15.taprpc.ScriptKeyTypeH\x00R\fexplicitType\x12\x1d\n" + + "\tall_types\x18\x02 \x01(\bH\x00R\ballTypesB\x06\n" + + "\x04type\"\x9e\x01\n" + + "\tScriptKey\x12\x17\n" + + "\apub_key\x18\x01 \x01(\fR\x06pubKey\x120\n" + + "\bkey_desc\x18\x02 \x01(\v2\x15.taprpc.KeyDescriptorR\akeyDesc\x12\x1b\n" + + "\ttap_tweak\x18\x03 \x01(\fR\btapTweak\x12)\n" + + "\x04type\x18\x04 \x01(\x0e2\x15.taprpc.ScriptKeyTypeR\x04type\"H\n" + + "\n" + + "KeyLocator\x12\x1d\n" + + "\n" + + "key_family\x18\x01 \x01(\x05R\tkeyFamily\x12\x1b\n" + + "\tkey_index\x18\x02 \x01(\x05R\bkeyIndex\"`\n" + + "\rKeyDescriptor\x12\"\n" + + "\rraw_key_bytes\x18\x01 \x01(\fR\vrawKeyBytes\x12+\n" + + "\akey_loc\x18\x02 \x01(\v2\x12.taprpc.KeyLocatorR\x06keyLoc\"C\n" + + "\x11TapscriptFullTree\x12.\n" + + "\n" + + "all_leaves\x18\x01 \x03(\v2\x0f.taprpc.TapLeafR\tallLeaves\"!\n" + + "\aTapLeaf\x12\x16\n" + + "\x06script\x18\x02 \x01(\fR\x06script\"S\n" + + "\tTapBranch\x12!\n" + + "\fleft_taphash\x18\x01 \x01(\fR\vleftTaphash\x12#\n" + + "\rright_taphash\x18\x02 \x01(\fR\frightTaphash\"'\n" + + "\x11DecodeAddrRequest\x12\x12\n" + + "\x04addr\x18\x01 \x01(\tR\x04addr\"V\n" + + "\tProofFile\x12$\n" + + "\x0eraw_proof_file\x18\x01 \x01(\fR\frawProofFile\x12#\n" + + "\rgenesis_point\x18\x02 \x01(\tR\fgenesisPoint\"\xf6\x04\n" + + "\fDecodedProof\x12$\n" + + "\x0eproof_at_depth\x18\x01 \x01(\rR\fproofAtDepth\x12(\n" + + "\x10number_of_proofs\x18\x02 \x01(\rR\x0enumberOfProofs\x12#\n" + + "\x05asset\x18\x03 \x01(\v2\r.taprpc.AssetR\x05asset\x122\n" + + "\vmeta_reveal\x18\x04 \x01(\v2\x11.taprpc.AssetMetaR\n" + + "metaReveal\x12&\n" + + "\x0ftx_merkle_proof\x18\x05 \x01(\fR\rtxMerkleProof\x12'\n" + + "\x0finclusion_proof\x18\x06 \x01(\fR\x0einclusionProof\x12)\n" + + "\x10exclusion_proofs\x18\a \x03(\fR\x0fexclusionProofs\x12(\n" + + "\x10split_root_proof\x18\b \x01(\fR\x0esplitRootProof\x122\n" + + "\x15num_additional_inputs\x18\t \x01(\rR\x13numAdditionalInputs\x12+\n" + + "\x11challenge_witness\x18\n" + + " \x03(\fR\x10challengeWitness\x12\x17\n" + + "\ais_burn\x18\v \x01(\bR\x06isBurn\x12<\n" + + "\x0egenesis_reveal\x18\f \x01(\v2\x15.taprpc.GenesisRevealR\rgenesisReveal\x12@\n" + + "\x10group_key_reveal\x18\r \x01(\v2\x16.taprpc.GroupKeyRevealR\x0egroupKeyReveal\x12\x1d\n" + + "\n" + + "alt_leaves\x18\x0e \x01(\fR\taltLeaves\"f\n" + + "\x13VerifyProofResponse\x12\x14\n" + + "\x05valid\x18\x01 \x01(\bR\x05valid\x129\n" + + "\rdecoded_proof\x18\x02 \x01(\v2\x14.taprpc.DecodedProofR\fdecodedProof\"\xb1\x01\n" + + "\x12DecodeProofRequest\x12\x1b\n" + + "\traw_proof\x18\x01 \x01(\fR\brawProof\x12$\n" + + "\x0eproof_at_depth\x18\x02 \x01(\rR\fproofAtDepth\x12.\n" + + "\x13with_prev_witnesses\x18\x03 \x01(\bR\x11withPrevWitnesses\x12(\n" + + "\x10with_meta_reveal\x18\x04 \x01(\bR\x0ewithMetaReveal\"P\n" + + "\x13DecodeProofResponse\x129\n" + + "\rdecoded_proof\x18\x01 \x01(\v2\x14.taprpc.DecodedProofR\fdecodedProof\"|\n" + + "\x12ExportProofRequest\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12\x1d\n" + + "\n" + + "script_key\x18\x02 \x01(\fR\tscriptKey\x12,\n" + + "\boutpoint\x18\x03 \x01(\v2\x10.taprpc.OutPointR\boutpoint\">\n" + + "\x16UnpackProofFileRequest\x12$\n" + + "\x0eraw_proof_file\x18\x01 \x01(\fR\frawProofFile\"8\n" + + "\x17UnpackProofFileResponse\x12\x1d\n" + + "\n" + + "raw_proofs\x18\x01 \x03(\fR\trawProofs\"\xd0\x02\n" + + "\tAddrEvent\x12;\n" + + "\x1acreation_time_unix_seconds\x18\x01 \x01(\x04R\x17creationTimeUnixSeconds\x12 \n" + + "\x04addr\x18\x02 \x01(\v2\f.taprpc.AddrR\x04addr\x12/\n" + + "\x06status\x18\x03 \x01(\x0e2\x17.taprpc.AddrEventStatusR\x06status\x12\x1a\n" + + "\boutpoint\x18\x04 \x01(\tR\boutpoint\x12 \n" + + "\futxo_amt_sat\x18\x05 \x01(\x04R\n" + + "utxoAmtSat\x12'\n" + + "\x0ftaproot_sibling\x18\x06 \x01(\fR\x0etaprootSibling\x12/\n" + + "\x13confirmation_height\x18\a \x01(\rR\x12confirmationHeight\x12\x1b\n" + + "\thas_proof\x18\b \x01(\bR\bhasProof\"t\n" + + "\x13AddrReceivesRequest\x12\x1f\n" + + "\vfilter_addr\x18\x01 \x01(\tR\n" + + "filterAddr\x12<\n" + + "\rfilter_status\x18\x02 \x01(\x0e2\x17.taprpc.AddrEventStatusR\ffilterStatus\"A\n" + + "\x14AddrReceivesResponse\x12)\n" + + "\x06events\x18\x01 \x03(\v2\x11.taprpc.AddrEventR\x06events\"\xa2\x01\n" + + "\x10SendAssetRequest\x12\x1b\n" + + "\ttap_addrs\x18\x01 \x03(\tR\btapAddrs\x12\x19\n" + + "\bfee_rate\x18\x02 \x01(\rR\afeeRate\x12\x14\n" + + "\x05label\x18\x03 \x01(\tR\x05label\x12@\n" + + "\x1dskip_proof_courier_ping_check\x18\x04 \x01(\bR\x19skipProofCourierPingCheck\"\x85\x01\n" + + "\x0ePrevInputAsset\x12!\n" + + "\fanchor_point\x18\x01 \x01(\tR\vanchorPoint\x12\x19\n" + + "\basset_id\x18\x02 \x01(\fR\aassetId\x12\x1d\n" + + "\n" + + "script_key\x18\x03 \x01(\fR\tscriptKey\x12\x16\n" + + "\x06amount\x18\x04 \x01(\x04R\x06amount\"F\n" + + "\x11SendAssetResponse\x121\n" + + "\btransfer\x18\x01 \x01(\v2\x15.taprpc.AssetTransferR\btransfer\"\x10\n" + + "\x0eGetInfoRequest\"\x9b\x02\n" + + "\x0fGetInfoResponse\x12\x18\n" + + "\aversion\x18\x01 \x01(\tR\aversion\x12\x1f\n" + + "\vlnd_version\x18\x02 \x01(\tR\n" + + "lndVersion\x12\x18\n" + + "\anetwork\x18\x03 \x01(\tR\anetwork\x12.\n" + + "\x13lnd_identity_pubkey\x18\x04 \x01(\tR\x11lndIdentityPubkey\x12\x1d\n" + + "\n" + + "node_alias\x18\x05 \x01(\tR\tnodeAlias\x12!\n" + + "\fblock_height\x18\x06 \x01(\rR\vblockHeight\x12\x1d\n" + + "\n" + + "block_hash\x18\a \x01(\tR\tblockHash\x12\"\n" + + "\rsync_to_chain\x18\b \x01(\bR\vsyncToChain\"\xeb\x01\n" + + "\x15FetchAssetMetaRequest\x12\x1b\n" + + "\basset_id\x18\x01 \x01(\fH\x00R\aassetId\x12\x1d\n" + + "\tmeta_hash\x18\x02 \x01(\fH\x00R\bmetaHash\x12\"\n" + + "\fasset_id_str\x18\x03 \x01(\tH\x00R\n" + + "assetIdStr\x12$\n" + + "\rmeta_hash_str\x18\x04 \x01(\tH\x00R\vmetaHashStr\x12\x1d\n" + + "\tgroup_key\x18\x05 \x01(\fH\x00R\bgroupKey\x12$\n" + + "\rgroup_key_str\x18\x06 \x01(\tH\x00R\vgroupKeyStrB\a\n" + + "\x05asset\"u\n" + + "\x16FetchAssetMetaResponse\x122\n" + + "\vasset_metas\x18\x01 \x03(\v2\x11.taprpc.AssetMetaR\n" + + "assetMetas\x12'\n" + + "\x0fdecimal_display\x18\x02 \x01(\x05R\x0edecimalDisplay\"\xc3\x01\n" + + "\x10BurnAssetRequest\x12\x1b\n" + + "\basset_id\x18\x01 \x01(\fH\x00R\aassetId\x12\"\n" + + "\fasset_id_str\x18\x02 \x01(\tH\x00R\n" + + "assetIdStr\x12$\n" + + "\x0eamount_to_burn\x18\x03 \x01(\x04R\famountToBurn\x12+\n" + + "\x11confirmation_text\x18\x04 \x01(\tR\x10confirmationText\x12\x12\n" + + "\x04note\x18\x05 \x01(\tR\x04noteB\a\n" + + "\x05asset\"\x84\x01\n" + + "\x11BurnAssetResponse\x12:\n" + + "\rburn_transfer\x18\x01 \x01(\v2\x15.taprpc.AssetTransferR\fburnTransfer\x123\n" + + "\n" + + "burn_proof\x18\x02 \x01(\v2\x14.taprpc.DecodedProofR\tburnProof\"z\n" + + "\x10ListBurnsRequest\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12*\n" + + "\x11tweaked_group_key\x18\x03 \x01(\fR\x0ftweakedGroupKey\x12\x1f\n" + + "\vanchor_txid\x18\x04 \x01(\fR\n" + + "anchorTxid\"\x9f\x01\n" + + "\tAssetBurn\x12\x12\n" + + "\x04note\x18\x01 \x01(\tR\x04note\x12\x19\n" + + "\basset_id\x18\x02 \x01(\fR\aassetId\x12*\n" + + "\x11tweaked_group_key\x18\x03 \x01(\fR\x0ftweakedGroupKey\x12\x16\n" + + "\x06amount\x18\x04 \x01(\x04R\x06amount\x12\x1f\n" + + "\vanchor_txid\x18\x05 \x01(\fR\n" + + "anchorTxid\"<\n" + + "\x11ListBurnsResponse\x12'\n" + + "\x05burns\x18\x01 \x03(\v2\x11.taprpc.AssetBurnR\x05burns\"A\n" + + "\bOutPoint\x12\x12\n" + + "\x04txid\x18\x01 \x01(\fR\x04txid\x12!\n" + + "\foutput_index\x18\x02 \x01(\rR\voutputIndex\"i\n" + + "\x1dSubscribeReceiveEventsRequest\x12\x1f\n" + + "\vfilter_addr\x18\x01 \x01(\tR\n" + + "filterAddr\x12'\n" + + "\x0fstart_timestamp\x18\x02 \x01(\x03R\x0estartTimestamp\"\xe8\x01\n" + + "\fReceiveEvent\x12\x1c\n" + + "\ttimestamp\x18\x01 \x01(\x03R\ttimestamp\x12&\n" + + "\aaddress\x18\x02 \x01(\v2\f.taprpc.AddrR\aaddress\x12\x1a\n" + + "\boutpoint\x18\x03 \x01(\tR\boutpoint\x12/\n" + + "\x06status\x18\x04 \x01(\x0e2\x17.taprpc.AddrEventStatusR\x06status\x12/\n" + + "\x13confirmation_height\x18\x05 \x01(\rR\x12confirmationHeight\x12\x14\n" + + "\x05error\x18\x06 \x01(\tR\x05error\"k\n" + + "\x1aSubscribeSendEventsRequest\x12*\n" + + "\x11filter_script_key\x18\x01 \x01(\fR\x0ffilterScriptKey\x12!\n" + + "\ffilter_label\x18\x02 \x01(\tR\vfilterLabel\"\xec\x03\n" + + "\tSendEvent\x12\x1c\n" + + "\ttimestamp\x18\x01 \x01(\x03R\ttimestamp\x12\x1d\n" + + "\n" + + "send_state\x18\x02 \x01(\tR\tsendState\x123\n" + + "\vparcel_type\x18\x03 \x01(\x0e2\x12.taprpc.ParcelTypeR\n" + + "parcelType\x12*\n" + + "\taddresses\x18\x04 \x03(\v2\f.taprpc.AddrR\taddresses\x12'\n" + + "\x0fvirtual_packets\x18\x05 \x03(\fR\x0evirtualPackets\x126\n" + + "\x17passive_virtual_packets\x18\x06 \x03(\fR\x15passiveVirtualPackets\x12H\n" + + "\x12anchor_transaction\x18\a \x01(\v2\x19.taprpc.AnchorTransactionR\x11anchorTransaction\x121\n" + + "\btransfer\x18\b \x01(\v2\x15.taprpc.AssetTransferR\btransfer\x12\x14\n" + + "\x05error\x18\t \x01(\tR\x05error\x12%\n" + + "\x0etransfer_label\x18\n" + + " \x01(\tR\rtransferLabel\x12&\n" + + "\x0fnext_send_state\x18\v \x01(\tR\rnextSendState\"\x97\x02\n" + + "\x11AnchorTransaction\x12\x1f\n" + + "\vanchor_psbt\x18\x01 \x01(\fR\n" + + "anchorPsbt\x12.\n" + + "\x13change_output_index\x18\x02 \x01(\x05R\x11changeOutputIndex\x12&\n" + + "\x0fchain_fees_sats\x18\x03 \x01(\x03R\rchainFeesSats\x122\n" + + "\x16target_fee_rate_sat_kw\x18\x04 \x01(\x05R\x12targetFeeRateSatKw\x12:\n" + + "\x10lnd_locked_utxos\x18\x05 \x03(\v2\x10.taprpc.OutPointR\x0elndLockedUtxos\x12\x19\n" + + "\bfinal_tx\x18\x06 \x01(\fR\afinalTx\"\x9e\x01\n" + + "\x17RegisterTransferRequest\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12\x1b\n" + + "\tgroup_key\x18\x02 \x01(\fR\bgroupKey\x12\x1d\n" + + "\n" + + "script_key\x18\x03 \x01(\fR\tscriptKey\x12,\n" + + "\boutpoint\x18\x04 \x01(\v2\x10.taprpc.OutPointR\boutpoint\"T\n" + + "\x18RegisterTransferResponse\x128\n" + + "\x10registered_asset\x18\x01 \x01(\v2\r.taprpc.AssetR\x0fregisteredAsset*(\n" + + "\tAssetType\x12\n" + + "\n" + + "\x06NORMAL\x10\x00\x12\x0f\n" + + "\vCOLLECTIBLE\x10\x01*9\n" + + "\rAssetMetaType\x12\x14\n" + + "\x10META_TYPE_OPAQUE\x10\x00\x12\x12\n" + + "\x0eMETA_TYPE_JSON\x10\x01*:\n" + + "\fAssetVersion\x12\x14\n" + + "\x10ASSET_VERSION_V0\x10\x00\x12\x14\n" + + "\x10ASSET_VERSION_V1\x10\x01*R\n" + + "\n" + + "OutputType\x12\x16\n" + + "\x12OUTPUT_TYPE_SIMPLE\x10\x00\x12\x1a\n" + + "\x16OUTPUT_TYPE_SPLIT_ROOT\x10\x01\"\x04\b\x02\x10\x02\"\x04\b\x03\x10\x03\"\x04\b\x04\x10\x04*\x86\x01\n" + + "\x13ProofDeliveryStatus\x12(\n" + + "$PROOF_DELIVERY_STATUS_NOT_APPLICABLE\x10\x00\x12\"\n" + + "\x1ePROOF_DELIVERY_STATUS_COMPLETE\x10\x01\x12!\n" + + "\x1dPROOF_DELIVERY_STATUS_PENDING\x10\x02*U\n" + + "\vAddrVersion\x12\x1c\n" + + "\x18ADDR_VERSION_UNSPECIFIED\x10\x00\x12\x13\n" + + "\x0fADDR_VERSION_V0\x10\x01\x12\x13\n" + + "\x0fADDR_VERSION_V1\x10\x02*\xa9\x01\n" + + "\rScriptKeyType\x12\x16\n" + + "\x12SCRIPT_KEY_UNKNOWN\x10\x00\x12\x14\n" + + "\x10SCRIPT_KEY_BIP86\x10\x01\x12#\n" + + "\x1fSCRIPT_KEY_SCRIPT_PATH_EXTERNAL\x10\x02\x12\x13\n" + + "\x0fSCRIPT_KEY_BURN\x10\x03\x12\x18\n" + + "\x14SCRIPT_KEY_TOMBSTONE\x10\x04\x12\x16\n" + + "\x12SCRIPT_KEY_CHANNEL\x10\x05*\xd0\x01\n" + + "\x0fAddrEventStatus\x12\x1d\n" + + "\x19ADDR_EVENT_STATUS_UNKNOWN\x10\x00\x12*\n" + + "&ADDR_EVENT_STATUS_TRANSACTION_DETECTED\x10\x01\x12+\n" + + "'ADDR_EVENT_STATUS_TRANSACTION_CONFIRMED\x10\x02\x12$\n" + + " ADDR_EVENT_STATUS_PROOF_RECEIVED\x10\x03\x12\x1f\n" + + "\x1bADDR_EVENT_STATUS_COMPLETED\x10\x04*\x9b\x02\n" + + "\tSendState\x12#\n" + + "\x1fSEND_STATE_VIRTUAL_INPUT_SELECT\x10\x00\x12\x1b\n" + + "\x17SEND_STATE_VIRTUAL_SIGN\x10\x01\x12\x1a\n" + + "\x16SEND_STATE_ANCHOR_SIGN\x10\x02\x12\x1d\n" + + "\x19SEND_STATE_LOG_COMMITMENT\x10\x03\x12\x18\n" + + "\x14SEND_STATE_BROADCAST\x10\x04\x12 \n" + + "\x1cSEND_STATE_WAIT_CONFIRMATION\x10\x05\x12\x1b\n" + + "\x17SEND_STATE_STORE_PROOFS\x10\x06\x12\x1e\n" + + "\x1aSEND_STATE_TRANSFER_PROOFS\x10\a\x12\x18\n" + + "\x14SEND_STATE_COMPLETED\x10\b*x\n" + + "\n" + + "ParcelType\x12\x17\n" + + "\x13PARCEL_TYPE_ADDRESS\x10\x00\x12\x1a\n" + + "\x16PARCEL_TYPE_PRE_SIGNED\x10\x01\x12\x17\n" + + "\x13PARCEL_TYPE_PENDING\x10\x02\x12\x1c\n" + + "\x18PARCEL_TYPE_PRE_ANCHORED\x10\x032\xd2\f\n" + + "\rTaprootAssets\x12A\n" + + "\n" + + "ListAssets\x12\x18.taprpc.ListAssetRequest\x1a\x19.taprpc.ListAssetResponse\x12@\n" + + "\tListUtxos\x12\x18.taprpc.ListUtxosRequest\x1a\x19.taprpc.ListUtxosResponse\x12C\n" + + "\n" + + "ListGroups\x12\x19.taprpc.ListGroupsRequest\x1a\x1a.taprpc.ListGroupsResponse\x12I\n" + + "\fListBalances\x12\x1b.taprpc.ListBalancesRequest\x1a\x1c.taprpc.ListBalancesResponse\x12L\n" + + "\rListTransfers\x12\x1c.taprpc.ListTransfersRequest\x1a\x1d.taprpc.ListTransfersResponse\x127\n" + + "\n" + + "StopDaemon\x12\x13.taprpc.StopRequest\x1a\x14.taprpc.StopResponse\x12C\n" + + "\n" + + "DebugLevel\x12\x19.taprpc.DebugLevelRequest\x1a\x1a.taprpc.DebugLevelResponse\x12A\n" + + "\n" + + "QueryAddrs\x12\x18.taprpc.QueryAddrRequest\x1a\x19.taprpc.QueryAddrResponse\x12/\n" + + "\aNewAddr\x12\x16.taprpc.NewAddrRequest\x1a\f.taprpc.Addr\x125\n" + + "\n" + + "DecodeAddr\x12\x19.taprpc.DecodeAddrRequest\x1a\f.taprpc.Addr\x12I\n" + + "\fAddrReceives\x12\x1b.taprpc.AddrReceivesRequest\x1a\x1c.taprpc.AddrReceivesResponse\x12=\n" + + "\vVerifyProof\x12\x11.taprpc.ProofFile\x1a\x1b.taprpc.VerifyProofResponse\x12F\n" + + "\vDecodeProof\x12\x1a.taprpc.DecodeProofRequest\x1a\x1b.taprpc.DecodeProofResponse\x12<\n" + + "\vExportProof\x12\x1a.taprpc.ExportProofRequest\x1a\x11.taprpc.ProofFile\x12R\n" + + "\x0fUnpackProofFile\x12\x1e.taprpc.UnpackProofFileRequest\x1a\x1f.taprpc.UnpackProofFileResponse\x12@\n" + + "\tSendAsset\x12\x18.taprpc.SendAssetRequest\x1a\x19.taprpc.SendAssetResponse\x12@\n" + + "\tBurnAsset\x12\x18.taprpc.BurnAssetRequest\x1a\x19.taprpc.BurnAssetResponse\x12@\n" + + "\tListBurns\x12\x18.taprpc.ListBurnsRequest\x1a\x19.taprpc.ListBurnsResponse\x12:\n" + + "\aGetInfo\x12\x16.taprpc.GetInfoRequest\x1a\x17.taprpc.GetInfoResponse\x12O\n" + + "\x0eFetchAssetMeta\x12\x1d.taprpc.FetchAssetMetaRequest\x1a\x1e.taprpc.FetchAssetMetaResponse\x12W\n" + + "\x16SubscribeReceiveEvents\x12%.taprpc.SubscribeReceiveEventsRequest\x1a\x14.taprpc.ReceiveEvent0\x01\x12N\n" + + "\x13SubscribeSendEvents\x12\".taprpc.SubscribeSendEventsRequest\x1a\x11.taprpc.SendEvent0\x01\x12U\n" + + "\x10RegisterTransfer\x12\x1f.taprpc.RegisterTransferRequest\x1a .taprpc.RegisterTransferResponseB0Z.github.com/lightninglabs/taproot-assets/taprpcb\x06proto3" var ( file_taprootassets_proto_rawDescOnce sync.Once - file_taprootassets_proto_rawDescData = file_taprootassets_proto_rawDesc + file_taprootassets_proto_rawDescData []byte ) func file_taprootassets_proto_rawDescGZIP() []byte { file_taprootassets_proto_rawDescOnce.Do(func() { - file_taprootassets_proto_rawDescData = protoimpl.X.CompressGZIP(file_taprootassets_proto_rawDescData) + file_taprootassets_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_taprootassets_proto_rawDesc), len(file_taprootassets_proto_rawDesc))) }) return file_taprootassets_proto_rawDescData } var file_taprootassets_proto_enumTypes = make([]protoimpl.EnumInfo, 10) -var file_taprootassets_proto_msgTypes = make([]protoimpl.MessageInfo, 85) +var file_taprootassets_proto_msgTypes = make([]protoimpl.MessageInfo, 86) var file_taprootassets_proto_goTypes = []any{ (AssetType)(0), // 0: taprpc.AssetType (AssetMetaType)(0), // 1: taprpc.AssetMetaType @@ -7899,28 +7257,29 @@ var file_taprootassets_proto_goTypes = []any{ (*GetInfoRequest)(nil), // 75: taprpc.GetInfoRequest (*GetInfoResponse)(nil), // 76: taprpc.GetInfoResponse (*FetchAssetMetaRequest)(nil), // 77: taprpc.FetchAssetMetaRequest - (*BurnAssetRequest)(nil), // 78: taprpc.BurnAssetRequest - (*BurnAssetResponse)(nil), // 79: taprpc.BurnAssetResponse - (*ListBurnsRequest)(nil), // 80: taprpc.ListBurnsRequest - (*AssetBurn)(nil), // 81: taprpc.AssetBurn - (*ListBurnsResponse)(nil), // 82: taprpc.ListBurnsResponse - (*OutPoint)(nil), // 83: taprpc.OutPoint - (*SubscribeReceiveEventsRequest)(nil), // 84: taprpc.SubscribeReceiveEventsRequest - (*ReceiveEvent)(nil), // 85: taprpc.ReceiveEvent - (*SubscribeSendEventsRequest)(nil), // 86: taprpc.SubscribeSendEventsRequest - (*SendEvent)(nil), // 87: taprpc.SendEvent - (*AnchorTransaction)(nil), // 88: taprpc.AnchorTransaction - (*RegisterTransferRequest)(nil), // 89: taprpc.RegisterTransferRequest - (*RegisterTransferResponse)(nil), // 90: taprpc.RegisterTransferResponse - nil, // 91: taprpc.ListUtxosResponse.ManagedUtxosEntry - nil, // 92: taprpc.ListGroupsResponse.GroupsEntry - nil, // 93: taprpc.ListBalancesResponse.AssetBalancesEntry - nil, // 94: taprpc.ListBalancesResponse.AssetGroupBalancesEntry + (*FetchAssetMetaResponse)(nil), // 78: taprpc.FetchAssetMetaResponse + (*BurnAssetRequest)(nil), // 79: taprpc.BurnAssetRequest + (*BurnAssetResponse)(nil), // 80: taprpc.BurnAssetResponse + (*ListBurnsRequest)(nil), // 81: taprpc.ListBurnsRequest + (*AssetBurn)(nil), // 82: taprpc.AssetBurn + (*ListBurnsResponse)(nil), // 83: taprpc.ListBurnsResponse + (*OutPoint)(nil), // 84: taprpc.OutPoint + (*SubscribeReceiveEventsRequest)(nil), // 85: taprpc.SubscribeReceiveEventsRequest + (*ReceiveEvent)(nil), // 86: taprpc.ReceiveEvent + (*SubscribeSendEventsRequest)(nil), // 87: taprpc.SubscribeSendEventsRequest + (*SendEvent)(nil), // 88: taprpc.SendEvent + (*AnchorTransaction)(nil), // 89: taprpc.AnchorTransaction + (*RegisterTransferRequest)(nil), // 90: taprpc.RegisterTransferRequest + (*RegisterTransferResponse)(nil), // 91: taprpc.RegisterTransferResponse + nil, // 92: taprpc.ListUtxosResponse.ManagedUtxosEntry + nil, // 93: taprpc.ListGroupsResponse.GroupsEntry + nil, // 94: taprpc.ListBalancesResponse.AssetBalancesEntry + nil, // 95: taprpc.ListBalancesResponse.AssetGroupBalancesEntry } var file_taprootassets_proto_depIdxs = []int32{ 1, // 0: taprpc.AssetMeta.type:type_name -> taprpc.AssetMetaType 54, // 1: taprpc.ListAssetRequest.script_key:type_name -> taprpc.ScriptKey - 83, // 2: taprpc.ListAssetRequest.anchor_outpoint:type_name -> taprpc.OutPoint + 84, // 2: taprpc.ListAssetRequest.anchor_outpoint:type_name -> taprpc.OutPoint 53, // 3: taprpc.ListAssetRequest.script_key_type:type_name -> taprpc.ScriptKeyTypeQuery 0, // 4: taprpc.GenesisInfo.asset_type:type_name -> taprpc.AssetType 56, // 5: taprpc.GroupKeyRequest.raw_key:type_name -> taprpc.KeyDescriptor @@ -7941,15 +7300,15 @@ var file_taprootassets_proto_depIdxs = []int32{ 23, // 20: taprpc.ListAssetResponse.assets:type_name -> taprpc.Asset 53, // 21: taprpc.ListUtxosRequest.script_key_type:type_name -> taprpc.ScriptKeyTypeQuery 23, // 22: taprpc.ManagedUtxo.assets:type_name -> taprpc.Asset - 91, // 23: taprpc.ListUtxosResponse.managed_utxos:type_name -> taprpc.ListUtxosResponse.ManagedUtxosEntry + 92, // 23: taprpc.ListUtxosResponse.managed_utxos:type_name -> taprpc.ListUtxosResponse.ManagedUtxosEntry 0, // 24: taprpc.AssetHumanReadable.type:type_name -> taprpc.AssetType 2, // 25: taprpc.AssetHumanReadable.version:type_name -> taprpc.AssetVersion 31, // 26: taprpc.GroupedAssets.assets:type_name -> taprpc.AssetHumanReadable - 92, // 27: taprpc.ListGroupsResponse.groups:type_name -> taprpc.ListGroupsResponse.GroupsEntry + 93, // 27: taprpc.ListGroupsResponse.groups:type_name -> taprpc.ListGroupsResponse.GroupsEntry 53, // 28: taprpc.ListBalancesRequest.script_key_type:type_name -> taprpc.ScriptKeyTypeQuery 13, // 29: taprpc.AssetBalance.asset_genesis:type_name -> taprpc.GenesisInfo - 93, // 30: taprpc.ListBalancesResponse.asset_balances:type_name -> taprpc.ListBalancesResponse.AssetBalancesEntry - 94, // 31: taprpc.ListBalancesResponse.asset_group_balances:type_name -> taprpc.ListBalancesResponse.AssetGroupBalancesEntry + 94, // 30: taprpc.ListBalancesResponse.asset_balances:type_name -> taprpc.ListBalancesResponse.AssetBalancesEntry + 95, // 31: taprpc.ListBalancesResponse.asset_group_balances:type_name -> taprpc.ListBalancesResponse.AssetGroupBalancesEntry 41, // 32: taprpc.ListTransfersResponse.transfers:type_name -> taprpc.AssetTransfer 42, // 33: taprpc.AssetTransfer.inputs:type_name -> taprpc.TransferInput 44, // 34: taprpc.AssetTransfer.outputs:type_name -> taprpc.TransferOutput @@ -7977,79 +7336,80 @@ var file_taprootassets_proto_depIdxs = []int32{ 20, // 56: taprpc.DecodedProof.group_key_reveal:type_name -> taprpc.GroupKeyReveal 62, // 57: taprpc.VerifyProofResponse.decoded_proof:type_name -> taprpc.DecodedProof 62, // 58: taprpc.DecodeProofResponse.decoded_proof:type_name -> taprpc.DecodedProof - 83, // 59: taprpc.ExportProofRequest.outpoint:type_name -> taprpc.OutPoint + 84, // 59: taprpc.ExportProofRequest.outpoint:type_name -> taprpc.OutPoint 49, // 60: taprpc.AddrEvent.addr:type_name -> taprpc.Addr 7, // 61: taprpc.AddrEvent.status:type_name -> taprpc.AddrEventStatus 7, // 62: taprpc.AddrReceivesRequest.filter_status:type_name -> taprpc.AddrEventStatus 69, // 63: taprpc.AddrReceivesResponse.events:type_name -> taprpc.AddrEvent 41, // 64: taprpc.SendAssetResponse.transfer:type_name -> taprpc.AssetTransfer - 41, // 65: taprpc.BurnAssetResponse.burn_transfer:type_name -> taprpc.AssetTransfer - 62, // 66: taprpc.BurnAssetResponse.burn_proof:type_name -> taprpc.DecodedProof - 81, // 67: taprpc.ListBurnsResponse.burns:type_name -> taprpc.AssetBurn - 49, // 68: taprpc.ReceiveEvent.address:type_name -> taprpc.Addr - 7, // 69: taprpc.ReceiveEvent.status:type_name -> taprpc.AddrEventStatus - 9, // 70: taprpc.SendEvent.parcel_type:type_name -> taprpc.ParcelType - 49, // 71: taprpc.SendEvent.addresses:type_name -> taprpc.Addr - 88, // 72: taprpc.SendEvent.anchor_transaction:type_name -> taprpc.AnchorTransaction - 41, // 73: taprpc.SendEvent.transfer:type_name -> taprpc.AssetTransfer - 83, // 74: taprpc.AnchorTransaction.lnd_locked_utxos:type_name -> taprpc.OutPoint - 83, // 75: taprpc.RegisterTransferRequest.outpoint:type_name -> taprpc.OutPoint - 23, // 76: taprpc.RegisterTransferResponse.registered_asset:type_name -> taprpc.Asset - 28, // 77: taprpc.ListUtxosResponse.ManagedUtxosEntry.value:type_name -> taprpc.ManagedUtxo - 32, // 78: taprpc.ListGroupsResponse.GroupsEntry.value:type_name -> taprpc.GroupedAssets - 35, // 79: taprpc.ListBalancesResponse.AssetBalancesEntry.value:type_name -> taprpc.AssetBalance - 36, // 80: taprpc.ListBalancesResponse.AssetGroupBalancesEntry.value:type_name -> taprpc.AssetGroupBalance - 11, // 81: taprpc.TaprootAssets.ListAssets:input_type -> taprpc.ListAssetRequest - 27, // 82: taprpc.TaprootAssets.ListUtxos:input_type -> taprpc.ListUtxosRequest - 30, // 83: taprpc.TaprootAssets.ListGroups:input_type -> taprpc.ListGroupsRequest - 34, // 84: taprpc.TaprootAssets.ListBalances:input_type -> taprpc.ListBalancesRequest - 38, // 85: taprpc.TaprootAssets.ListTransfers:input_type -> taprpc.ListTransfersRequest - 45, // 86: taprpc.TaprootAssets.StopDaemon:input_type -> taprpc.StopRequest - 47, // 87: taprpc.TaprootAssets.DebugLevel:input_type -> taprpc.DebugLevelRequest - 50, // 88: taprpc.TaprootAssets.QueryAddrs:input_type -> taprpc.QueryAddrRequest - 52, // 89: taprpc.TaprootAssets.NewAddr:input_type -> taprpc.NewAddrRequest - 60, // 90: taprpc.TaprootAssets.DecodeAddr:input_type -> taprpc.DecodeAddrRequest - 70, // 91: taprpc.TaprootAssets.AddrReceives:input_type -> taprpc.AddrReceivesRequest - 61, // 92: taprpc.TaprootAssets.VerifyProof:input_type -> taprpc.ProofFile - 64, // 93: taprpc.TaprootAssets.DecodeProof:input_type -> taprpc.DecodeProofRequest - 66, // 94: taprpc.TaprootAssets.ExportProof:input_type -> taprpc.ExportProofRequest - 67, // 95: taprpc.TaprootAssets.UnpackProofFile:input_type -> taprpc.UnpackProofFileRequest - 72, // 96: taprpc.TaprootAssets.SendAsset:input_type -> taprpc.SendAssetRequest - 78, // 97: taprpc.TaprootAssets.BurnAsset:input_type -> taprpc.BurnAssetRequest - 80, // 98: taprpc.TaprootAssets.ListBurns:input_type -> taprpc.ListBurnsRequest - 75, // 99: taprpc.TaprootAssets.GetInfo:input_type -> taprpc.GetInfoRequest - 77, // 100: taprpc.TaprootAssets.FetchAssetMeta:input_type -> taprpc.FetchAssetMetaRequest - 84, // 101: taprpc.TaprootAssets.SubscribeReceiveEvents:input_type -> taprpc.SubscribeReceiveEventsRequest - 86, // 102: taprpc.TaprootAssets.SubscribeSendEvents:input_type -> taprpc.SubscribeSendEventsRequest - 89, // 103: taprpc.TaprootAssets.RegisterTransfer:input_type -> taprpc.RegisterTransferRequest - 26, // 104: taprpc.TaprootAssets.ListAssets:output_type -> taprpc.ListAssetResponse - 29, // 105: taprpc.TaprootAssets.ListUtxos:output_type -> taprpc.ListUtxosResponse - 33, // 106: taprpc.TaprootAssets.ListGroups:output_type -> taprpc.ListGroupsResponse - 37, // 107: taprpc.TaprootAssets.ListBalances:output_type -> taprpc.ListBalancesResponse - 39, // 108: taprpc.TaprootAssets.ListTransfers:output_type -> taprpc.ListTransfersResponse - 46, // 109: taprpc.TaprootAssets.StopDaemon:output_type -> taprpc.StopResponse - 48, // 110: taprpc.TaprootAssets.DebugLevel:output_type -> taprpc.DebugLevelResponse - 51, // 111: taprpc.TaprootAssets.QueryAddrs:output_type -> taprpc.QueryAddrResponse - 49, // 112: taprpc.TaprootAssets.NewAddr:output_type -> taprpc.Addr - 49, // 113: taprpc.TaprootAssets.DecodeAddr:output_type -> taprpc.Addr - 71, // 114: taprpc.TaprootAssets.AddrReceives:output_type -> taprpc.AddrReceivesResponse - 63, // 115: taprpc.TaprootAssets.VerifyProof:output_type -> taprpc.VerifyProofResponse - 65, // 116: taprpc.TaprootAssets.DecodeProof:output_type -> taprpc.DecodeProofResponse - 61, // 117: taprpc.TaprootAssets.ExportProof:output_type -> taprpc.ProofFile - 68, // 118: taprpc.TaprootAssets.UnpackProofFile:output_type -> taprpc.UnpackProofFileResponse - 74, // 119: taprpc.TaprootAssets.SendAsset:output_type -> taprpc.SendAssetResponse - 79, // 120: taprpc.TaprootAssets.BurnAsset:output_type -> taprpc.BurnAssetResponse - 82, // 121: taprpc.TaprootAssets.ListBurns:output_type -> taprpc.ListBurnsResponse - 76, // 122: taprpc.TaprootAssets.GetInfo:output_type -> taprpc.GetInfoResponse - 10, // 123: taprpc.TaprootAssets.FetchAssetMeta:output_type -> taprpc.AssetMeta - 85, // 124: taprpc.TaprootAssets.SubscribeReceiveEvents:output_type -> taprpc.ReceiveEvent - 87, // 125: taprpc.TaprootAssets.SubscribeSendEvents:output_type -> taprpc.SendEvent - 90, // 126: taprpc.TaprootAssets.RegisterTransfer:output_type -> taprpc.RegisterTransferResponse - 104, // [104:127] is the sub-list for method output_type - 81, // [81:104] is the sub-list for method input_type - 81, // [81:81] is the sub-list for extension type_name - 81, // [81:81] is the sub-list for extension extendee - 0, // [0:81] is the sub-list for field type_name + 10, // 65: taprpc.FetchAssetMetaResponse.asset_metas:type_name -> taprpc.AssetMeta + 41, // 66: taprpc.BurnAssetResponse.burn_transfer:type_name -> taprpc.AssetTransfer + 62, // 67: taprpc.BurnAssetResponse.burn_proof:type_name -> taprpc.DecodedProof + 82, // 68: taprpc.ListBurnsResponse.burns:type_name -> taprpc.AssetBurn + 49, // 69: taprpc.ReceiveEvent.address:type_name -> taprpc.Addr + 7, // 70: taprpc.ReceiveEvent.status:type_name -> taprpc.AddrEventStatus + 9, // 71: taprpc.SendEvent.parcel_type:type_name -> taprpc.ParcelType + 49, // 72: taprpc.SendEvent.addresses:type_name -> taprpc.Addr + 89, // 73: taprpc.SendEvent.anchor_transaction:type_name -> taprpc.AnchorTransaction + 41, // 74: taprpc.SendEvent.transfer:type_name -> taprpc.AssetTransfer + 84, // 75: taprpc.AnchorTransaction.lnd_locked_utxos:type_name -> taprpc.OutPoint + 84, // 76: taprpc.RegisterTransferRequest.outpoint:type_name -> taprpc.OutPoint + 23, // 77: taprpc.RegisterTransferResponse.registered_asset:type_name -> taprpc.Asset + 28, // 78: taprpc.ListUtxosResponse.ManagedUtxosEntry.value:type_name -> taprpc.ManagedUtxo + 32, // 79: taprpc.ListGroupsResponse.GroupsEntry.value:type_name -> taprpc.GroupedAssets + 35, // 80: taprpc.ListBalancesResponse.AssetBalancesEntry.value:type_name -> taprpc.AssetBalance + 36, // 81: taprpc.ListBalancesResponse.AssetGroupBalancesEntry.value:type_name -> taprpc.AssetGroupBalance + 11, // 82: taprpc.TaprootAssets.ListAssets:input_type -> taprpc.ListAssetRequest + 27, // 83: taprpc.TaprootAssets.ListUtxos:input_type -> taprpc.ListUtxosRequest + 30, // 84: taprpc.TaprootAssets.ListGroups:input_type -> taprpc.ListGroupsRequest + 34, // 85: taprpc.TaprootAssets.ListBalances:input_type -> taprpc.ListBalancesRequest + 38, // 86: taprpc.TaprootAssets.ListTransfers:input_type -> taprpc.ListTransfersRequest + 45, // 87: taprpc.TaprootAssets.StopDaemon:input_type -> taprpc.StopRequest + 47, // 88: taprpc.TaprootAssets.DebugLevel:input_type -> taprpc.DebugLevelRequest + 50, // 89: taprpc.TaprootAssets.QueryAddrs:input_type -> taprpc.QueryAddrRequest + 52, // 90: taprpc.TaprootAssets.NewAddr:input_type -> taprpc.NewAddrRequest + 60, // 91: taprpc.TaprootAssets.DecodeAddr:input_type -> taprpc.DecodeAddrRequest + 70, // 92: taprpc.TaprootAssets.AddrReceives:input_type -> taprpc.AddrReceivesRequest + 61, // 93: taprpc.TaprootAssets.VerifyProof:input_type -> taprpc.ProofFile + 64, // 94: taprpc.TaprootAssets.DecodeProof:input_type -> taprpc.DecodeProofRequest + 66, // 95: taprpc.TaprootAssets.ExportProof:input_type -> taprpc.ExportProofRequest + 67, // 96: taprpc.TaprootAssets.UnpackProofFile:input_type -> taprpc.UnpackProofFileRequest + 72, // 97: taprpc.TaprootAssets.SendAsset:input_type -> taprpc.SendAssetRequest + 79, // 98: taprpc.TaprootAssets.BurnAsset:input_type -> taprpc.BurnAssetRequest + 81, // 99: taprpc.TaprootAssets.ListBurns:input_type -> taprpc.ListBurnsRequest + 75, // 100: taprpc.TaprootAssets.GetInfo:input_type -> taprpc.GetInfoRequest + 77, // 101: taprpc.TaprootAssets.FetchAssetMeta:input_type -> taprpc.FetchAssetMetaRequest + 85, // 102: taprpc.TaprootAssets.SubscribeReceiveEvents:input_type -> taprpc.SubscribeReceiveEventsRequest + 87, // 103: taprpc.TaprootAssets.SubscribeSendEvents:input_type -> taprpc.SubscribeSendEventsRequest + 90, // 104: taprpc.TaprootAssets.RegisterTransfer:input_type -> taprpc.RegisterTransferRequest + 26, // 105: taprpc.TaprootAssets.ListAssets:output_type -> taprpc.ListAssetResponse + 29, // 106: taprpc.TaprootAssets.ListUtxos:output_type -> taprpc.ListUtxosResponse + 33, // 107: taprpc.TaprootAssets.ListGroups:output_type -> taprpc.ListGroupsResponse + 37, // 108: taprpc.TaprootAssets.ListBalances:output_type -> taprpc.ListBalancesResponse + 39, // 109: taprpc.TaprootAssets.ListTransfers:output_type -> taprpc.ListTransfersResponse + 46, // 110: taprpc.TaprootAssets.StopDaemon:output_type -> taprpc.StopResponse + 48, // 111: taprpc.TaprootAssets.DebugLevel:output_type -> taprpc.DebugLevelResponse + 51, // 112: taprpc.TaprootAssets.QueryAddrs:output_type -> taprpc.QueryAddrResponse + 49, // 113: taprpc.TaprootAssets.NewAddr:output_type -> taprpc.Addr + 49, // 114: taprpc.TaprootAssets.DecodeAddr:output_type -> taprpc.Addr + 71, // 115: taprpc.TaprootAssets.AddrReceives:output_type -> taprpc.AddrReceivesResponse + 63, // 116: taprpc.TaprootAssets.VerifyProof:output_type -> taprpc.VerifyProofResponse + 65, // 117: taprpc.TaprootAssets.DecodeProof:output_type -> taprpc.DecodeProofResponse + 61, // 118: taprpc.TaprootAssets.ExportProof:output_type -> taprpc.ProofFile + 68, // 119: taprpc.TaprootAssets.UnpackProofFile:output_type -> taprpc.UnpackProofFileResponse + 74, // 120: taprpc.TaprootAssets.SendAsset:output_type -> taprpc.SendAssetResponse + 80, // 121: taprpc.TaprootAssets.BurnAsset:output_type -> taprpc.BurnAssetResponse + 83, // 122: taprpc.TaprootAssets.ListBurns:output_type -> taprpc.ListBurnsResponse + 76, // 123: taprpc.TaprootAssets.GetInfo:output_type -> taprpc.GetInfoResponse + 78, // 124: taprpc.TaprootAssets.FetchAssetMeta:output_type -> taprpc.FetchAssetMetaResponse + 86, // 125: taprpc.TaprootAssets.SubscribeReceiveEvents:output_type -> taprpc.ReceiveEvent + 88, // 126: taprpc.TaprootAssets.SubscribeSendEvents:output_type -> taprpc.SendEvent + 91, // 127: taprpc.TaprootAssets.RegisterTransfer:output_type -> taprpc.RegisterTransferResponse + 105, // [105:128] is the sub-list for method output_type + 82, // [82:105] is the sub-list for method input_type + 82, // [82:82] is the sub-list for extension type_name + 82, // [82:82] is the sub-list for extension extendee + 0, // [0:82] is the sub-list for field type_name } func init() { file_taprootassets_proto_init() } @@ -8057,980 +7417,6 @@ func file_taprootassets_proto_init() { if File_taprootassets_proto != nil { return } - if !protoimpl.UnsafeEnabled { - file_taprootassets_proto_msgTypes[0].Exporter = func(v any, i int) any { - switch v := v.(*AssetMeta); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[1].Exporter = func(v any, i int) any { - switch v := v.(*ListAssetRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[2].Exporter = func(v any, i int) any { - switch v := v.(*AnchorInfo); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[3].Exporter = func(v any, i int) any { - switch v := v.(*GenesisInfo); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[4].Exporter = func(v any, i int) any { - switch v := v.(*ExternalKey); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[5].Exporter = func(v any, i int) any { - switch v := v.(*GroupKeyRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[6].Exporter = func(v any, i int) any { - switch v := v.(*TxOut); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[7].Exporter = func(v any, i int) any { - switch v := v.(*GroupVirtualTx); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[8].Exporter = func(v any, i int) any { - switch v := v.(*GroupWitness); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[9].Exporter = func(v any, i int) any { - switch v := v.(*AssetGroup); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[10].Exporter = func(v any, i int) any { - switch v := v.(*GroupKeyReveal); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[11].Exporter = func(v any, i int) any { - switch v := v.(*GenesisReveal); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[12].Exporter = func(v any, i int) any { - switch v := v.(*DecimalDisplay); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[13].Exporter = func(v any, i int) any { - switch v := v.(*Asset); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[14].Exporter = func(v any, i int) any { - switch v := v.(*PrevWitness); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[15].Exporter = func(v any, i int) any { - switch v := v.(*SplitCommitment); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[16].Exporter = func(v any, i int) any { - switch v := v.(*ListAssetResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[17].Exporter = func(v any, i int) any { - switch v := v.(*ListUtxosRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[18].Exporter = func(v any, i int) any { - switch v := v.(*ManagedUtxo); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[19].Exporter = func(v any, i int) any { - switch v := v.(*ListUtxosResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[20].Exporter = func(v any, i int) any { - switch v := v.(*ListGroupsRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[21].Exporter = func(v any, i int) any { - switch v := v.(*AssetHumanReadable); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[22].Exporter = func(v any, i int) any { - switch v := v.(*GroupedAssets); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[23].Exporter = func(v any, i int) any { - switch v := v.(*ListGroupsResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[24].Exporter = func(v any, i int) any { - switch v := v.(*ListBalancesRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[25].Exporter = func(v any, i int) any { - switch v := v.(*AssetBalance); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[26].Exporter = func(v any, i int) any { - switch v := v.(*AssetGroupBalance); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[27].Exporter = func(v any, i int) any { - switch v := v.(*ListBalancesResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[28].Exporter = func(v any, i int) any { - switch v := v.(*ListTransfersRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[29].Exporter = func(v any, i int) any { - switch v := v.(*ListTransfersResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[30].Exporter = func(v any, i int) any { - switch v := v.(*ChainHash); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[31].Exporter = func(v any, i int) any { - switch v := v.(*AssetTransfer); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[32].Exporter = func(v any, i int) any { - switch v := v.(*TransferInput); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[33].Exporter = func(v any, i int) any { - switch v := v.(*TransferOutputAnchor); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[34].Exporter = func(v any, i int) any { - switch v := v.(*TransferOutput); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[35].Exporter = func(v any, i int) any { - switch v := v.(*StopRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[36].Exporter = func(v any, i int) any { - switch v := v.(*StopResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[37].Exporter = func(v any, i int) any { - switch v := v.(*DebugLevelRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[38].Exporter = func(v any, i int) any { - switch v := v.(*DebugLevelResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[39].Exporter = func(v any, i int) any { - switch v := v.(*Addr); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[40].Exporter = func(v any, i int) any { - switch v := v.(*QueryAddrRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[41].Exporter = func(v any, i int) any { - switch v := v.(*QueryAddrResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[42].Exporter = func(v any, i int) any { - switch v := v.(*NewAddrRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[43].Exporter = func(v any, i int) any { - switch v := v.(*ScriptKeyTypeQuery); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[44].Exporter = func(v any, i int) any { - switch v := v.(*ScriptKey); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[45].Exporter = func(v any, i int) any { - switch v := v.(*KeyLocator); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[46].Exporter = func(v any, i int) any { - switch v := v.(*KeyDescriptor); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[47].Exporter = func(v any, i int) any { - switch v := v.(*TapscriptFullTree); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[48].Exporter = func(v any, i int) any { - switch v := v.(*TapLeaf); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[49].Exporter = func(v any, i int) any { - switch v := v.(*TapBranch); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[50].Exporter = func(v any, i int) any { - switch v := v.(*DecodeAddrRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[51].Exporter = func(v any, i int) any { - switch v := v.(*ProofFile); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[52].Exporter = func(v any, i int) any { - switch v := v.(*DecodedProof); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[53].Exporter = func(v any, i int) any { - switch v := v.(*VerifyProofResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[54].Exporter = func(v any, i int) any { - switch v := v.(*DecodeProofRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[55].Exporter = func(v any, i int) any { - switch v := v.(*DecodeProofResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[56].Exporter = func(v any, i int) any { - switch v := v.(*ExportProofRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[57].Exporter = func(v any, i int) any { - switch v := v.(*UnpackProofFileRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[58].Exporter = func(v any, i int) any { - switch v := v.(*UnpackProofFileResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[59].Exporter = func(v any, i int) any { - switch v := v.(*AddrEvent); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[60].Exporter = func(v any, i int) any { - switch v := v.(*AddrReceivesRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[61].Exporter = func(v any, i int) any { - switch v := v.(*AddrReceivesResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[62].Exporter = func(v any, i int) any { - switch v := v.(*SendAssetRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[63].Exporter = func(v any, i int) any { - switch v := v.(*PrevInputAsset); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[64].Exporter = func(v any, i int) any { - switch v := v.(*SendAssetResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[65].Exporter = func(v any, i int) any { - switch v := v.(*GetInfoRequest); 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 any, i int) any { - switch v := v.(*GetInfoResponse); 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 any, i int) any { - switch v := v.(*FetchAssetMetaRequest); 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 any, i int) any { - switch v := v.(*BurnAssetRequest); 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 any, i int) any { - switch v := v.(*BurnAssetResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[70].Exporter = func(v any, i int) any { - switch v := v.(*ListBurnsRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[71].Exporter = func(v any, i int) any { - switch v := v.(*AssetBurn); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[72].Exporter = func(v any, i int) any { - switch v := v.(*ListBurnsResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[73].Exporter = func(v any, i int) any { - switch v := v.(*OutPoint); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[74].Exporter = func(v any, i int) any { - 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[75].Exporter = func(v any, i int) any { - 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[76].Exporter = func(v any, i int) any { - 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[77].Exporter = func(v any, i int) any { - 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[78].Exporter = func(v any, i int) any { - switch v := v.(*AnchorTransaction); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[79].Exporter = func(v any, i int) any { - switch v := v.(*RegisterTransferRequest); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - file_taprootassets_proto_msgTypes[80].Exporter = func(v any, i int) any { - switch v := v.(*RegisterTransferResponse); i { - case 0: - return &v.state - case 1: - return &v.sizeCache - case 2: - return &v.unknownFields - default: - return nil - } - } - } file_taprootassets_proto_msgTypes[24].OneofWrappers = []any{ (*ListBalancesRequest_AssetId)(nil), (*ListBalancesRequest_GroupKey)(nil), @@ -9044,8 +7430,10 @@ func file_taprootassets_proto_init() { (*FetchAssetMetaRequest_MetaHash)(nil), (*FetchAssetMetaRequest_AssetIdStr)(nil), (*FetchAssetMetaRequest_MetaHashStr)(nil), + (*FetchAssetMetaRequest_GroupKey)(nil), + (*FetchAssetMetaRequest_GroupKeyStr)(nil), } - file_taprootassets_proto_msgTypes[68].OneofWrappers = []any{ + file_taprootassets_proto_msgTypes[69].OneofWrappers = []any{ (*BurnAssetRequest_AssetId)(nil), (*BurnAssetRequest_AssetIdStr)(nil), } @@ -9053,9 +7441,9 @@ func file_taprootassets_proto_init() { out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_taprootassets_proto_rawDesc, + RawDescriptor: unsafe.Slice(unsafe.StringData(file_taprootassets_proto_rawDesc), len(file_taprootassets_proto_rawDesc)), NumEnums: 10, - NumMessages: 85, + NumMessages: 86, NumExtensions: 0, NumServices: 1, }, @@ -9065,7 +7453,6 @@ func file_taprootassets_proto_init() { MessageInfos: file_taprootassets_proto_msgTypes, }.Build() File_taprootassets_proto = out.File - file_taprootassets_proto_rawDesc = nil file_taprootassets_proto_goTypes = nil file_taprootassets_proto_depIdxs = nil } diff --git a/taprpc/taprootassets.pb.gw.go b/taprpc/taprootassets.pb.gw.go index 206f7c8a1..d25734e0c 100644 --- a/taprpc/taprootassets.pb.gw.go +++ b/taprpc/taprootassets.pb.gw.go @@ -10,6 +10,7 @@ package taprpc import ( "context" + "errors" "io" "net/http" @@ -24,623 +25,566 @@ import ( ) // Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = metadata.Join - var ( - filter_TaprootAssets_ListAssets_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + _ codes.Code + _ io.Reader + _ status.Status + _ = errors.New + _ = runtime.String + _ = utilities.NewDoubleArray + _ = metadata.Join ) -func request_TaprootAssets_ListAssets_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListAssetRequest - var metadata runtime.ServerMetadata +var filter_TaprootAssets_ListAssets_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +func request_TaprootAssets_ListAssets_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq ListAssetRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListAssets_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.ListAssets(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_ListAssets_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListAssetRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListAssetRequest + metadata runtime.ServerMetadata + ) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListAssets_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.ListAssets(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_TaprootAssets_ListUtxos_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_TaprootAssets_ListUtxos_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_TaprootAssets_ListUtxos_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListUtxosRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListUtxosRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListUtxos_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.ListUtxos(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_ListUtxos_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListUtxosRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListUtxosRequest + metadata runtime.ServerMetadata + ) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListUtxos_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.ListUtxos(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_ListGroups_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListGroupsRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListGroupsRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) msg, err := client.ListGroups(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_ListGroups_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListGroupsRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListGroupsRequest + metadata runtime.ServerMetadata + ) msg, err := server.ListGroups(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_TaprootAssets_ListBalances_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_TaprootAssets_ListBalances_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_TaprootAssets_ListBalances_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListBalancesRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListBalancesRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListBalances_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.ListBalances(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_ListBalances_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListBalancesRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListBalancesRequest + metadata runtime.ServerMetadata + ) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListBalances_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.ListBalances(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_TaprootAssets_ListTransfers_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_TaprootAssets_ListTransfers_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_TaprootAssets_ListTransfers_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListTransfersRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListTransfersRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListTransfers_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.ListTransfers(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_ListTransfers_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListTransfersRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListTransfersRequest + metadata runtime.ServerMetadata + ) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListTransfers_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.ListTransfers(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_ListTransfers_1(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListTransfersRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq ListTransfersRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["anchor_txid"] + io.Copy(io.Discard, req.Body) + val, ok := pathParams["anchor_txid"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "anchor_txid") } - protoReq.AnchorTxid, err = runtime.String(val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "anchor_txid", err) } - msg, err := client.ListTransfers(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_ListTransfers_1(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListTransfersRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq ListTransfersRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["anchor_txid"] + val, ok := pathParams["anchor_txid"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "anchor_txid") } - protoReq.AnchorTxid, err = runtime.String(val) if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "anchor_txid", err) } - msg, err := server.ListTransfers(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_StopDaemon_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq StopRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq StopRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.StopDaemon(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_StopDaemon_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq StopRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq StopRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.StopDaemon(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_DebugLevel_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DebugLevelRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq DebugLevelRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.DebugLevel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_DebugLevel_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DebugLevelRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq DebugLevelRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.DebugLevel(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_TaprootAssets_QueryAddrs_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_TaprootAssets_QueryAddrs_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_TaprootAssets_QueryAddrs_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryAddrRequest - var metadata runtime.ServerMetadata - + var ( + protoReq QueryAddrRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_QueryAddrs_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.QueryAddrs(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_QueryAddrs_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryAddrRequest - var metadata runtime.ServerMetadata - + var ( + protoReq QueryAddrRequest + metadata runtime.ServerMetadata + ) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_QueryAddrs_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.QueryAddrs(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_NewAddr_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq NewAddrRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq NewAddrRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.NewAddr(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_NewAddr_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq NewAddrRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq NewAddrRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.NewAddr(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_DecodeAddr_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DecodeAddrRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq DecodeAddrRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.DecodeAddr(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_DecodeAddr_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DecodeAddrRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq DecodeAddrRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.DecodeAddr(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_AddrReceives_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddrReceivesRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq AddrReceivesRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.AddrReceives(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_AddrReceives_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq AddrReceivesRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq AddrReceivesRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.AddrReceives(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_VerifyProof_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ProofFile - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq ProofFile + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.VerifyProof(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_VerifyProof_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ProofFile - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq ProofFile + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.VerifyProof(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_DecodeProof_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DecodeProofRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq DecodeProofRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.DecodeProof(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_DecodeProof_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq DecodeProofRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq DecodeProofRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.DecodeProof(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_ExportProof_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ExportProofRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq ExportProofRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.ExportProof(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_ExportProof_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ExportProofRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq ExportProofRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.ExportProof(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_UnpackProofFile_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq UnpackProofFileRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq UnpackProofFileRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.UnpackProofFile(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_UnpackProofFile_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq UnpackProofFileRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq UnpackProofFileRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.UnpackProofFile(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_SendAsset_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq SendAssetRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SendAssetRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.SendAsset(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_SendAsset_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq SendAssetRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SendAssetRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.SendAsset(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_BurnAsset_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq BurnAssetRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq BurnAssetRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.BurnAsset(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_BurnAsset_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq BurnAssetRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq BurnAssetRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.BurnAsset(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_TaprootAssets_ListBurns_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) +var filter_TaprootAssets_ListBurns_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} func request_TaprootAssets_ListBurns_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListBurnsRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListBurnsRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListBurns_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.ListBurns(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_ListBurns_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq ListBurnsRequest - var metadata runtime.ServerMetadata - + var ( + protoReq ListBurnsRequest + metadata runtime.ServerMetadata + ) if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_ListBurns_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.ListBurns(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_GetInfo_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq GetInfoRequest - var metadata runtime.ServerMetadata - + var ( + protoReq GetInfoRequest + metadata runtime.ServerMetadata + ) + io.Copy(io.Discard, req.Body) msg, err := client.GetInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_GetInfo_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq GetInfoRequest - var metadata runtime.ServerMetadata - + var ( + protoReq GetInfoRequest + metadata runtime.ServerMetadata + ) msg, err := server.GetInfo(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_TaprootAssets_FetchAssetMeta_0 = &utilities.DoubleArray{Encoding: map[string]int{"asset_id_str": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} -) +var filter_TaprootAssets_FetchAssetMeta_0 = &utilities.DoubleArray{Encoding: map[string]int{"asset_id_str": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} func request_TaprootAssets_FetchAssetMeta_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq FetchAssetMetaRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq FetchAssetMetaRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_id_str"] + io.Copy(io.Discard, req.Body) + val, ok := pathParams["asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_id_str") } - if protoReq.Asset == nil { protoReq.Asset = &FetchAssetMetaRequest_AssetIdStr{} } else if _, ok := protoReq.Asset.(*FetchAssetMetaRequest_AssetIdStr); !ok { @@ -650,35 +594,26 @@ func request_TaprootAssets_FetchAssetMeta_0(ctx context.Context, marshaler runti if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_id_str", err) } - if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_FetchAssetMeta_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.FetchAssetMeta(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_FetchAssetMeta_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq FetchAssetMetaRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq FetchAssetMetaRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["asset_id_str"] + val, ok := pathParams["asset_id_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "asset_id_str") } - if protoReq.Asset == nil { protoReq.Asset = &FetchAssetMetaRequest_AssetIdStr{} } else if _, ok := protoReq.Asset.(*FetchAssetMetaRequest_AssetIdStr); !ok { @@ -688,39 +623,29 @@ func local_request_TaprootAssets_FetchAssetMeta_0(ctx context.Context, marshaler if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "asset_id_str", err) } - if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_FetchAssetMeta_0); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.FetchAssetMeta(ctx, &protoReq) return msg, metadata, err - } -var ( - filter_TaprootAssets_FetchAssetMeta_1 = &utilities.DoubleArray{Encoding: map[string]int{"meta_hash_str": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} -) +var filter_TaprootAssets_FetchAssetMeta_1 = &utilities.DoubleArray{Encoding: map[string]int{"meta_hash_str": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} func request_TaprootAssets_FetchAssetMeta_1(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq FetchAssetMetaRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq FetchAssetMetaRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["meta_hash_str"] + io.Copy(io.Discard, req.Body) + val, ok := pathParams["meta_hash_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "meta_hash_str") } - if protoReq.Asset == nil { protoReq.Asset = &FetchAssetMetaRequest_MetaHashStr{} } else if _, ok := protoReq.Asset.(*FetchAssetMetaRequest_MetaHashStr); !ok { @@ -730,35 +655,26 @@ func request_TaprootAssets_FetchAssetMeta_1(ctx context.Context, marshaler runti if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "meta_hash_str", err) } - if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_FetchAssetMeta_1); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.FetchAssetMeta(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_FetchAssetMeta_1(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq FetchAssetMetaRequest - var metadata runtime.ServerMetadata - var ( - val string - ok bool - err error - _ = err + protoReq FetchAssetMetaRequest + metadata runtime.ServerMetadata + err error ) - - val, ok = pathParams["meta_hash_str"] + val, ok := pathParams["meta_hash_str"] if !ok { return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "meta_hash_str") } - if protoReq.Asset == nil { protoReq.Asset = &FetchAssetMetaRequest_MetaHashStr{} } else if _, ok := protoReq.Asset.(*FetchAssetMetaRequest_MetaHashStr); !ok { @@ -768,27 +684,24 @@ func local_request_TaprootAssets_FetchAssetMeta_1(ctx context.Context, marshaler if err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "meta_hash_str", err) } - if err := req.ParseForm(); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TaprootAssets_FetchAssetMeta_1); err != nil { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.FetchAssetMeta(ctx, &protoReq) return msg, metadata, err - } func request_TaprootAssets_SubscribeReceiveEvents_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (TaprootAssets_SubscribeReceiveEventsClient, runtime.ServerMetadata, error) { - var protoReq SubscribeReceiveEventsRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SubscribeReceiveEventsRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - stream, err := client.SubscribeReceiveEvents(ctx, &protoReq) if err != nil { return nil, metadata, err @@ -799,17 +712,16 @@ func request_TaprootAssets_SubscribeReceiveEvents_0(ctx context.Context, marshal } metadata.HeaderMD = header return stream, metadata, nil - } func request_TaprootAssets_SubscribeSendEvents_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (TaprootAssets_SubscribeSendEventsClient, runtime.ServerMetadata, error) { - var protoReq SubscribeSendEventsRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq SubscribeSendEventsRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - stream, err := client.SubscribeSendEvents(ctx, &protoReq) if err != nil { return nil, metadata, err @@ -820,50 +732,45 @@ func request_TaprootAssets_SubscribeSendEvents_0(ctx context.Context, marshaler } metadata.HeaderMD = header return stream, metadata, nil - } func request_TaprootAssets_RegisterTransfer_0(ctx context.Context, marshaler runtime.Marshaler, client TaprootAssetsClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq RegisterTransferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq RegisterTransferRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := client.RegisterTransfer(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err - } func local_request_TaprootAssets_RegisterTransfer_0(ctx context.Context, marshaler runtime.Marshaler, server TaprootAssetsServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq RegisterTransferRequest - var metadata runtime.ServerMetadata - - if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && err != io.EOF { + var ( + protoReq RegisterTransferRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) { return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) } - msg, err := server.RegisterTransfer(ctx, &protoReq) return msg, metadata, err - } // RegisterTaprootAssetsHandlerServer registers the http handlers for service TaprootAssets to "mux". // UnaryRPC :call TaprootAssetsServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterTaprootAssetsHandlerFromEndpoint instead. +// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call. func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeMux, server TaprootAssetsServer) error { - - mux.Handle("GET", pattern_TaprootAssets_ListAssets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListAssets_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, "/taprpc.TaprootAssets/ListAssets", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/ListAssets", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -875,20 +782,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListAssets_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListUtxos_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListUtxos_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, "/taprpc.TaprootAssets/ListUtxos", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/utxos")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/ListUtxos", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/utxos")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -900,20 +802,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListUtxos_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListGroups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListGroups_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, "/taprpc.TaprootAssets/ListGroups", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/groups")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/ListGroups", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/groups")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -925,20 +822,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListGroups_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListBalances_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListBalances_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, "/taprpc.TaprootAssets/ListBalances", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/balance")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/ListBalances", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/balance")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -950,20 +842,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListBalances_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListTransfers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListTransfers_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, "/taprpc.TaprootAssets/ListTransfers", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/ListTransfers", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -975,20 +862,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListTransfers_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListTransfers_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListTransfers_1, 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, "/taprpc.TaprootAssets/ListTransfers", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers/{anchor_txid}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/ListTransfers", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers/{anchor_txid}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1000,20 +882,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListTransfers_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_StopDaemon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_StopDaemon_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, "/taprpc.TaprootAssets/StopDaemon", runtime.WithHTTPPathPattern("/v1/taproot-assets/stop")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/StopDaemon", runtime.WithHTTPPathPattern("/v1/taproot-assets/stop")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1025,20 +902,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_StopDaemon_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_DebugLevel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_DebugLevel_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, "/taprpc.TaprootAssets/DebugLevel", runtime.WithHTTPPathPattern("/v1/taproot-assets/debuglevel")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/DebugLevel", runtime.WithHTTPPathPattern("/v1/taproot-assets/debuglevel")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1050,20 +922,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_DebugLevel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_QueryAddrs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_QueryAddrs_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, "/taprpc.TaprootAssets/QueryAddrs", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/QueryAddrs", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1075,20 +942,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_QueryAddrs_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_NewAddr_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_NewAddr_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, "/taprpc.TaprootAssets/NewAddr", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/NewAddr", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1100,20 +962,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_NewAddr_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_DecodeAddr_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_DecodeAddr_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, "/taprpc.TaprootAssets/DecodeAddr", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs/decode")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/DecodeAddr", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs/decode")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1125,20 +982,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_DecodeAddr_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_AddrReceives_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_AddrReceives_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, "/taprpc.TaprootAssets/AddrReceives", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs/receives")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/AddrReceives", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs/receives")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1150,20 +1002,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_AddrReceives_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_VerifyProof_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_VerifyProof_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, "/taprpc.TaprootAssets/VerifyProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/verify")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/VerifyProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/verify")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1175,20 +1022,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_VerifyProof_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_DecodeProof_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_DecodeProof_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, "/taprpc.TaprootAssets/DecodeProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/decode")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/DecodeProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/decode")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1200,20 +1042,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_DecodeProof_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_ExportProof_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_ExportProof_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, "/taprpc.TaprootAssets/ExportProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/export")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/ExportProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/export")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1225,20 +1062,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ExportProof_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_UnpackProofFile_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_UnpackProofFile_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, "/taprpc.TaprootAssets/UnpackProofFile", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/unpack-file")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/UnpackProofFile", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/unpack-file")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1250,20 +1082,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_UnpackProofFile_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_SendAsset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_SendAsset_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, "/taprpc.TaprootAssets/SendAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/send")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/SendAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/send")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1275,20 +1102,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_SendAsset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_BurnAsset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_BurnAsset_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, "/taprpc.TaprootAssets/BurnAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/burn")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/BurnAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/burn")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1300,20 +1122,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_BurnAsset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListBurns_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListBurns_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, "/taprpc.TaprootAssets/ListBurns", runtime.WithHTTPPathPattern("/v1/taproot-assets/burns")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/ListBurns", runtime.WithHTTPPathPattern("/v1/taproot-assets/burns")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1325,20 +1142,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListBurns_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_GetInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_GetInfo_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, "/taprpc.TaprootAssets/GetInfo", runtime.WithHTTPPathPattern("/v1/taproot-assets/getinfo")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/GetInfo", runtime.WithHTTPPathPattern("/v1/taproot-assets/getinfo")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1350,20 +1162,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_GetInfo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_FetchAssetMeta_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_FetchAssetMeta_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, "/taprpc.TaprootAssets/FetchAssetMeta", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/meta/asset-id/{asset_id_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/FetchAssetMeta", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/meta/asset-id/{asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1375,20 +1182,15 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_FetchAssetMeta_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_FetchAssetMeta_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_FetchAssetMeta_1, 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, "/taprpc.TaprootAssets/FetchAssetMeta", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/meta/hash/{meta_hash_str}")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/FetchAssetMeta", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/meta/hash/{meta_hash_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1400,34 +1202,29 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_FetchAssetMeta_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - mux.Handle("POST", pattern_TaprootAssets_SubscribeReceiveEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_SubscribeReceiveEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport") _, outboundMarshaler := runtime.MarshalerForRequest(mux, req) runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return }) - mux.Handle("POST", pattern_TaprootAssets_SubscribeSendEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_SubscribeSendEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport") _, outboundMarshaler := runtime.MarshalerForRequest(mux, req) runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return }) - - mux.Handle("POST", pattern_TaprootAssets_RegisterTransfer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_RegisterTransfer_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, "/taprpc.TaprootAssets/RegisterTransfer", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers/register")) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/taprpc.TaprootAssets/RegisterTransfer", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers/register")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1439,9 +1236,7 @@ func RegisterTaprootAssetsHandlerServer(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_RegisterTransfer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) return nil @@ -1468,7 +1263,6 @@ func RegisterTaprootAssetsHandlerFromEndpoint(ctx context.Context, mux *runtime. } }() }() - return RegisterTaprootAssetsHandler(ctx, mux, conn) } @@ -1482,16 +1276,13 @@ func RegisterTaprootAssetsHandler(ctx context.Context, mux *runtime.ServeMux, co // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "TaprootAssetsClient". // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "TaprootAssetsClient" // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "TaprootAssetsClient" to call the correct interceptors. +// "TaprootAssetsClient" to call the correct interceptors. This client ignores the HTTP middlewares. func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TaprootAssetsClient) error { - - mux.Handle("GET", pattern_TaprootAssets_ListAssets_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListAssets_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, "/taprpc.TaprootAssets/ListAssets", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/ListAssets", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1502,18 +1293,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListAssets_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListUtxos_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListUtxos_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, "/taprpc.TaprootAssets/ListUtxos", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/utxos")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/ListUtxos", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/utxos")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1524,18 +1310,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListUtxos_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListGroups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListGroups_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, "/taprpc.TaprootAssets/ListGroups", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/groups")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/ListGroups", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/groups")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1546,18 +1327,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListGroups_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListBalances_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListBalances_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, "/taprpc.TaprootAssets/ListBalances", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/balance")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/ListBalances", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/balance")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1568,18 +1344,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListBalances_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListTransfers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListTransfers_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, "/taprpc.TaprootAssets/ListTransfers", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/ListTransfers", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1590,18 +1361,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListTransfers_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListTransfers_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListTransfers_1, 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, "/taprpc.TaprootAssets/ListTransfers", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers/{anchor_txid}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/ListTransfers", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers/{anchor_txid}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1612,18 +1378,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListTransfers_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_StopDaemon_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_StopDaemon_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, "/taprpc.TaprootAssets/StopDaemon", runtime.WithHTTPPathPattern("/v1/taproot-assets/stop")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/StopDaemon", runtime.WithHTTPPathPattern("/v1/taproot-assets/stop")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1634,18 +1395,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_StopDaemon_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_DebugLevel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_DebugLevel_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, "/taprpc.TaprootAssets/DebugLevel", runtime.WithHTTPPathPattern("/v1/taproot-assets/debuglevel")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/DebugLevel", runtime.WithHTTPPathPattern("/v1/taproot-assets/debuglevel")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1656,18 +1412,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_DebugLevel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_QueryAddrs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_QueryAddrs_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, "/taprpc.TaprootAssets/QueryAddrs", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/QueryAddrs", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1678,18 +1429,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_QueryAddrs_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_NewAddr_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_NewAddr_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, "/taprpc.TaprootAssets/NewAddr", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/NewAddr", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1700,18 +1446,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_NewAddr_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_DecodeAddr_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_DecodeAddr_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, "/taprpc.TaprootAssets/DecodeAddr", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs/decode")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/DecodeAddr", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs/decode")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1722,18 +1463,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_DecodeAddr_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_AddrReceives_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_AddrReceives_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, "/taprpc.TaprootAssets/AddrReceives", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs/receives")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/AddrReceives", runtime.WithHTTPPathPattern("/v1/taproot-assets/addrs/receives")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1744,18 +1480,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_AddrReceives_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_VerifyProof_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_VerifyProof_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, "/taprpc.TaprootAssets/VerifyProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/verify")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/VerifyProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/verify")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1766,18 +1497,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_VerifyProof_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_DecodeProof_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_DecodeProof_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, "/taprpc.TaprootAssets/DecodeProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/decode")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/DecodeProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/decode")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1788,18 +1514,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_DecodeProof_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_ExportProof_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_ExportProof_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, "/taprpc.TaprootAssets/ExportProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/export")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/ExportProof", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/export")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1810,18 +1531,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ExportProof_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_UnpackProofFile_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_UnpackProofFile_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, "/taprpc.TaprootAssets/UnpackProofFile", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/unpack-file")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/UnpackProofFile", runtime.WithHTTPPathPattern("/v1/taproot-assets/proofs/unpack-file")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1832,18 +1548,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_UnpackProofFile_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_SendAsset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_SendAsset_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, "/taprpc.TaprootAssets/SendAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/send")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/SendAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/send")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1854,18 +1565,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_SendAsset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_BurnAsset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_BurnAsset_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, "/taprpc.TaprootAssets/BurnAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/burn")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/BurnAsset", runtime.WithHTTPPathPattern("/v1/taproot-assets/burn")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1876,18 +1582,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_BurnAsset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_ListBurns_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_ListBurns_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, "/taprpc.TaprootAssets/ListBurns", runtime.WithHTTPPathPattern("/v1/taproot-assets/burns")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/ListBurns", runtime.WithHTTPPathPattern("/v1/taproot-assets/burns")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1898,18 +1599,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_ListBurns_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_GetInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_GetInfo_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, "/taprpc.TaprootAssets/GetInfo", runtime.WithHTTPPathPattern("/v1/taproot-assets/getinfo")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/GetInfo", runtime.WithHTTPPathPattern("/v1/taproot-assets/getinfo")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1920,18 +1616,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_GetInfo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_FetchAssetMeta_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_FetchAssetMeta_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, "/taprpc.TaprootAssets/FetchAssetMeta", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/meta/asset-id/{asset_id_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/FetchAssetMeta", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/meta/asset-id/{asset_id_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1942,18 +1633,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_FetchAssetMeta_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("GET", pattern_TaprootAssets_FetchAssetMeta_1, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodGet, pattern_TaprootAssets_FetchAssetMeta_1, 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, "/taprpc.TaprootAssets/FetchAssetMeta", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/meta/hash/{meta_hash_str}")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/FetchAssetMeta", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/meta/hash/{meta_hash_str}")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1964,18 +1650,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_FetchAssetMeta_1(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_SubscribeReceiveEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_SubscribeReceiveEvents_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, "/taprpc.TaprootAssets/SubscribeReceiveEvents", runtime.WithHTTPPathPattern("/v1/taproot-assets/events/asset-receive")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/SubscribeReceiveEvents", runtime.WithHTTPPathPattern("/v1/taproot-assets/events/asset-receive")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -1986,18 +1667,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_SubscribeReceiveEvents_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_SubscribeSendEvents_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_SubscribeSendEvents_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, "/taprpc.TaprootAssets/SubscribeSendEvents", runtime.WithHTTPPathPattern("/v1/taproot-assets/events/asset-send")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/SubscribeSendEvents", runtime.WithHTTPPathPattern("/v1/taproot-assets/events/asset-send")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -2008,18 +1684,13 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_SubscribeSendEvents_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) - }) - - mux.Handle("POST", pattern_TaprootAssets_RegisterTransfer_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle(http.MethodPost, pattern_TaprootAssets_RegisterTransfer_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, "/taprpc.TaprootAssets/RegisterTransfer", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers/register")) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/taprpc.TaprootAssets/RegisterTransfer", runtime.WithHTTPPathPattern("/v1/taproot-assets/assets/transfers/register")) if err != nil { runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return @@ -2030,114 +1701,63 @@ func RegisterTaprootAssetsHandlerClient(ctx context.Context, mux *runtime.ServeM runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) return } - forward_TaprootAssets_RegisterTransfer_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - }) - return nil } var ( - pattern_TaprootAssets_ListAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "assets"}, "")) - - pattern_TaprootAssets_ListUtxos_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "assets", "utxos"}, "")) - - pattern_TaprootAssets_ListGroups_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "assets", "groups"}, "")) - - pattern_TaprootAssets_ListBalances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "assets", "balance"}, "")) - - pattern_TaprootAssets_ListTransfers_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "assets", "transfers"}, "")) - - pattern_TaprootAssets_ListTransfers_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "taproot-assets", "assets", "transfers", "anchor_txid"}, "")) - - pattern_TaprootAssets_StopDaemon_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "stop"}, "")) - - pattern_TaprootAssets_DebugLevel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "debuglevel"}, "")) - - pattern_TaprootAssets_QueryAddrs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "addrs"}, "")) - - pattern_TaprootAssets_NewAddr_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "addrs"}, "")) - - pattern_TaprootAssets_DecodeAddr_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "addrs", "decode"}, "")) - - pattern_TaprootAssets_AddrReceives_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "addrs", "receives"}, "")) - - pattern_TaprootAssets_VerifyProof_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "proofs", "verify"}, "")) - - pattern_TaprootAssets_DecodeProof_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "proofs", "decode"}, "")) - - pattern_TaprootAssets_ExportProof_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "proofs", "export"}, "")) - - pattern_TaprootAssets_UnpackProofFile_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "proofs", "unpack-file"}, "")) - - pattern_TaprootAssets_SendAsset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "send"}, "")) - - pattern_TaprootAssets_BurnAsset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "burn"}, "")) - - pattern_TaprootAssets_ListBurns_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "burns"}, "")) - - pattern_TaprootAssets_GetInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "getinfo"}, "")) - - pattern_TaprootAssets_FetchAssetMeta_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "assets", "meta", "asset-id", "asset_id_str"}, "")) - - pattern_TaprootAssets_FetchAssetMeta_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "assets", "meta", "hash", "meta_hash_str"}, "")) - + pattern_TaprootAssets_ListAssets_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "assets"}, "")) + pattern_TaprootAssets_ListUtxos_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "assets", "utxos"}, "")) + pattern_TaprootAssets_ListGroups_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "assets", "groups"}, "")) + pattern_TaprootAssets_ListBalances_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "assets", "balance"}, "")) + pattern_TaprootAssets_ListTransfers_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "assets", "transfers"}, "")) + pattern_TaprootAssets_ListTransfers_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"v1", "taproot-assets", "assets", "transfers", "anchor_txid"}, "")) + pattern_TaprootAssets_StopDaemon_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "stop"}, "")) + pattern_TaprootAssets_DebugLevel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "debuglevel"}, "")) + pattern_TaprootAssets_QueryAddrs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "addrs"}, "")) + pattern_TaprootAssets_NewAddr_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "addrs"}, "")) + pattern_TaprootAssets_DecodeAddr_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "addrs", "decode"}, "")) + pattern_TaprootAssets_AddrReceives_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "addrs", "receives"}, "")) + pattern_TaprootAssets_VerifyProof_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "proofs", "verify"}, "")) + pattern_TaprootAssets_DecodeProof_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "proofs", "decode"}, "")) + pattern_TaprootAssets_ExportProof_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "proofs", "export"}, "")) + pattern_TaprootAssets_UnpackProofFile_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "proofs", "unpack-file"}, "")) + pattern_TaprootAssets_SendAsset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "send"}, "")) + pattern_TaprootAssets_BurnAsset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "burn"}, "")) + pattern_TaprootAssets_ListBurns_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "burns"}, "")) + pattern_TaprootAssets_GetInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "taproot-assets", "getinfo"}, "")) + pattern_TaprootAssets_FetchAssetMeta_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "assets", "meta", "asset-id", "asset_id_str"}, "")) + pattern_TaprootAssets_FetchAssetMeta_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"v1", "taproot-assets", "assets", "meta", "hash", "meta_hash_str"}, "")) pattern_TaprootAssets_SubscribeReceiveEvents_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "events", "asset-receive"}, "")) - - pattern_TaprootAssets_SubscribeSendEvents_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "events", "asset-send"}, "")) - - pattern_TaprootAssets_RegisterTransfer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "assets", "transfers", "register"}, "")) + pattern_TaprootAssets_SubscribeSendEvents_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "taproot-assets", "events", "asset-send"}, "")) + pattern_TaprootAssets_RegisterTransfer_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"v1", "taproot-assets", "assets", "transfers", "register"}, "")) ) var ( - forward_TaprootAssets_ListAssets_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_ListUtxos_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_ListGroups_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_ListBalances_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_ListTransfers_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_ListTransfers_1 = runtime.ForwardResponseMessage - - forward_TaprootAssets_StopDaemon_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_DebugLevel_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_QueryAddrs_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_NewAddr_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_DecodeAddr_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_AddrReceives_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_VerifyProof_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_DecodeProof_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_ExportProof_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_UnpackProofFile_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_SendAsset_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_BurnAsset_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_ListBurns_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_GetInfo_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_FetchAssetMeta_0 = runtime.ForwardResponseMessage - - forward_TaprootAssets_FetchAssetMeta_1 = runtime.ForwardResponseMessage - + forward_TaprootAssets_ListAssets_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_ListUtxos_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_ListGroups_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_ListBalances_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_ListTransfers_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_ListTransfers_1 = runtime.ForwardResponseMessage + forward_TaprootAssets_StopDaemon_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_DebugLevel_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_QueryAddrs_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_NewAddr_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_DecodeAddr_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_AddrReceives_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_VerifyProof_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_DecodeProof_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_ExportProof_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_UnpackProofFile_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_SendAsset_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_BurnAsset_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_ListBurns_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_GetInfo_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_FetchAssetMeta_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_FetchAssetMeta_1 = runtime.ForwardResponseMessage forward_TaprootAssets_SubscribeReceiveEvents_0 = runtime.ForwardResponseStream - - forward_TaprootAssets_SubscribeSendEvents_0 = runtime.ForwardResponseStream - - forward_TaprootAssets_RegisterTransfer_0 = runtime.ForwardResponseMessage + forward_TaprootAssets_SubscribeSendEvents_0 = runtime.ForwardResponseStream + forward_TaprootAssets_RegisterTransfer_0 = runtime.ForwardResponseMessage ) diff --git a/taprpc/taprootassets.proto b/taprpc/taprootassets.proto index 8cb63f84a..d4b2796f3 100644 --- a/taprpc/taprootassets.proto +++ b/taprpc/taprootassets.proto @@ -127,7 +127,7 @@ service TaprootAssets { 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. */ - rpc FetchAssetMeta (FetchAssetMetaRequest) returns (AssetMeta); + rpc FetchAssetMeta (FetchAssetMetaRequest) returns (FetchAssetMetaResponse); /* tapcli: `events receive` SubscribeReceiveEvents allows a caller to subscribe to receive events for @@ -1417,9 +1417,24 @@ message FetchAssetMetaRequest { // The hex encoded meta hash of the asset meta. string meta_hash_str = 4; + + // The group key of the assets to fetch the meta for. + bytes group_key = 5; + + // The hex encoded group key of the assets to fetch the meta for. + string group_key_str = 6; } } +message FetchAssetMetaResponse { + // The list of asset metadata objects. + repeated AssetMeta asset_metas = 1; + + // The number of base 10 digits to the right of the decimal point to + // display the asset amount. This is the same for all assets in a group. + int32 decimal_display = 2; +} + message BurnAssetRequest { oneof asset { // The asset ID of the asset to burn units of. diff --git a/taprpc/taprootassets.swagger.json b/taprpc/taprootassets.swagger.json index 8f4c1050c..feb270c46 100644 --- a/taprpc/taprootassets.swagger.json +++ b/taprpc/taprootassets.swagger.json @@ -455,7 +455,7 @@ "200": { "description": "A successful response.", "schema": { - "$ref": "#/definitions/taprpcAssetMeta" + "$ref": "#/definitions/taprpcFetchAssetMetaResponse" } }, "default": { @@ -495,6 +495,21 @@ "in": "query", "required": false, "type": "string" + }, + { + "name": "group_key", + "description": "The group key of the assets to fetch the meta for.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "group_key_str", + "description": "The hex encoded group key of the assets to fetch the meta for.", + "in": "query", + "required": false, + "type": "string" } ], "tags": [ @@ -510,7 +525,7 @@ "200": { "description": "A successful response.", "schema": { - "$ref": "#/definitions/taprpcAssetMeta" + "$ref": "#/definitions/taprpcFetchAssetMetaResponse" } }, "default": { @@ -550,6 +565,21 @@ "in": "query", "required": false, "type": "string" + }, + { + "name": "group_key", + "description": "The group key of the assets to fetch the meta for.", + "in": "query", + "required": false, + "type": "string", + "format": "byte" + }, + { + "name": "group_key_str", + "description": "The hex encoded group key of the assets to fetch the meta for.", + "in": "query", + "required": false, + "type": "string" } ], "tags": [ @@ -1919,6 +1949,24 @@ } } }, + "taprpcFetchAssetMetaResponse": { + "type": "object", + "properties": { + "asset_metas": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/taprpcAssetMeta" + }, + "description": "The list of asset metadata objects." + }, + "decimal_display": { + "type": "integer", + "format": "int32", + "description": "The number of base 10 digits to the right of the decimal point to\ndisplay the asset amount. This is the same for all assets in a group." + } + } + }, "taprpcGenesisInfo": { "type": "object", "properties": { diff --git a/taprpc/taprootassets_grpc.pb.go b/taprpc/taprootassets_grpc.pb.go index e796ff597..86628b114 100644 --- a/taprpc/taprootassets_grpc.pb.go +++ b/taprpc/taprootassets_grpc.pb.go @@ -1,4 +1,8 @@ // Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.5.1 +// - protoc v3.21.12 +// source: taprootassets.proto package taprpc @@ -11,8 +15,34 @@ import ( // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -// Requires gRPC-Go v1.32.0 or later. -const _ = grpc.SupportPackageIsVersion7 +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + TaprootAssets_ListAssets_FullMethodName = "/taprpc.TaprootAssets/ListAssets" + TaprootAssets_ListUtxos_FullMethodName = "/taprpc.TaprootAssets/ListUtxos" + TaprootAssets_ListGroups_FullMethodName = "/taprpc.TaprootAssets/ListGroups" + TaprootAssets_ListBalances_FullMethodName = "/taprpc.TaprootAssets/ListBalances" + TaprootAssets_ListTransfers_FullMethodName = "/taprpc.TaprootAssets/ListTransfers" + TaprootAssets_StopDaemon_FullMethodName = "/taprpc.TaprootAssets/StopDaemon" + TaprootAssets_DebugLevel_FullMethodName = "/taprpc.TaprootAssets/DebugLevel" + TaprootAssets_QueryAddrs_FullMethodName = "/taprpc.TaprootAssets/QueryAddrs" + TaprootAssets_NewAddr_FullMethodName = "/taprpc.TaprootAssets/NewAddr" + TaprootAssets_DecodeAddr_FullMethodName = "/taprpc.TaprootAssets/DecodeAddr" + TaprootAssets_AddrReceives_FullMethodName = "/taprpc.TaprootAssets/AddrReceives" + TaprootAssets_VerifyProof_FullMethodName = "/taprpc.TaprootAssets/VerifyProof" + TaprootAssets_DecodeProof_FullMethodName = "/taprpc.TaprootAssets/DecodeProof" + TaprootAssets_ExportProof_FullMethodName = "/taprpc.TaprootAssets/ExportProof" + TaprootAssets_UnpackProofFile_FullMethodName = "/taprpc.TaprootAssets/UnpackProofFile" + TaprootAssets_SendAsset_FullMethodName = "/taprpc.TaprootAssets/SendAsset" + TaprootAssets_BurnAsset_FullMethodName = "/taprpc.TaprootAssets/BurnAsset" + TaprootAssets_ListBurns_FullMethodName = "/taprpc.TaprootAssets/ListBurns" + TaprootAssets_GetInfo_FullMethodName = "/taprpc.TaprootAssets/GetInfo" + TaprootAssets_FetchAssetMeta_FullMethodName = "/taprpc.TaprootAssets/FetchAssetMeta" + TaprootAssets_SubscribeReceiveEvents_FullMethodName = "/taprpc.TaprootAssets/SubscribeReceiveEvents" + TaprootAssets_SubscribeSendEvents_FullMethodName = "/taprpc.TaprootAssets/SubscribeSendEvents" + TaprootAssets_RegisterTransfer_FullMethodName = "/taprpc.TaprootAssets/RegisterTransfer" +) // TaprootAssetsClient is the client API for TaprootAssets service. // @@ -100,15 +130,15 @@ type TaprootAssetsClient interface { // tapcli: `assets meta` // 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. - FetchAssetMeta(ctx context.Context, in *FetchAssetMetaRequest, opts ...grpc.CallOption) (*AssetMeta, error) + FetchAssetMeta(ctx context.Context, in *FetchAssetMetaRequest, opts ...grpc.CallOption) (*FetchAssetMetaResponse, error) // tapcli: `events receive` // SubscribeReceiveEvents allows a caller to subscribe to receive events for // incoming asset transfers. - SubscribeReceiveEvents(ctx context.Context, in *SubscribeReceiveEventsRequest, opts ...grpc.CallOption) (TaprootAssets_SubscribeReceiveEventsClient, error) + SubscribeReceiveEvents(ctx context.Context, in *SubscribeReceiveEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ReceiveEvent], error) // tapcli: `events send` // SubscribeSendEvents allows a caller to subscribe to send events for outgoing // asset transfers. - SubscribeSendEvents(ctx context.Context, in *SubscribeSendEventsRequest, opts ...grpc.CallOption) (TaprootAssets_SubscribeSendEventsClient, error) + SubscribeSendEvents(ctx context.Context, in *SubscribeSendEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SendEvent], error) // RegisterTransfer informs the daemon about a new inbound transfer that has // happened. This is used for interactive transfers where no TAP address is // involved and the recipient is aware of the transfer through an out-of-band @@ -129,8 +159,9 @@ func NewTaprootAssetsClient(cc grpc.ClientConnInterface) TaprootAssetsClient { } func (c *taprootAssetsClient) ListAssets(ctx context.Context, in *ListAssetRequest, opts ...grpc.CallOption) (*ListAssetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ListAssetResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/ListAssets", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_ListAssets_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -138,8 +169,9 @@ func (c *taprootAssetsClient) ListAssets(ctx context.Context, in *ListAssetReque } func (c *taprootAssetsClient) ListUtxos(ctx context.Context, in *ListUtxosRequest, opts ...grpc.CallOption) (*ListUtxosResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ListUtxosResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/ListUtxos", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_ListUtxos_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -147,8 +179,9 @@ func (c *taprootAssetsClient) ListUtxos(ctx context.Context, in *ListUtxosReques } func (c *taprootAssetsClient) ListGroups(ctx context.Context, in *ListGroupsRequest, opts ...grpc.CallOption) (*ListGroupsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ListGroupsResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/ListGroups", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_ListGroups_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -156,8 +189,9 @@ func (c *taprootAssetsClient) ListGroups(ctx context.Context, in *ListGroupsRequ } func (c *taprootAssetsClient) ListBalances(ctx context.Context, in *ListBalancesRequest, opts ...grpc.CallOption) (*ListBalancesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ListBalancesResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/ListBalances", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_ListBalances_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -165,8 +199,9 @@ func (c *taprootAssetsClient) ListBalances(ctx context.Context, in *ListBalances } func (c *taprootAssetsClient) ListTransfers(ctx context.Context, in *ListTransfersRequest, opts ...grpc.CallOption) (*ListTransfersResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ListTransfersResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/ListTransfers", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_ListTransfers_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -174,8 +209,9 @@ func (c *taprootAssetsClient) ListTransfers(ctx context.Context, in *ListTransfe } func (c *taprootAssetsClient) StopDaemon(ctx context.Context, in *StopRequest, opts ...grpc.CallOption) (*StopResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(StopResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/StopDaemon", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_StopDaemon_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -183,8 +219,9 @@ func (c *taprootAssetsClient) StopDaemon(ctx context.Context, in *StopRequest, o } func (c *taprootAssetsClient) DebugLevel(ctx context.Context, in *DebugLevelRequest, opts ...grpc.CallOption) (*DebugLevelResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(DebugLevelResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/DebugLevel", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_DebugLevel_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -192,8 +229,9 @@ func (c *taprootAssetsClient) DebugLevel(ctx context.Context, in *DebugLevelRequ } func (c *taprootAssetsClient) QueryAddrs(ctx context.Context, in *QueryAddrRequest, opts ...grpc.CallOption) (*QueryAddrResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(QueryAddrResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/QueryAddrs", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_QueryAddrs_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -201,8 +239,9 @@ func (c *taprootAssetsClient) QueryAddrs(ctx context.Context, in *QueryAddrReque } func (c *taprootAssetsClient) NewAddr(ctx context.Context, in *NewAddrRequest, opts ...grpc.CallOption) (*Addr, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(Addr) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/NewAddr", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_NewAddr_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -210,8 +249,9 @@ func (c *taprootAssetsClient) NewAddr(ctx context.Context, in *NewAddrRequest, o } func (c *taprootAssetsClient) DecodeAddr(ctx context.Context, in *DecodeAddrRequest, opts ...grpc.CallOption) (*Addr, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(Addr) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/DecodeAddr", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_DecodeAddr_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -219,8 +259,9 @@ func (c *taprootAssetsClient) DecodeAddr(ctx context.Context, in *DecodeAddrRequ } func (c *taprootAssetsClient) AddrReceives(ctx context.Context, in *AddrReceivesRequest, opts ...grpc.CallOption) (*AddrReceivesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(AddrReceivesResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/AddrReceives", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_AddrReceives_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -228,8 +269,9 @@ func (c *taprootAssetsClient) AddrReceives(ctx context.Context, in *AddrReceives } func (c *taprootAssetsClient) VerifyProof(ctx context.Context, in *ProofFile, opts ...grpc.CallOption) (*VerifyProofResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(VerifyProofResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/VerifyProof", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_VerifyProof_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -237,8 +279,9 @@ func (c *taprootAssetsClient) VerifyProof(ctx context.Context, in *ProofFile, op } func (c *taprootAssetsClient) DecodeProof(ctx context.Context, in *DecodeProofRequest, opts ...grpc.CallOption) (*DecodeProofResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(DecodeProofResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/DecodeProof", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_DecodeProof_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -246,8 +289,9 @@ func (c *taprootAssetsClient) DecodeProof(ctx context.Context, in *DecodeProofRe } func (c *taprootAssetsClient) ExportProof(ctx context.Context, in *ExportProofRequest, opts ...grpc.CallOption) (*ProofFile, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ProofFile) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/ExportProof", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_ExportProof_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -255,8 +299,9 @@ func (c *taprootAssetsClient) ExportProof(ctx context.Context, in *ExportProofRe } func (c *taprootAssetsClient) UnpackProofFile(ctx context.Context, in *UnpackProofFileRequest, opts ...grpc.CallOption) (*UnpackProofFileResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(UnpackProofFileResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/UnpackProofFile", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_UnpackProofFile_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -264,8 +309,9 @@ func (c *taprootAssetsClient) UnpackProofFile(ctx context.Context, in *UnpackPro } func (c *taprootAssetsClient) SendAsset(ctx context.Context, in *SendAssetRequest, opts ...grpc.CallOption) (*SendAssetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(SendAssetResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/SendAsset", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_SendAsset_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -273,8 +319,9 @@ func (c *taprootAssetsClient) SendAsset(ctx context.Context, in *SendAssetReques } func (c *taprootAssetsClient) BurnAsset(ctx context.Context, in *BurnAssetRequest, opts ...grpc.CallOption) (*BurnAssetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(BurnAssetResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/BurnAsset", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_BurnAsset_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -282,8 +329,9 @@ func (c *taprootAssetsClient) BurnAsset(ctx context.Context, in *BurnAssetReques } func (c *taprootAssetsClient) ListBurns(ctx context.Context, in *ListBurnsRequest, opts ...grpc.CallOption) (*ListBurnsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ListBurnsResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/ListBurns", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_ListBurns_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -291,29 +339,32 @@ func (c *taprootAssetsClient) ListBurns(ctx context.Context, in *ListBurnsReques } func (c *taprootAssetsClient) GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(GetInfoResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/GetInfo", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_GetInfo_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *taprootAssetsClient) FetchAssetMeta(ctx context.Context, in *FetchAssetMetaRequest, opts ...grpc.CallOption) (*AssetMeta, error) { - out := new(AssetMeta) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/FetchAssetMeta", in, out, opts...) +func (c *taprootAssetsClient) FetchAssetMeta(ctx context.Context, in *FetchAssetMetaRequest, opts ...grpc.CallOption) (*FetchAssetMetaResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(FetchAssetMetaResponse) + err := c.cc.Invoke(ctx, TaprootAssets_FetchAssetMeta_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } return out, nil } -func (c *taprootAssetsClient) SubscribeReceiveEvents(ctx context.Context, in *SubscribeReceiveEventsRequest, opts ...grpc.CallOption) (TaprootAssets_SubscribeReceiveEventsClient, error) { - stream, err := c.cc.NewStream(ctx, &TaprootAssets_ServiceDesc.Streams[0], "/taprpc.TaprootAssets/SubscribeReceiveEvents", opts...) +func (c *taprootAssetsClient) SubscribeReceiveEvents(ctx context.Context, in *SubscribeReceiveEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ReceiveEvent], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &TaprootAssets_ServiceDesc.Streams[0], TaprootAssets_SubscribeReceiveEvents_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &taprootAssetsSubscribeReceiveEventsClient{stream} + x := &grpc.GenericClientStream[SubscribeReceiveEventsRequest, ReceiveEvent]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -323,29 +374,16 @@ func (c *taprootAssetsClient) SubscribeReceiveEvents(ctx context.Context, in *Su return x, nil } -type TaprootAssets_SubscribeReceiveEventsClient interface { - Recv() (*ReceiveEvent, error) - grpc.ClientStream -} - -type taprootAssetsSubscribeReceiveEventsClient struct { - grpc.ClientStream -} - -func (x *taprootAssetsSubscribeReceiveEventsClient) Recv() (*ReceiveEvent, error) { - m := new(ReceiveEvent) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type TaprootAssets_SubscribeReceiveEventsClient = grpc.ServerStreamingClient[ReceiveEvent] -func (c *taprootAssetsClient) SubscribeSendEvents(ctx context.Context, in *SubscribeSendEventsRequest, opts ...grpc.CallOption) (TaprootAssets_SubscribeSendEventsClient, error) { - stream, err := c.cc.NewStream(ctx, &TaprootAssets_ServiceDesc.Streams[1], "/taprpc.TaprootAssets/SubscribeSendEvents", opts...) +func (c *taprootAssetsClient) SubscribeSendEvents(ctx context.Context, in *SubscribeSendEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[SendEvent], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &TaprootAssets_ServiceDesc.Streams[1], TaprootAssets_SubscribeSendEvents_FullMethodName, cOpts...) if err != nil { return nil, err } - x := &taprootAssetsSubscribeSendEventsClient{stream} + x := &grpc.GenericClientStream[SubscribeSendEventsRequest, SendEvent]{ClientStream: stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } @@ -355,26 +393,13 @@ func (c *taprootAssetsClient) SubscribeSendEvents(ctx context.Context, in *Subsc return x, nil } -type TaprootAssets_SubscribeSendEventsClient interface { - Recv() (*SendEvent, error) - grpc.ClientStream -} - -type taprootAssetsSubscribeSendEventsClient struct { - grpc.ClientStream -} - -func (x *taprootAssetsSubscribeSendEventsClient) Recv() (*SendEvent, error) { - m := new(SendEvent) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type TaprootAssets_SubscribeSendEventsClient = grpc.ServerStreamingClient[SendEvent] func (c *taprootAssetsClient) RegisterTransfer(ctx context.Context, in *RegisterTransferRequest, opts ...grpc.CallOption) (*RegisterTransferResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(RegisterTransferResponse) - err := c.cc.Invoke(ctx, "/taprpc.TaprootAssets/RegisterTransfer", in, out, opts...) + err := c.cc.Invoke(ctx, TaprootAssets_RegisterTransfer_FullMethodName, in, out, cOpts...) if err != nil { return nil, err } @@ -383,7 +408,7 @@ func (c *taprootAssetsClient) RegisterTransfer(ctx context.Context, in *Register // TaprootAssetsServer is the server API for TaprootAssets service. // All implementations must embed UnimplementedTaprootAssetsServer -// for forward compatibility +// for forward compatibility. type TaprootAssetsServer interface { // tapcli: `assets list` // ListAssets lists the set of assets owned by the target daemon. @@ -467,15 +492,15 @@ type TaprootAssetsServer interface { // tapcli: `assets meta` // 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. - FetchAssetMeta(context.Context, *FetchAssetMetaRequest) (*AssetMeta, error) + FetchAssetMeta(context.Context, *FetchAssetMetaRequest) (*FetchAssetMetaResponse, error) // tapcli: `events receive` // SubscribeReceiveEvents allows a caller to subscribe to receive events for // incoming asset transfers. - SubscribeReceiveEvents(*SubscribeReceiveEventsRequest, TaprootAssets_SubscribeReceiveEventsServer) error + SubscribeReceiveEvents(*SubscribeReceiveEventsRequest, grpc.ServerStreamingServer[ReceiveEvent]) error // tapcli: `events send` // SubscribeSendEvents allows a caller to subscribe to send events for outgoing // asset transfers. - SubscribeSendEvents(*SubscribeSendEventsRequest, TaprootAssets_SubscribeSendEventsServer) error + SubscribeSendEvents(*SubscribeSendEventsRequest, grpc.ServerStreamingServer[SendEvent]) error // RegisterTransfer informs the daemon about a new inbound transfer that has // happened. This is used for interactive transfers where no TAP address is // involved and the recipient is aware of the transfer through an out-of-band @@ -488,9 +513,12 @@ type TaprootAssetsServer interface { mustEmbedUnimplementedTaprootAssetsServer() } -// UnimplementedTaprootAssetsServer must be embedded to have forward compatible implementations. -type UnimplementedTaprootAssetsServer struct { -} +// UnimplementedTaprootAssetsServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedTaprootAssetsServer struct{} func (UnimplementedTaprootAssetsServer) ListAssets(context.Context, *ListAssetRequest) (*ListAssetResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListAssets not implemented") @@ -549,19 +577,20 @@ func (UnimplementedTaprootAssetsServer) ListBurns(context.Context, *ListBurnsReq func (UnimplementedTaprootAssetsServer) GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetInfo not implemented") } -func (UnimplementedTaprootAssetsServer) FetchAssetMeta(context.Context, *FetchAssetMetaRequest) (*AssetMeta, error) { +func (UnimplementedTaprootAssetsServer) FetchAssetMeta(context.Context, *FetchAssetMetaRequest) (*FetchAssetMetaResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method FetchAssetMeta not implemented") } -func (UnimplementedTaprootAssetsServer) SubscribeReceiveEvents(*SubscribeReceiveEventsRequest, TaprootAssets_SubscribeReceiveEventsServer) error { +func (UnimplementedTaprootAssetsServer) SubscribeReceiveEvents(*SubscribeReceiveEventsRequest, grpc.ServerStreamingServer[ReceiveEvent]) error { return status.Errorf(codes.Unimplemented, "method SubscribeReceiveEvents not implemented") } -func (UnimplementedTaprootAssetsServer) SubscribeSendEvents(*SubscribeSendEventsRequest, TaprootAssets_SubscribeSendEventsServer) error { +func (UnimplementedTaprootAssetsServer) SubscribeSendEvents(*SubscribeSendEventsRequest, grpc.ServerStreamingServer[SendEvent]) error { return status.Errorf(codes.Unimplemented, "method SubscribeSendEvents not implemented") } func (UnimplementedTaprootAssetsServer) RegisterTransfer(context.Context, *RegisterTransferRequest) (*RegisterTransferResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RegisterTransfer not implemented") } func (UnimplementedTaprootAssetsServer) mustEmbedUnimplementedTaprootAssetsServer() {} +func (UnimplementedTaprootAssetsServer) testEmbeddedByValue() {} // UnsafeTaprootAssetsServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to TaprootAssetsServer will @@ -571,6 +600,13 @@ type UnsafeTaprootAssetsServer interface { } func RegisterTaprootAssetsServer(s grpc.ServiceRegistrar, srv TaprootAssetsServer) { + // If the following call pancis, it indicates UnimplementedTaprootAssetsServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } s.RegisterService(&TaprootAssets_ServiceDesc, srv) } @@ -584,7 +620,7 @@ func _TaprootAssets_ListAssets_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/ListAssets", + FullMethod: TaprootAssets_ListAssets_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).ListAssets(ctx, req.(*ListAssetRequest)) @@ -602,7 +638,7 @@ func _TaprootAssets_ListUtxos_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/ListUtxos", + FullMethod: TaprootAssets_ListUtxos_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).ListUtxos(ctx, req.(*ListUtxosRequest)) @@ -620,7 +656,7 @@ func _TaprootAssets_ListGroups_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/ListGroups", + FullMethod: TaprootAssets_ListGroups_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).ListGroups(ctx, req.(*ListGroupsRequest)) @@ -638,7 +674,7 @@ func _TaprootAssets_ListBalances_Handler(srv interface{}, ctx context.Context, d } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/ListBalances", + FullMethod: TaprootAssets_ListBalances_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).ListBalances(ctx, req.(*ListBalancesRequest)) @@ -656,7 +692,7 @@ func _TaprootAssets_ListTransfers_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/ListTransfers", + FullMethod: TaprootAssets_ListTransfers_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).ListTransfers(ctx, req.(*ListTransfersRequest)) @@ -674,7 +710,7 @@ func _TaprootAssets_StopDaemon_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/StopDaemon", + FullMethod: TaprootAssets_StopDaemon_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).StopDaemon(ctx, req.(*StopRequest)) @@ -692,7 +728,7 @@ func _TaprootAssets_DebugLevel_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/DebugLevel", + FullMethod: TaprootAssets_DebugLevel_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).DebugLevel(ctx, req.(*DebugLevelRequest)) @@ -710,7 +746,7 @@ func _TaprootAssets_QueryAddrs_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/QueryAddrs", + FullMethod: TaprootAssets_QueryAddrs_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).QueryAddrs(ctx, req.(*QueryAddrRequest)) @@ -728,7 +764,7 @@ func _TaprootAssets_NewAddr_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/NewAddr", + FullMethod: TaprootAssets_NewAddr_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).NewAddr(ctx, req.(*NewAddrRequest)) @@ -746,7 +782,7 @@ func _TaprootAssets_DecodeAddr_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/DecodeAddr", + FullMethod: TaprootAssets_DecodeAddr_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).DecodeAddr(ctx, req.(*DecodeAddrRequest)) @@ -764,7 +800,7 @@ func _TaprootAssets_AddrReceives_Handler(srv interface{}, ctx context.Context, d } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/AddrReceives", + FullMethod: TaprootAssets_AddrReceives_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).AddrReceives(ctx, req.(*AddrReceivesRequest)) @@ -782,7 +818,7 @@ func _TaprootAssets_VerifyProof_Handler(srv interface{}, ctx context.Context, de } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/VerifyProof", + FullMethod: TaprootAssets_VerifyProof_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).VerifyProof(ctx, req.(*ProofFile)) @@ -800,7 +836,7 @@ func _TaprootAssets_DecodeProof_Handler(srv interface{}, ctx context.Context, de } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/DecodeProof", + FullMethod: TaprootAssets_DecodeProof_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).DecodeProof(ctx, req.(*DecodeProofRequest)) @@ -818,7 +854,7 @@ func _TaprootAssets_ExportProof_Handler(srv interface{}, ctx context.Context, de } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/ExportProof", + FullMethod: TaprootAssets_ExportProof_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).ExportProof(ctx, req.(*ExportProofRequest)) @@ -836,7 +872,7 @@ func _TaprootAssets_UnpackProofFile_Handler(srv interface{}, ctx context.Context } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/UnpackProofFile", + FullMethod: TaprootAssets_UnpackProofFile_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).UnpackProofFile(ctx, req.(*UnpackProofFileRequest)) @@ -854,7 +890,7 @@ func _TaprootAssets_SendAsset_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/SendAsset", + FullMethod: TaprootAssets_SendAsset_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).SendAsset(ctx, req.(*SendAssetRequest)) @@ -872,7 +908,7 @@ func _TaprootAssets_BurnAsset_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/BurnAsset", + FullMethod: TaprootAssets_BurnAsset_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).BurnAsset(ctx, req.(*BurnAssetRequest)) @@ -890,7 +926,7 @@ func _TaprootAssets_ListBurns_Handler(srv interface{}, ctx context.Context, dec } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/ListBurns", + FullMethod: TaprootAssets_ListBurns_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).ListBurns(ctx, req.(*ListBurnsRequest)) @@ -908,7 +944,7 @@ func _TaprootAssets_GetInfo_Handler(srv interface{}, ctx context.Context, dec fu } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/GetInfo", + FullMethod: TaprootAssets_GetInfo_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).GetInfo(ctx, req.(*GetInfoRequest)) @@ -926,7 +962,7 @@ func _TaprootAssets_FetchAssetMeta_Handler(srv interface{}, ctx context.Context, } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/FetchAssetMeta", + FullMethod: TaprootAssets_FetchAssetMeta_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).FetchAssetMeta(ctx, req.(*FetchAssetMetaRequest)) @@ -939,42 +975,22 @@ func _TaprootAssets_SubscribeReceiveEvents_Handler(srv interface{}, stream grpc. if err := stream.RecvMsg(m); err != nil { return err } - return srv.(TaprootAssetsServer).SubscribeReceiveEvents(m, &taprootAssetsSubscribeReceiveEventsServer{stream}) -} - -type TaprootAssets_SubscribeReceiveEventsServer interface { - Send(*ReceiveEvent) error - grpc.ServerStream -} - -type taprootAssetsSubscribeReceiveEventsServer struct { - grpc.ServerStream + return srv.(TaprootAssetsServer).SubscribeReceiveEvents(m, &grpc.GenericServerStream[SubscribeReceiveEventsRequest, ReceiveEvent]{ServerStream: stream}) } -func (x *taprootAssetsSubscribeReceiveEventsServer) Send(m *ReceiveEvent) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type TaprootAssets_SubscribeReceiveEventsServer = grpc.ServerStreamingServer[ReceiveEvent] func _TaprootAssets_SubscribeSendEvents_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(SubscribeSendEventsRequest) if err := stream.RecvMsg(m); err != nil { return err } - return srv.(TaprootAssetsServer).SubscribeSendEvents(m, &taprootAssetsSubscribeSendEventsServer{stream}) -} - -type TaprootAssets_SubscribeSendEventsServer interface { - Send(*SendEvent) error - grpc.ServerStream + return srv.(TaprootAssetsServer).SubscribeSendEvents(m, &grpc.GenericServerStream[SubscribeSendEventsRequest, SendEvent]{ServerStream: stream}) } -type taprootAssetsSubscribeSendEventsServer struct { - grpc.ServerStream -} - -func (x *taprootAssetsSubscribeSendEventsServer) Send(m *SendEvent) error { - return x.ServerStream.SendMsg(m) -} +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type TaprootAssets_SubscribeSendEventsServer = grpc.ServerStreamingServer[SendEvent] func _TaprootAssets_RegisterTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RegisterTransferRequest) @@ -986,7 +1002,7 @@ func _TaprootAssets_RegisterTransfer_Handler(srv interface{}, ctx context.Contex } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/taprpc.TaprootAssets/RegisterTransfer", + FullMethod: TaprootAssets_RegisterTransfer_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(TaprootAssetsServer).RegisterTransfer(ctx, req.(*RegisterTransferRequest)) diff --git a/taprpc/universerpc/universe.pb.go b/taprpc/universerpc/universe.pb.go index 9389b90e4..cda2b0043 100644 --- a/taprpc/universerpc/universe.pb.go +++ b/taprpc/universerpc/universe.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.34.2 +// protoc-gen-go v1.36.6 // protoc v3.21.12 // source: universerpc/universe.proto @@ -12,6 +12,7 @@ import ( protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + unsafe "unsafe" ) const ( @@ -280,26 +281,23 @@ func (AssetTypeFilter) EnumDescriptor() ([]byte, []int) { } type MultiverseRootRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The proof type to calculate the multiverse root for. ProofType ProofType `protobuf:"varint,1,opt,name=proof_type,json=proofType,proto3,enum=universerpc.ProofType" json:"proof_type,omitempty"` // An optional list of universe IDs to include in the multiverse root. If // none are specified, then all known universes of the given proof type are // included. NOTE: The proof type within the IDs must either be unspecified // or match the proof type above. - SpecificIds []*ID `protobuf:"bytes,2,rep,name=specific_ids,json=specificIds,proto3" json:"specific_ids,omitempty"` + SpecificIds []*ID `protobuf:"bytes,2,rep,name=specific_ids,json=specificIds,proto3" json:"specific_ids,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MultiverseRootRequest) Reset() { *x = MultiverseRootRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *MultiverseRootRequest) String() string { @@ -310,7 +308,7 @@ func (*MultiverseRootRequest) ProtoMessage() {} func (x *MultiverseRootRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[0] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -340,21 +338,18 @@ func (x *MultiverseRootRequest) GetSpecificIds() []*ID { } type MultiverseRootResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The root of the multiverse tree. MultiverseRoot *MerkleSumNode `protobuf:"bytes,1,opt,name=multiverse_root,json=multiverseRoot,proto3" json:"multiverse_root,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MultiverseRootResponse) Reset() { *x = MultiverseRootResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *MultiverseRootResponse) String() string { @@ -365,7 +360,7 @@ func (*MultiverseRootResponse) ProtoMessage() {} func (x *MultiverseRootResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[1] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -388,10 +383,7 @@ func (x *MultiverseRootResponse) GetMultiverseRoot() *MerkleSumNode { } type AssetRootRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // If true, then the response will include the amounts for each asset ID // of grouped assets. WithAmountsById bool `protobuf:"varint,1,opt,name=with_amounts_by_id,json=withAmountsById,proto3" json:"with_amounts_by_id,omitempty"` @@ -400,16 +392,16 @@ type AssetRootRequest struct { // The length limit for the page. Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` // The direction of the page. - Direction SortDirection `protobuf:"varint,4,opt,name=direction,proto3,enum=universerpc.SortDirection" json:"direction,omitempty"` + Direction SortDirection `protobuf:"varint,4,opt,name=direction,proto3,enum=universerpc.SortDirection" json:"direction,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetRootRequest) Reset() { *x = AssetRootRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[2] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetRootRequest) String() string { @@ -420,7 +412,7 @@ func (*AssetRootRequest) ProtoMessage() {} func (x *AssetRootRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[2] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -464,25 +456,22 @@ func (x *AssetRootRequest) GetDirection() SortDirection { } type MerkleSumNode struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The MS-SMT root hash for the branch node. RootHash []byte `protobuf:"bytes,1,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"` // The root sum of the branch node. This is hashed to create the root_hash // along with the left and right siblings. This value represents the total // known supply of the asset. - RootSum int64 `protobuf:"varint,2,opt,name=root_sum,json=rootSum,proto3" json:"root_sum,omitempty"` + RootSum int64 `protobuf:"varint,2,opt,name=root_sum,json=rootSum,proto3" json:"root_sum,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *MerkleSumNode) Reset() { *x = MerkleSumNode{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[3] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *MerkleSumNode) String() string { @@ -493,7 +482,7 @@ func (*MerkleSumNode) ProtoMessage() {} func (x *MerkleSumNode) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[3] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -523,27 +512,24 @@ func (x *MerkleSumNode) GetRootSum() int64 { } type ID struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Types that are assignable to Id: + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Id: // // *ID_AssetId // *ID_AssetIdStr // *ID_GroupKey // *ID_GroupKeyStr - Id isID_Id `protobuf_oneof:"id"` - ProofType ProofType `protobuf:"varint,5,opt,name=proof_type,json=proofType,proto3,enum=universerpc.ProofType" json:"proof_type,omitempty"` + Id isID_Id `protobuf_oneof:"id"` + ProofType ProofType `protobuf:"varint,5,opt,name=proof_type,json=proofType,proto3,enum=universerpc.ProofType" json:"proof_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *ID) Reset() { *x = ID{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[4] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *ID) String() string { @@ -554,7 +540,7 @@ func (*ID) ProtoMessage() {} func (x *ID) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[4] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -569,37 +555,45 @@ func (*ID) Descriptor() ([]byte, []int) { return file_universerpc_universe_proto_rawDescGZIP(), []int{4} } -func (m *ID) GetId() isID_Id { - if m != nil { - return m.Id +func (x *ID) GetId() isID_Id { + if x != nil { + return x.Id } return nil } func (x *ID) GetAssetId() []byte { - if x, ok := x.GetId().(*ID_AssetId); ok { - return x.AssetId + if x != nil { + if x, ok := x.Id.(*ID_AssetId); ok { + return x.AssetId + } } return nil } func (x *ID) GetAssetIdStr() string { - if x, ok := x.GetId().(*ID_AssetIdStr); ok { - return x.AssetIdStr + if x != nil { + if x, ok := x.Id.(*ID_AssetIdStr); ok { + return x.AssetIdStr + } } return "" } func (x *ID) GetGroupKey() []byte { - if x, ok := x.GetId().(*ID_GroupKey); ok { - return x.GroupKey + if x != nil { + if x, ok := x.Id.(*ID_GroupKey); ok { + return x.GroupKey + } } return nil } func (x *ID) GetGroupKeyStr() string { - if x, ok := x.GetId().(*ID_GroupKeyStr); ok { - return x.GroupKeyStr + if x != nil { + if x, ok := x.Id.(*ID_GroupKeyStr); ok { + return x.GroupKeyStr + } } return "" } @@ -645,11 +639,8 @@ func (*ID_GroupKey) isID_Id() {} func (*ID_GroupKeyStr) isID_Id() {} type UniverseRoot struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // The merkle sum sparse merkle tree root associated with the above // universe ID. MssmtRoot *MerkleSumNode `protobuf:"bytes,3,opt,name=mssmt_root,json=mssmtRoot,proto3" json:"mssmt_root,omitempty"` @@ -662,16 +653,16 @@ type UniverseRoot struct { // asset ID above and the sum in the mssmt_root. A hex encoded string is // used as the map key because gRPC does not support using raw bytes for a // map key. - AmountsByAssetId map[string]uint64 `protobuf:"bytes,5,rep,name=amounts_by_asset_id,json=amountsByAssetId,proto3" json:"amounts_by_asset_id,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + AmountsByAssetId map[string]uint64 `protobuf:"bytes,5,rep,name=amounts_by_asset_id,json=amountsByAssetId,proto3" json:"amounts_by_asset_id,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *UniverseRoot) Reset() { *x = UniverseRoot{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[5] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *UniverseRoot) String() string { @@ -682,7 +673,7 @@ func (*UniverseRoot) ProtoMessage() {} func (x *UniverseRoot) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[5] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -726,22 +717,19 @@ func (x *UniverseRoot) GetAmountsByAssetId() map[string]uint64 { } type AssetRootResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // A map of the set of known universe roots for each asset. The key in the // map is the 32-byte asset_id or group key hash. - UniverseRoots map[string]*UniverseRoot `protobuf:"bytes,1,rep,name=universe_roots,json=universeRoots,proto3" json:"universe_roots,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + UniverseRoots map[string]*UniverseRoot `protobuf:"bytes,1,rep,name=universe_roots,json=universeRoots,proto3" json:"universe_roots,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetRootResponse) Reset() { *x = AssetRootResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[6] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetRootResponse) String() string { @@ -752,7 +740,7 @@ func (*AssetRootResponse) ProtoMessage() {} func (x *AssetRootResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[6] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -775,21 +763,18 @@ func (x *AssetRootResponse) GetUniverseRoots() map[string]*UniverseRoot { } type AssetRootQuery struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // An ID value to uniquely identify a Universe root. - Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetRootQuery) Reset() { *x = AssetRootQuery{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetRootQuery) String() string { @@ -800,7 +785,7 @@ func (*AssetRootQuery) ProtoMessage() {} func (x *AssetRootQuery) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[7] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -823,23 +808,20 @@ func (x *AssetRootQuery) GetId() *ID { } type QueryRootResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The issuance universe root for the given asset ID or group key. IssuanceRoot *UniverseRoot `protobuf:"bytes,1,opt,name=issuance_root,json=issuanceRoot,proto3" json:"issuance_root,omitempty"` // The transfer universe root for the given asset ID or group key. - TransferRoot *UniverseRoot `protobuf:"bytes,2,opt,name=transfer_root,json=transferRoot,proto3" json:"transfer_root,omitempty"` + TransferRoot *UniverseRoot `protobuf:"bytes,2,opt,name=transfer_root,json=transferRoot,proto3" json:"transfer_root,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryRootResponse) Reset() { *x = QueryRootResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[8] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryRootResponse) String() string { @@ -850,7 +832,7 @@ func (*QueryRootResponse) ProtoMessage() {} func (x *QueryRootResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[8] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -880,21 +862,18 @@ func (x *QueryRootResponse) GetTransferRoot() *UniverseRoot { } type DeleteRootQuery struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // An ID value to uniquely identify a Universe root. - Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *DeleteRootQuery) Reset() { *x = DeleteRootQuery{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[9] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *DeleteRootQuery) String() string { @@ -905,7 +884,7 @@ func (*DeleteRootQuery) ProtoMessage() {} func (x *DeleteRootQuery) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[9] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -928,18 +907,16 @@ func (x *DeleteRootQuery) GetId() *ID { } type DeleteRootResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *DeleteRootResponse) Reset() { *x = DeleteRootResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[10] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *DeleteRootResponse) String() string { @@ -950,7 +927,7 @@ func (*DeleteRootResponse) ProtoMessage() {} func (x *DeleteRootResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[10] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -966,23 +943,20 @@ func (*DeleteRootResponse) Descriptor() ([]byte, []int) { } type Outpoint struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The output as a hex encoded (and reversed!) string. HashStr string `protobuf:"bytes,1,opt,name=hash_str,json=hashStr,proto3" json:"hash_str,omitempty"` // The index of the output. - Index int32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` + Index int32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *Outpoint) Reset() { *x = Outpoint{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[11] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *Outpoint) String() string { @@ -993,7 +967,7 @@ func (*Outpoint) ProtoMessage() {} func (x *Outpoint) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[11] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1023,34 +997,31 @@ func (x *Outpoint) GetIndex() int32 { } type AssetKey struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The outpoint of the asset key, either as a single hex encoded string, or // an unrolled outpoint. // - // Types that are assignable to Outpoint: + // Types that are valid to be assigned to Outpoint: // // *AssetKey_OpStr // *AssetKey_Op Outpoint isAssetKey_Outpoint `protobuf_oneof:"outpoint"` // The script key of the asset. // - // Types that are assignable to ScriptKey: + // Types that are valid to be assigned to ScriptKey: // // *AssetKey_ScriptKeyBytes // *AssetKey_ScriptKeyStr - ScriptKey isAssetKey_ScriptKey `protobuf_oneof:"script_key"` + ScriptKey isAssetKey_ScriptKey `protobuf_oneof:"script_key"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetKey) Reset() { *x = AssetKey{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[12] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetKey) String() string { @@ -1061,7 +1032,7 @@ func (*AssetKey) ProtoMessage() {} func (x *AssetKey) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[12] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1076,44 +1047,52 @@ func (*AssetKey) Descriptor() ([]byte, []int) { return file_universerpc_universe_proto_rawDescGZIP(), []int{12} } -func (m *AssetKey) GetOutpoint() isAssetKey_Outpoint { - if m != nil { - return m.Outpoint +func (x *AssetKey) GetOutpoint() isAssetKey_Outpoint { + if x != nil { + return x.Outpoint } return nil } func (x *AssetKey) GetOpStr() string { - if x, ok := x.GetOutpoint().(*AssetKey_OpStr); ok { - return x.OpStr + if x != nil { + if x, ok := x.Outpoint.(*AssetKey_OpStr); ok { + return x.OpStr + } } return "" } func (x *AssetKey) GetOp() *Outpoint { - if x, ok := x.GetOutpoint().(*AssetKey_Op); ok { - return x.Op + if x != nil { + if x, ok := x.Outpoint.(*AssetKey_Op); ok { + return x.Op + } } return nil } -func (m *AssetKey) GetScriptKey() isAssetKey_ScriptKey { - if m != nil { - return m.ScriptKey +func (x *AssetKey) GetScriptKey() isAssetKey_ScriptKey { + if x != nil { + return x.ScriptKey } return nil } func (x *AssetKey) GetScriptKeyBytes() []byte { - if x, ok := x.GetScriptKey().(*AssetKey_ScriptKeyBytes); ok { - return x.ScriptKeyBytes + if x != nil { + if x, ok := x.ScriptKey.(*AssetKey_ScriptKeyBytes); ok { + return x.ScriptKeyBytes + } } return nil } func (x *AssetKey) GetScriptKeyStr() string { - if x, ok := x.GetScriptKey().(*AssetKey_ScriptKeyStr); ok { - return x.ScriptKeyStr + if x != nil { + if x, ok := x.ScriptKey.(*AssetKey_ScriptKeyStr); ok { + return x.ScriptKeyStr + } } return "" } @@ -1151,10 +1130,7 @@ func (*AssetKey_ScriptKeyBytes) isAssetKey_ScriptKey() {} func (*AssetKey_ScriptKeyStr) isAssetKey_ScriptKey() {} type AssetLeafKeysRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The ID of the asset to query for. Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // The offset for the page. @@ -1162,16 +1138,16 @@ type AssetLeafKeysRequest struct { // The length limit for the page. Limit int32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` // The direction of the page. - Direction SortDirection `protobuf:"varint,4,opt,name=direction,proto3,enum=universerpc.SortDirection" json:"direction,omitempty"` + Direction SortDirection `protobuf:"varint,4,opt,name=direction,proto3,enum=universerpc.SortDirection" json:"direction,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetLeafKeysRequest) Reset() { *x = AssetLeafKeysRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[13] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetLeafKeysRequest) String() string { @@ -1182,7 +1158,7 @@ func (*AssetLeafKeysRequest) ProtoMessage() {} func (x *AssetLeafKeysRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[13] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1226,21 +1202,18 @@ func (x *AssetLeafKeysRequest) GetDirection() SortDirection { } type AssetLeafKeyResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The set of asset leaf keys for the given asset ID or group key. - AssetKeys []*AssetKey `protobuf:"bytes,1,rep,name=asset_keys,json=assetKeys,proto3" json:"asset_keys,omitempty"` + AssetKeys []*AssetKey `protobuf:"bytes,1,rep,name=asset_keys,json=assetKeys,proto3" json:"asset_keys,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetLeafKeyResponse) Reset() { *x = AssetLeafKeyResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[14] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetLeafKeyResponse) String() string { @@ -1251,7 +1224,7 @@ func (*AssetLeafKeyResponse) ProtoMessage() {} func (x *AssetLeafKeyResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[14] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1274,25 +1247,22 @@ func (x *AssetLeafKeyResponse) GetAssetKeys() []*AssetKey { } type AssetLeaf struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The asset included in the leaf. Asset *taprpc.Asset `protobuf:"bytes,1,opt,name=asset,proto3" json:"asset,omitempty"` // The asset issuance or transfer proof, which proves that the asset // specified above was issued or transferred properly. This is always just // an individual mint/transfer proof and never a proof file. - Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetLeaf) Reset() { *x = AssetLeaf{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetLeaf) String() string { @@ -1303,7 +1273,7 @@ func (*AssetLeaf) ProtoMessage() {} func (x *AssetLeaf) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[15] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1333,21 +1303,18 @@ func (x *AssetLeaf) GetProof() []byte { } type AssetLeafResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The set of asset leaves for the given asset ID or group key. - Leaves []*AssetLeaf `protobuf:"bytes,1,rep,name=leaves,proto3" json:"leaves,omitempty"` + Leaves []*AssetLeaf `protobuf:"bytes,1,rep,name=leaves,proto3" json:"leaves,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetLeafResponse) Reset() { *x = AssetLeafResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[16] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetLeafResponse) String() string { @@ -1358,7 +1325,7 @@ func (*AssetLeafResponse) ProtoMessage() {} func (x *AssetLeafResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[16] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1381,23 +1348,20 @@ func (x *AssetLeafResponse) GetLeaves() []*AssetLeaf { } type UniverseKey struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The ID of the asset to query for. Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // The asset key to query for. - LeafKey *AssetKey `protobuf:"bytes,2,opt,name=leaf_key,json=leafKey,proto3" json:"leaf_key,omitempty"` + LeafKey *AssetKey `protobuf:"bytes,2,opt,name=leaf_key,json=leafKey,proto3" json:"leaf_key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *UniverseKey) Reset() { *x = UniverseKey{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[17] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *UniverseKey) String() string { @@ -1408,7 +1372,7 @@ func (*UniverseKey) ProtoMessage() {} func (x *UniverseKey) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[17] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1438,10 +1402,7 @@ func (x *UniverseKey) GetLeafKey() *AssetKey { } type AssetProofResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The original request for the issuance proof. Req *UniverseKey `protobuf:"bytes,1,opt,name=req,proto3" json:"req,omitempty"` // The Universe root that includes this asset leaf. @@ -1459,16 +1420,16 @@ type AssetProofResponse struct { MultiverseInclusionProof []byte `protobuf:"bytes,6,opt,name=multiverse_inclusion_proof,json=multiverseInclusionProof,proto3" json:"multiverse_inclusion_proof,omitempty"` // The issuance related data for an issuance asset leaf. This is empty for // any other type of asset leaf. - IssuanceData *IssuanceData `protobuf:"bytes,7,opt,name=issuance_data,json=issuanceData,proto3" json:"issuance_data,omitempty"` + IssuanceData *IssuanceData `protobuf:"bytes,7,opt,name=issuance_data,json=issuanceData,proto3" json:"issuance_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetProofResponse) Reset() { *x = AssetProofResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[18] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetProofResponse) String() string { @@ -1479,7 +1440,7 @@ func (*AssetProofResponse) ProtoMessage() {} func (x *AssetProofResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[18] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1544,10 +1505,7 @@ func (x *AssetProofResponse) GetIssuanceData() *IssuanceData { } type IssuanceData struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The reveal meta data associated with the proof, if available. MetaReveal *taprpc.AssetMeta `protobuf:"bytes,1,opt,name=meta_reveal,json=metaReveal,proto3" json:"meta_reveal,omitempty"` // GenesisReveal is an optional field that is the Genesis information for @@ -1556,15 +1514,15 @@ type IssuanceData struct { // GroupKeyReveal is an optional field that includes the information needed // to derive the tweaked group key. GroupKeyReveal *taprpc.GroupKeyReveal `protobuf:"bytes,3,opt,name=group_key_reveal,json=groupKeyReveal,proto3" json:"group_key_reveal,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *IssuanceData) Reset() { *x = IssuanceData{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[19] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *IssuanceData) String() string { @@ -1575,7 +1533,7 @@ func (*IssuanceData) ProtoMessage() {} func (x *IssuanceData) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[19] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1612,23 +1570,20 @@ func (x *IssuanceData) GetGroupKeyReveal() *taprpc.GroupKeyReveal { } type AssetProof struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The ID of the asset to insert the proof for. Key *UniverseKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // The asset leaf to insert into the Universe tree. - AssetLeaf *AssetLeaf `protobuf:"bytes,4,opt,name=asset_leaf,json=assetLeaf,proto3" json:"asset_leaf,omitempty"` + AssetLeaf *AssetLeaf `protobuf:"bytes,4,opt,name=asset_leaf,json=assetLeaf,proto3" json:"asset_leaf,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetProof) Reset() { *x = AssetProof{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[20] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetProof) String() string { @@ -1639,7 +1594,7 @@ func (*AssetProof) ProtoMessage() {} func (x *AssetProof) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[20] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1669,23 +1624,20 @@ func (x *AssetProof) GetAssetLeaf() *AssetLeaf { } type PushProofRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The ID of the asset to push the proof for. Key *UniverseKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` // The universe server to push the proof to. - Server *UniverseFederationServer `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"` + Server *UniverseFederationServer `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PushProofRequest) Reset() { *x = PushProofRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[21] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PushProofRequest) String() string { @@ -1696,7 +1648,7 @@ func (*PushProofRequest) ProtoMessage() {} func (x *PushProofRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[21] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1726,21 +1678,18 @@ func (x *PushProofRequest) GetServer() *UniverseFederationServer { } type PushProofResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The ID of the asset a push was requested for. - Key *UniverseKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Key *UniverseKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *PushProofResponse) Reset() { *x = PushProofResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[22] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *PushProofResponse) String() string { @@ -1751,7 +1700,7 @@ func (*PushProofResponse) ProtoMessage() {} func (x *PushProofResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[22] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1774,18 +1723,16 @@ func (x *PushProofResponse) GetKey() *UniverseKey { } type InfoRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *InfoRequest) Reset() { *x = InfoRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[23] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *InfoRequest) String() string { @@ -1796,7 +1743,7 @@ func (*InfoRequest) ProtoMessage() {} func (x *InfoRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[23] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1812,23 +1759,20 @@ func (*InfoRequest) Descriptor() ([]byte, []int) { } type InfoResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // A pseudo-random runtime ID for the current instance of the Universe // server, changes with each restart. Mainly used to identify identical // servers when they are exposed under different hostnames/ports. - RuntimeId int64 `protobuf:"varint,1,opt,name=runtime_id,json=runtimeId,proto3" json:"runtime_id,omitempty"` + RuntimeId int64 `protobuf:"varint,1,opt,name=runtime_id,json=runtimeId,proto3" json:"runtime_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *InfoResponse) Reset() { *x = InfoResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[24] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *InfoResponse) String() string { @@ -1839,7 +1783,7 @@ func (*InfoResponse) ProtoMessage() {} func (x *InfoResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[24] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1862,20 +1806,17 @@ func (x *InfoResponse) GetRuntimeId() int64 { } type SyncTarget struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` unknownFields protoimpl.UnknownFields - - Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + sizeCache protoimpl.SizeCache } func (x *SyncTarget) Reset() { *x = SyncTarget{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[25] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SyncTarget) String() string { @@ -1886,7 +1827,7 @@ func (*SyncTarget) ProtoMessage() {} func (x *SyncTarget) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[25] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1909,10 +1850,7 @@ func (x *SyncTarget) GetId() *ID { } type SyncRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // TODO(roasbeef): accept connection type? so can pass along self-signed // cert, also brontide based RPC handshake UniverseHost string `protobuf:"bytes,1,opt,name=universe_host,json=universeHost,proto3" json:"universe_host,omitempty"` @@ -1920,16 +1858,16 @@ type SyncRequest struct { SyncMode UniverseSyncMode `protobuf:"varint,2,opt,name=sync_mode,json=syncMode,proto3,enum=universerpc.UniverseSyncMode" json:"sync_mode,omitempty"` // The set of assets to sync. If none are specified, then all assets are // synced. - SyncTargets []*SyncTarget `protobuf:"bytes,3,rep,name=sync_targets,json=syncTargets,proto3" json:"sync_targets,omitempty"` + SyncTargets []*SyncTarget `protobuf:"bytes,3,rep,name=sync_targets,json=syncTargets,proto3" json:"sync_targets,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SyncRequest) Reset() { *x = SyncRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[26] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SyncRequest) String() string { @@ -1940,7 +1878,7 @@ func (*SyncRequest) ProtoMessage() {} func (x *SyncRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[26] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -1977,25 +1915,22 @@ func (x *SyncRequest) GetSyncTargets() []*SyncTarget { } type SyncedUniverse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The old Universe root for the synced asset. OldAssetRoot *UniverseRoot `protobuf:"bytes,1,opt,name=old_asset_root,json=oldAssetRoot,proto3" json:"old_asset_root,omitempty"` // The new Universe root for the synced asset. NewAssetRoot *UniverseRoot `protobuf:"bytes,2,opt,name=new_asset_root,json=newAssetRoot,proto3" json:"new_asset_root,omitempty"` // The set of new asset leaves that were synced. NewAssetLeaves []*AssetLeaf `protobuf:"bytes,3,rep,name=new_asset_leaves,json=newAssetLeaves,proto3" json:"new_asset_leaves,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SyncedUniverse) Reset() { *x = SyncedUniverse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[27] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SyncedUniverse) String() string { @@ -2006,7 +1941,7 @@ func (*SyncedUniverse) ProtoMessage() {} func (x *SyncedUniverse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[27] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2043,18 +1978,16 @@ func (x *SyncedUniverse) GetNewAssetLeaves() []*AssetLeaf { } type StatsRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *StatsRequest) Reset() { *x = StatsRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[28] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *StatsRequest) String() string { @@ -2065,7 +1998,7 @@ func (*StatsRequest) ProtoMessage() {} func (x *StatsRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[28] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2081,21 +2014,18 @@ func (*StatsRequest) Descriptor() ([]byte, []int) { } type SyncResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The set of synced asset Universes. SyncedUniverses []*SyncedUniverse `protobuf:"bytes,1,rep,name=synced_universes,json=syncedUniverses,proto3" json:"synced_universes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SyncResponse) Reset() { *x = SyncResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[29] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SyncResponse) String() string { @@ -2106,7 +2036,7 @@ func (*SyncResponse) ProtoMessage() {} func (x *SyncResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[29] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2129,21 +2059,18 @@ func (x *SyncResponse) GetSyncedUniverses() []*SyncedUniverse { } type UniverseFederationServer struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` + Id int32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` unknownFields protoimpl.UnknownFields - - Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"` - Id int32 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"` + sizeCache protoimpl.SizeCache } func (x *UniverseFederationServer) Reset() { *x = UniverseFederationServer{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[30] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *UniverseFederationServer) String() string { @@ -2154,7 +2081,7 @@ func (*UniverseFederationServer) ProtoMessage() {} func (x *UniverseFederationServer) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[30] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2184,18 +2111,16 @@ func (x *UniverseFederationServer) GetId() int32 { } type ListFederationServersRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *ListFederationServersRequest) Reset() { *x = ListFederationServersRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[31] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *ListFederationServersRequest) String() string { @@ -2206,7 +2131,7 @@ func (*ListFederationServersRequest) ProtoMessage() {} func (x *ListFederationServersRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[31] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2222,20 +2147,17 @@ func (*ListFederationServersRequest) Descriptor() ([]byte, []int) { } type ListFederationServersResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Servers []*UniverseFederationServer `protobuf:"bytes,1,rep,name=servers,proto3" json:"servers,omitempty"` unknownFields protoimpl.UnknownFields - - Servers []*UniverseFederationServer `protobuf:"bytes,1,rep,name=servers,proto3" json:"servers,omitempty"` + sizeCache protoimpl.SizeCache } func (x *ListFederationServersResponse) Reset() { *x = ListFederationServersResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[32] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *ListFederationServersResponse) String() string { @@ -2246,7 +2168,7 @@ func (*ListFederationServersResponse) ProtoMessage() {} func (x *ListFederationServersResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[32] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2269,20 +2191,17 @@ func (x *ListFederationServersResponse) GetServers() []*UniverseFederationServer } type AddFederationServerRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Servers []*UniverseFederationServer `protobuf:"bytes,1,rep,name=servers,proto3" json:"servers,omitempty"` unknownFields protoimpl.UnknownFields - - Servers []*UniverseFederationServer `protobuf:"bytes,1,rep,name=servers,proto3" json:"servers,omitempty"` + sizeCache protoimpl.SizeCache } func (x *AddFederationServerRequest) Reset() { *x = AddFederationServerRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[33] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddFederationServerRequest) String() string { @@ -2293,7 +2212,7 @@ func (*AddFederationServerRequest) ProtoMessage() {} func (x *AddFederationServerRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[33] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2316,18 +2235,16 @@ func (x *AddFederationServerRequest) GetServers() []*UniverseFederationServer { } type AddFederationServerResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AddFederationServerResponse) Reset() { *x = AddFederationServerResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[34] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AddFederationServerResponse) String() string { @@ -2338,7 +2255,7 @@ func (*AddFederationServerResponse) ProtoMessage() {} func (x *AddFederationServerResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[34] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2354,20 +2271,17 @@ func (*AddFederationServerResponse) Descriptor() ([]byte, []int) { } type DeleteFederationServerRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Servers []*UniverseFederationServer `protobuf:"bytes,1,rep,name=servers,proto3" json:"servers,omitempty"` unknownFields protoimpl.UnknownFields - - Servers []*UniverseFederationServer `protobuf:"bytes,1,rep,name=servers,proto3" json:"servers,omitempty"` + sizeCache protoimpl.SizeCache } func (x *DeleteFederationServerRequest) Reset() { *x = DeleteFederationServerRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[35] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *DeleteFederationServerRequest) String() string { @@ -2378,7 +2292,7 @@ func (*DeleteFederationServerRequest) ProtoMessage() {} func (x *DeleteFederationServerRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[35] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2401,18 +2315,16 @@ func (x *DeleteFederationServerRequest) GetServers() []*UniverseFederationServer } type DeleteFederationServerResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *DeleteFederationServerResponse) Reset() { *x = DeleteFederationServerResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[36] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *DeleteFederationServerResponse) String() string { @@ -2423,7 +2335,7 @@ func (*DeleteFederationServerResponse) ProtoMessage() {} func (x *DeleteFederationServerResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[36] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2439,23 +2351,20 @@ func (*DeleteFederationServerResponse) Descriptor() ([]byte, []int) { } type StatsResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - NumTotalAssets int64 `protobuf:"varint,1,opt,name=num_total_assets,json=numTotalAssets,proto3" json:"num_total_assets,omitempty"` - NumTotalGroups int64 `protobuf:"varint,2,opt,name=num_total_groups,json=numTotalGroups,proto3" json:"num_total_groups,omitempty"` - NumTotalSyncs int64 `protobuf:"varint,3,opt,name=num_total_syncs,json=numTotalSyncs,proto3" json:"num_total_syncs,omitempty"` - NumTotalProofs int64 `protobuf:"varint,4,opt,name=num_total_proofs,json=numTotalProofs,proto3" json:"num_total_proofs,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + NumTotalAssets int64 `protobuf:"varint,1,opt,name=num_total_assets,json=numTotalAssets,proto3" json:"num_total_assets,omitempty"` + NumTotalGroups int64 `protobuf:"varint,2,opt,name=num_total_groups,json=numTotalGroups,proto3" json:"num_total_groups,omitempty"` + NumTotalSyncs int64 `protobuf:"varint,3,opt,name=num_total_syncs,json=numTotalSyncs,proto3" json:"num_total_syncs,omitempty"` + NumTotalProofs int64 `protobuf:"varint,4,opt,name=num_total_proofs,json=numTotalProofs,proto3" json:"num_total_proofs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *StatsResponse) Reset() { *x = StatsResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[37] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *StatsResponse) String() string { @@ -2466,7 +2375,7 @@ func (*StatsResponse) ProtoMessage() {} func (x *StatsResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[37] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2510,26 +2419,23 @@ func (x *StatsResponse) GetNumTotalProofs() int64 { } type AssetStatsQuery struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - AssetNameFilter string `protobuf:"bytes,1,opt,name=asset_name_filter,json=assetNameFilter,proto3" json:"asset_name_filter,omitempty"` - AssetIdFilter []byte `protobuf:"bytes,2,opt,name=asset_id_filter,json=assetIdFilter,proto3" json:"asset_id_filter,omitempty"` - AssetTypeFilter AssetTypeFilter `protobuf:"varint,3,opt,name=asset_type_filter,json=assetTypeFilter,proto3,enum=universerpc.AssetTypeFilter" json:"asset_type_filter,omitempty"` - SortBy AssetQuerySort `protobuf:"varint,4,opt,name=sort_by,json=sortBy,proto3,enum=universerpc.AssetQuerySort" json:"sort_by,omitempty"` - Offset int32 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"` - Limit int32 `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"` - Direction SortDirection `protobuf:"varint,7,opt,name=direction,proto3,enum=universerpc.SortDirection" json:"direction,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + AssetNameFilter string `protobuf:"bytes,1,opt,name=asset_name_filter,json=assetNameFilter,proto3" json:"asset_name_filter,omitempty"` + AssetIdFilter []byte `protobuf:"bytes,2,opt,name=asset_id_filter,json=assetIdFilter,proto3" json:"asset_id_filter,omitempty"` + AssetTypeFilter AssetTypeFilter `protobuf:"varint,3,opt,name=asset_type_filter,json=assetTypeFilter,proto3,enum=universerpc.AssetTypeFilter" json:"asset_type_filter,omitempty"` + SortBy AssetQuerySort `protobuf:"varint,4,opt,name=sort_by,json=sortBy,proto3,enum=universerpc.AssetQuerySort" json:"sort_by,omitempty"` + Offset int32 `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"` + Limit int32 `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"` + Direction SortDirection `protobuf:"varint,7,opt,name=direction,proto3,enum=universerpc.SortDirection" json:"direction,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetStatsQuery) Reset() { *x = AssetStatsQuery{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[38] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetStatsQuery) String() string { @@ -2540,7 +2446,7 @@ func (*AssetStatsQuery) ProtoMessage() {} func (x *AssetStatsQuery) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[38] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2605,10 +2511,7 @@ func (x *AssetStatsQuery) GetDirection() SortDirection { } type AssetStatsSnapshot struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The group key of the asset group. If this is empty, then the asset is // not part of a group. GroupKey []byte `protobuf:"bytes,1,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"` @@ -2626,16 +2529,16 @@ type AssetStatsSnapshot struct { TotalSyncs int64 `protobuf:"varint,5,opt,name=total_syncs,json=totalSyncs,proto3" json:"total_syncs,omitempty"` // The total number of proofs either for the asset group or the single asset // if it is not part of a group. - TotalProofs int64 `protobuf:"varint,6,opt,name=total_proofs,json=totalProofs,proto3" json:"total_proofs,omitempty"` + TotalProofs int64 `protobuf:"varint,6,opt,name=total_proofs,json=totalProofs,proto3" json:"total_proofs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetStatsSnapshot) Reset() { *x = AssetStatsSnapshot{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[39] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetStatsSnapshot) String() string { @@ -2646,7 +2549,7 @@ func (*AssetStatsSnapshot) ProtoMessage() {} func (x *AssetStatsSnapshot) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[39] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2704,28 +2607,25 @@ func (x *AssetStatsSnapshot) GetTotalProofs() int64 { } type AssetStatsAsset struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` - GenesisPoint string `protobuf:"bytes,2,opt,name=genesis_point,json=genesisPoint,proto3" json:"genesis_point,omitempty"` - TotalSupply int64 `protobuf:"varint,3,opt,name=total_supply,json=totalSupply,proto3" json:"total_supply,omitempty"` - AssetName string `protobuf:"bytes,4,opt,name=asset_name,json=assetName,proto3" json:"asset_name,omitempty"` - AssetType taprpc.AssetType `protobuf:"varint,5,opt,name=asset_type,json=assetType,proto3,enum=taprpc.AssetType" json:"asset_type,omitempty"` - GenesisHeight int32 `protobuf:"varint,6,opt,name=genesis_height,json=genesisHeight,proto3" json:"genesis_height,omitempty"` - GenesisTimestamp int64 `protobuf:"varint,7,opt,name=genesis_timestamp,json=genesisTimestamp,proto3" json:"genesis_timestamp,omitempty"` - AnchorPoint string `protobuf:"bytes,8,opt,name=anchor_point,json=anchorPoint,proto3" json:"anchor_point,omitempty"` - DecimalDisplay uint32 `protobuf:"varint,9,opt,name=decimal_display,json=decimalDisplay,proto3" json:"decimal_display,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + AssetId []byte `protobuf:"bytes,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` + GenesisPoint string `protobuf:"bytes,2,opt,name=genesis_point,json=genesisPoint,proto3" json:"genesis_point,omitempty"` + TotalSupply int64 `protobuf:"varint,3,opt,name=total_supply,json=totalSupply,proto3" json:"total_supply,omitempty"` + AssetName string `protobuf:"bytes,4,opt,name=asset_name,json=assetName,proto3" json:"asset_name,omitempty"` + AssetType taprpc.AssetType `protobuf:"varint,5,opt,name=asset_type,json=assetType,proto3,enum=taprpc.AssetType" json:"asset_type,omitempty"` + GenesisHeight int32 `protobuf:"varint,6,opt,name=genesis_height,json=genesisHeight,proto3" json:"genesis_height,omitempty"` + GenesisTimestamp int64 `protobuf:"varint,7,opt,name=genesis_timestamp,json=genesisTimestamp,proto3" json:"genesis_timestamp,omitempty"` + AnchorPoint string `protobuf:"bytes,8,opt,name=anchor_point,json=anchorPoint,proto3" json:"anchor_point,omitempty"` + DecimalDisplay uint32 `protobuf:"varint,9,opt,name=decimal_display,json=decimalDisplay,proto3" json:"decimal_display,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetStatsAsset) Reset() { *x = AssetStatsAsset{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[40] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetStatsAsset) String() string { @@ -2736,7 +2636,7 @@ func (*AssetStatsAsset) ProtoMessage() {} func (x *AssetStatsAsset) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[40] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2815,20 +2715,17 @@ func (x *AssetStatsAsset) GetDecimalDisplay() uint32 { } type UniverseAssetStats struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + AssetStats []*AssetStatsSnapshot `protobuf:"bytes,1,rep,name=asset_stats,json=assetStats,proto3" json:"asset_stats,omitempty"` unknownFields protoimpl.UnknownFields - - AssetStats []*AssetStatsSnapshot `protobuf:"bytes,1,rep,name=asset_stats,json=assetStats,proto3" json:"asset_stats,omitempty"` + sizeCache protoimpl.SizeCache } func (x *UniverseAssetStats) Reset() { *x = UniverseAssetStats{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[41] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *UniverseAssetStats) String() string { @@ -2839,7 +2736,7 @@ func (*UniverseAssetStats) ProtoMessage() {} func (x *UniverseAssetStats) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[41] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2862,21 +2759,18 @@ func (x *UniverseAssetStats) GetAssetStats() []*AssetStatsSnapshot { } type QueryEventsRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - StartTimestamp int64 `protobuf:"varint,1,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"` - EndTimestamp int64 `protobuf:"varint,2,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + StartTimestamp int64 `protobuf:"varint,1,opt,name=start_timestamp,json=startTimestamp,proto3" json:"start_timestamp,omitempty"` + EndTimestamp int64 `protobuf:"varint,2,opt,name=end_timestamp,json=endTimestamp,proto3" json:"end_timestamp,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryEventsRequest) Reset() { *x = QueryEventsRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[42] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryEventsRequest) String() string { @@ -2887,7 +2781,7 @@ func (*QueryEventsRequest) ProtoMessage() {} func (x *QueryEventsRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[42] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2917,20 +2811,17 @@ func (x *QueryEventsRequest) GetEndTimestamp() int64 { } type QueryEventsResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` + Events []*GroupedUniverseEvents `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` unknownFields protoimpl.UnknownFields - - Events []*GroupedUniverseEvents `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` + sizeCache protoimpl.SizeCache } func (x *QueryEventsResponse) Reset() { *x = QueryEventsResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[43] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryEventsResponse) String() string { @@ -2941,7 +2832,7 @@ func (*QueryEventsResponse) ProtoMessage() {} func (x *QueryEventsResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[43] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -2964,23 +2855,20 @@ func (x *QueryEventsResponse) GetEvents() []*GroupedUniverseEvents { } type GroupedUniverseEvents struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // The date the events occurred on, formatted as YYYY-MM-DD. Date string `protobuf:"bytes,1,opt,name=date,proto3" json:"date,omitempty"` SyncEvents uint64 `protobuf:"varint,2,opt,name=sync_events,json=syncEvents,proto3" json:"sync_events,omitempty"` NewProofEvents uint64 `protobuf:"varint,3,opt,name=new_proof_events,json=newProofEvents,proto3" json:"new_proof_events,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *GroupedUniverseEvents) Reset() { *x = GroupedUniverseEvents{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[44] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *GroupedUniverseEvents) String() string { @@ -2991,7 +2879,7 @@ func (*GroupedUniverseEvents) ProtoMessage() {} func (x *GroupedUniverseEvents) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[44] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -3028,21 +2916,18 @@ func (x *GroupedUniverseEvents) GetNewProofEvents() uint64 { } type SetFederationSyncConfigRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` GlobalSyncConfigs []*GlobalFederationSyncConfig `protobuf:"bytes,1,rep,name=global_sync_configs,json=globalSyncConfigs,proto3" json:"global_sync_configs,omitempty"` AssetSyncConfigs []*AssetFederationSyncConfig `protobuf:"bytes,2,rep,name=asset_sync_configs,json=assetSyncConfigs,proto3" json:"asset_sync_configs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SetFederationSyncConfigRequest) Reset() { *x = SetFederationSyncConfigRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[45] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SetFederationSyncConfigRequest) String() string { @@ -3053,7 +2938,7 @@ func (*SetFederationSyncConfigRequest) ProtoMessage() {} func (x *SetFederationSyncConfigRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[45] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -3083,18 +2968,16 @@ func (x *SetFederationSyncConfigRequest) GetAssetSyncConfigs() []*AssetFederatio } type SetFederationSyncConfigResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache + state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *SetFederationSyncConfigResponse) Reset() { *x = SetFederationSyncConfigResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[46] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *SetFederationSyncConfigResponse) String() string { @@ -3105,7 +2988,7 @@ func (*SetFederationSyncConfigResponse) ProtoMessage() {} func (x *SetFederationSyncConfigResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[46] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -3123,10 +3006,7 @@ func (*SetFederationSyncConfigResponse) Descriptor() ([]byte, []int) { // GlobalFederationSyncConfig is a global proof type specific configuration // for universe federation syncing. type GlobalFederationSyncConfig struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // proof_type is the universe proof type which this config applies to. ProofType ProofType `protobuf:"varint,1,opt,name=proof_type,json=proofType,proto3,enum=universerpc.ProofType" json:"proof_type,omitempty"` // allow_sync_insert is a boolean that indicates whether leaves from @@ -3137,15 +3017,15 @@ type GlobalFederationSyncConfig struct { // universes of the given proof type have may be exported via federation // sync. AllowSyncExport bool `protobuf:"varint,3,opt,name=allow_sync_export,json=allowSyncExport,proto3" json:"allow_sync_export,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *GlobalFederationSyncConfig) Reset() { *x = GlobalFederationSyncConfig{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[47] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *GlobalFederationSyncConfig) String() string { @@ -3156,7 +3036,7 @@ func (*GlobalFederationSyncConfig) ProtoMessage() {} func (x *GlobalFederationSyncConfig) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[47] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -3195,10 +3075,7 @@ func (x *GlobalFederationSyncConfig) GetAllowSyncExport() bool { // AssetFederationSyncConfig is an asset universe specific configuration for // federation syncing. type AssetFederationSyncConfig struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // id is the ID of the universe to configure. Id *ID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // allow_sync_insert is a boolean that indicates whether leaves from @@ -3209,15 +3086,15 @@ type AssetFederationSyncConfig struct { // universes of the given proof type have may be exported via federation // sync. AllowSyncExport bool `protobuf:"varint,3,opt,name=allow_sync_export,json=allowSyncExport,proto3" json:"allow_sync_export,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *AssetFederationSyncConfig) Reset() { *x = AssetFederationSyncConfig{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[48] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *AssetFederationSyncConfig) String() string { @@ -3228,7 +3105,7 @@ func (*AssetFederationSyncConfig) ProtoMessage() {} func (x *AssetFederationSyncConfig) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[48] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -3265,21 +3142,18 @@ func (x *AssetFederationSyncConfig) GetAllowSyncExport() bool { } type QueryFederationSyncConfigRequest struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` // Target universe ID(s). - Id []*ID `protobuf:"bytes,1,rep,name=id,proto3" json:"id,omitempty"` + Id []*ID `protobuf:"bytes,1,rep,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryFederationSyncConfigRequest) Reset() { *x = QueryFederationSyncConfigRequest{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[49] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryFederationSyncConfigRequest) String() string { @@ -3290,7 +3164,7 @@ func (*QueryFederationSyncConfigRequest) ProtoMessage() {} func (x *QueryFederationSyncConfigRequest) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[49] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -3313,21 +3187,18 @@ func (x *QueryFederationSyncConfigRequest) GetId() []*ID { } type QueryFederationSyncConfigResponse struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - + state protoimpl.MessageState `protogen:"open.v1"` GlobalSyncConfigs []*GlobalFederationSyncConfig `protobuf:"bytes,1,rep,name=global_sync_configs,json=globalSyncConfigs,proto3" json:"global_sync_configs,omitempty"` AssetSyncConfigs []*AssetFederationSyncConfig `protobuf:"bytes,2,rep,name=asset_sync_configs,json=assetSyncConfigs,proto3" json:"asset_sync_configs,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *QueryFederationSyncConfigResponse) Reset() { *x = QueryFederationSyncConfigResponse{} - if protoimpl.UnsafeEnabled { - mi := &file_universerpc_universe_proto_msgTypes[50] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } + mi := &file_universerpc_universe_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } func (x *QueryFederationSyncConfigResponse) String() string { @@ -3338,7 +3209,7 @@ func (*QueryFederationSyncConfigResponse) ProtoMessage() {} func (x *QueryFederationSyncConfigResponse) ProtoReflect() protoreflect.Message { mi := &file_universerpc_universe_proto_msgTypes[50] - if protoimpl.UnsafeEnabled && x != nil { + if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { ms.StoreMessageInfo(mi) @@ -3369,573 +3240,255 @@ func (x *QueryFederationSyncConfigResponse) GetAssetSyncConfigs() []*AssetFedera var File_universerpc_universe_proto protoreflect.FileDescriptor -var file_universerpc_universe_proto_rawDesc = []byte{ - 0x0a, 0x1a, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2f, 0x75, 0x6e, - 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0b, 0x75, 0x6e, - 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x1a, 0x13, 0x74, 0x61, 0x70, 0x72, 0x6f, - 0x6f, 0x74, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x82, - 0x01, 0x0a, 0x15, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x35, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6f, - 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x75, - 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, - 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x32, 0x0a, 0x0c, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, 0x5f, 0x69, 0x64, 0x73, 0x18, - 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, - 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x0b, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x63, - 0x49, 0x64, 0x73, 0x22, 0x5d, 0x0a, 0x16, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, - 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, - 0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, - 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, - 0x64, 0x65, 0x52, 0x0e, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, - 0x6f, 0x74, 0x22, 0xa7, 0x01, 0x0a, 0x10, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2b, 0x0a, 0x12, 0x77, 0x69, 0x74, 0x68, 0x5f, - 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x0f, 0x77, 0x69, 0x74, 0x68, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, - 0x42, 0x79, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, - 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, - 0x69, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, - 0x72, 0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x47, 0x0a, 0x0d, - 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x1b, 0x0a, - 0x09, 0x72, 0x6f, 0x6f, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, - 0x52, 0x08, 0x72, 0x6f, 0x6f, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, - 0x6f, 0x74, 0x5f, 0x73, 0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x72, 0x6f, - 0x6f, 0x74, 0x53, 0x75, 0x6d, 0x22, 0xc7, 0x01, 0x0a, 0x02, 0x49, 0x44, 0x12, 0x1b, 0x0a, 0x08, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, - 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0c, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x48, - 0x00, 0x52, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x53, 0x74, 0x72, 0x12, 0x1d, 0x0a, - 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, - 0x48, 0x00, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x0d, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x53, - 0x74, 0x72, 0x12, 0x35, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, - 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, - 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x42, 0x04, 0x0a, 0x02, 0x69, 0x64, 0x22, - 0xae, 0x02, 0x0a, 0x0c, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, - 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, - 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, - 0x64, 0x12, 0x39, 0x0a, 0x0a, 0x6d, 0x73, 0x73, 0x6d, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, - 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, 0x64, - 0x65, 0x52, 0x09, 0x6d, 0x73, 0x73, 0x6d, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1d, 0x0a, 0x0a, - 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x5e, 0x0a, 0x13, 0x61, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5f, 0x62, 0x79, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x69, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, - 0x6f, 0x6f, 0x74, 0x2e, 0x41, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x49, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x61, 0x6d, 0x6f, 0x75, 0x6e, - 0x74, 0x73, 0x42, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x1a, 0x43, 0x0a, 0x15, 0x41, - 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x42, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, - 0x22, 0xca, 0x01, 0x0a, 0x11, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x58, 0x0a, 0x0e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, - 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x55, - 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x52, 0x0d, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x73, - 0x1a, 0x5b, 0x0a, 0x12, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, - 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x2f, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, - 0x6f, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x31, 0x0a, - 0x0e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, - 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, - 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, - 0x22, 0x93, 0x01, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0d, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, - 0x63, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, - 0x63, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3e, 0x0a, 0x0d, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x52, 0x6f, 0x6f, 0x74, 0x22, 0x32, 0x0a, 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, - 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, - 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x22, 0x14, 0x0a, 0x12, 0x44, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x3b, 0x0a, 0x08, 0x4f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, - 0x68, 0x61, 0x73, 0x68, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x68, 0x61, 0x73, 0x68, 0x53, 0x74, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0xba, 0x01, - 0x0a, 0x08, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x12, 0x17, 0x0a, 0x06, 0x6f, 0x70, - 0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x05, 0x6f, 0x70, - 0x53, 0x74, 0x72, 0x12, 0x27, 0x0a, 0x02, 0x6f, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x15, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4f, 0x75, - 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x48, 0x00, 0x52, 0x02, 0x6f, 0x70, 0x12, 0x2a, 0x0a, 0x10, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x01, 0x52, 0x0e, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x4b, 0x65, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x0e, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x48, 0x01, 0x52, 0x0c, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x72, - 0x42, 0x0a, 0x0a, 0x08, 0x6f, 0x75, 0x74, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x42, 0x0c, 0x0a, 0x0a, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x5f, 0x6b, 0x65, 0x79, 0x22, 0x9f, 0x01, 0x0a, 0x14, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, - 0x52, 0x02, 0x69, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, - 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, - 0x69, 0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, - 0x72, 0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x4c, 0x0a, 0x14, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6b, 0x65, - 0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x52, - 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, 0x73, 0x22, 0x46, 0x0a, 0x09, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x12, 0x23, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, - 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, - 0x6f, 0x66, 0x22, 0x43, 0x0a, 0x11, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x06, 0x6c, 0x65, 0x61, 0x76, 0x65, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, - 0x06, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x60, 0x0a, 0x0b, 0x55, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, - 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x30, 0x0a, 0x08, 0x6c, 0x65, 0x61, 0x66, 0x5f, - 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x75, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4b, 0x65, 0x79, - 0x52, 0x07, 0x6c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x22, 0xb4, 0x03, 0x0a, 0x12, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x2a, 0x0a, 0x03, 0x72, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x52, 0x03, 0x72, 0x65, 0x71, 0x12, 0x3e, 0x0a, 0x0d, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, - 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x38, 0x0a, 0x18, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, - 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x16, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, - 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x35, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x6c, 0x65, 0x61, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, - 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, - 0x61, 0x66, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x12, 0x43, 0x0a, - 0x0f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, - 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x53, 0x75, 0x6d, 0x4e, 0x6f, - 0x64, 0x65, 0x52, 0x0e, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, - 0x6f, 0x74, 0x12, 0x3c, 0x0a, 0x1a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, - 0x5f, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x18, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f, 0x66, - 0x12, 0x3e, 0x0a, 0x0d, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x61, 0x74, - 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x61, - 0x74, 0x61, 0x52, 0x0c, 0x69, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x61, 0x74, 0x61, - 0x22, 0xc2, 0x01, 0x0a, 0x0c, 0x49, 0x73, 0x73, 0x75, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x61, 0x74, - 0x61, 0x12, 0x32, 0x0a, 0x0b, 0x6d, 0x65, 0x74, 0x61, 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x61, 0x52, 0x0a, 0x6d, 0x65, 0x74, 0x61, 0x52, - 0x65, 0x76, 0x65, 0x61, 0x6c, 0x12, 0x3c, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, - 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, 0x65, - 0x76, 0x65, 0x61, 0x6c, 0x52, 0x0d, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x52, 0x65, 0x76, - 0x65, 0x61, 0x6c, 0x12, 0x40, 0x0a, 0x10, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, - 0x5f, 0x72, 0x65, 0x76, 0x65, 0x61, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x52, - 0x65, 0x76, 0x65, 0x61, 0x6c, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x52, - 0x65, 0x76, 0x65, 0x61, 0x6c, 0x22, 0x6f, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72, - 0x6f, 0x6f, 0x66, 0x12, 0x2a, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, - 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, 0x79, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, - 0x35, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6c, 0x65, 0x61, 0x66, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, - 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x09, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x22, 0x7d, 0x0a, 0x10, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, - 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x03, 0x6b, 0x65, - 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, - 0x79, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, - 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, - 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x06, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x22, 0x3f, 0x0a, 0x11, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, - 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2a, 0x0a, 0x03, 0x6b, 0x65, - 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, - 0x79, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x0d, 0x0a, 0x0b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x2d, 0x0a, 0x0c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, - 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x75, 0x6e, 0x74, 0x69, - 0x6d, 0x65, 0x49, 0x64, 0x22, 0x2d, 0x0a, 0x0a, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, - 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, - 0x02, 0x69, 0x64, 0x22, 0xaa, 0x01, 0x0a, 0x0b, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x5f, - 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x75, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x48, 0x6f, 0x73, 0x74, 0x12, 0x3a, 0x0a, 0x09, 0x73, 0x79, 0x6e, 0x63, - 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x75, 0x6e, - 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x4d, 0x6f, 0x64, 0x65, 0x52, 0x08, 0x73, 0x79, 0x6e, 0x63, - 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x3a, 0x0a, 0x0c, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x74, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x75, 0x6e, 0x69, - 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x52, 0x0b, 0x73, 0x79, 0x6e, 0x63, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, - 0x22, 0xd4, 0x01, 0x0a, 0x0e, 0x53, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0e, 0x6f, 0x6c, 0x64, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, - 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x6e, - 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x6f, 0x6c, 0x64, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3f, 0x0a, 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, - 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x40, 0x0a, 0x10, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x5f, 0x6c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x52, 0x0e, 0x6e, 0x65, 0x77, 0x41, 0x73, 0x73, 0x65, - 0x74, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x22, 0x0e, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x56, 0x0a, 0x0c, 0x53, 0x79, 0x6e, 0x63, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x10, 0x73, 0x79, 0x6e, 0x63, 0x65, - 0x64, 0x5f, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x1b, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x53, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x0f, - 0x73, 0x79, 0x6e, 0x63, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x73, 0x22, - 0x3e, 0x0a, 0x18, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x68, - 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, - 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x22, - 0x1e, 0x0a, 0x1c, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, - 0x60, 0x0a, 0x1d, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x3f, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x73, 0x22, 0x5d, 0x0a, 0x1a, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x3f, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, - 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, - 0x22, 0x1d, 0x0a, 0x1b, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x60, 0x0a, 0x1d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x3f, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x25, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x07, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x73, 0x22, 0x20, 0x0a, 0x1e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0xb5, 0x01, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f, 0x74, - 0x61, 0x6c, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x0e, 0x6e, 0x75, 0x6d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, - 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6e, 0x75, 0x6d, 0x54, 0x6f, - 0x74, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x75, 0x6d, - 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x73, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x0d, 0x6e, 0x75, 0x6d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x79, 0x6e, 0x63, - 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x70, - 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x6e, 0x75, 0x6d, - 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0xcd, 0x02, 0x0a, 0x0f, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, - 0x2a, 0x0a, 0x11, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x66, 0x69, - 0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x0f, 0x61, - 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x46, 0x69, 0x6c, - 0x74, 0x65, 0x72, 0x12, 0x48, 0x0a, 0x11, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, - 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x52, 0x0f, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x34, 0x0a, - 0x07, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, - 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x6f, 0x72, 0x74, 0x52, 0x06, 0x73, 0x6f, 0x72, - 0x74, 0x42, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, - 0x69, 0x6d, 0x69, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, - 0x74, 0x12, 0x38, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, - 0x70, 0x63, 0x2e, 0x53, 0x6f, 0x72, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x8d, 0x02, 0x0a, 0x12, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, - 0x6f, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4b, 0x65, 0x79, 0x12, - 0x21, 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x75, 0x70, 0x70, - 0x6c, 0x79, 0x12, 0x3f, 0x0a, 0x0c, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x5f, 0x61, 0x6e, 0x63, 0x68, - 0x6f, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, - 0x73, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x0b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6e, 0x63, - 0x68, 0x6f, 0x72, 0x12, 0x32, 0x0a, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, - 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x41, 0x73, 0x73, 0x65, 0x74, - 0x52, 0x05, 0x61, 0x73, 0x73, 0x65, 0x74, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, - 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x6f, - 0x74, 0x61, 0x6c, 0x53, 0x79, 0x6e, 0x63, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, - 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, - 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x22, 0xe5, 0x02, 0x0a, 0x0f, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, - 0x19, 0x0a, 0x08, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x07, 0x61, 0x73, 0x73, 0x65, 0x74, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x67, 0x65, - 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0c, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, - 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x75, 0x70, 0x70, - 0x6c, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x4e, 0x61, 0x6d, - 0x65, 0x12, 0x30, 0x0a, 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x61, 0x73, 0x73, 0x65, 0x74, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x68, - 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x67, 0x65, 0x6e, - 0x65, 0x73, 0x69, 0x73, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x2b, 0x0a, 0x11, 0x67, 0x65, - 0x6e, 0x65, 0x73, 0x69, 0x73, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x54, 0x69, - 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x6e, 0x63, 0x68, 0x6f, - 0x72, 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, - 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, - 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x5f, 0x64, 0x69, 0x73, 0x70, 0x6c, 0x61, 0x79, 0x18, 0x09, 0x20, - 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x6c, 0x44, 0x69, 0x73, 0x70, - 0x6c, 0x61, 0x79, 0x22, 0x56, 0x0a, 0x12, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x40, 0x0a, 0x0b, 0x61, 0x73, 0x73, - 0x65, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, - 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x52, - 0x0a, 0x61, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x22, 0x62, 0x0a, 0x12, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, - 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x74, 0x61, 0x72, - 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x23, 0x0a, 0x0d, 0x65, 0x6e, - 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x0c, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, - 0x51, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3a, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, - 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, - 0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x55, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e, - 0x74, 0x73, 0x22, 0x76, 0x0a, 0x15, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x65, 0x64, 0x55, 0x6e, 0x69, - 0x76, 0x65, 0x72, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, - 0x61, 0x74, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x12, - 0x1f, 0x0a, 0x0b, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x73, 0x79, 0x6e, 0x63, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, - 0x12, 0x28, 0x0a, 0x10, 0x6e, 0x65, 0x77, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x65, 0x76, - 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x6e, 0x65, 0x77, 0x50, - 0x72, 0x6f, 0x6f, 0x66, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xcf, 0x01, 0x0a, 0x1e, 0x53, - 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, - 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x57, 0x0a, - 0x13, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x75, 0x6e, 0x69, - 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x46, - 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x52, 0x11, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x79, 0x6e, 0x63, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, - 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, - 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x10, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x22, 0x21, 0x0a, 0x1f, - 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, - 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0xab, 0x01, 0x0a, 0x1a, 0x47, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x35, - 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, - 0x2e, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x6f, - 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, - 0x79, 0x6e, 0x63, 0x5f, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x49, 0x6e, 0x73, 0x65, 0x72, - 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, - 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x61, 0x6c, - 0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x45, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x94, 0x01, - 0x0a, 0x19, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1f, 0x0a, 0x02, 0x69, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2a, 0x0a, 0x11, - 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x69, 0x6e, 0x73, 0x65, 0x72, - 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79, - 0x6e, 0x63, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x12, 0x2a, 0x0a, 0x11, 0x61, 0x6c, 0x6c, 0x6f, - 0x77, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x65, 0x78, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x53, 0x79, 0x6e, 0x63, 0x45, 0x78, - 0x70, 0x6f, 0x72, 0x74, 0x22, 0x43, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, - 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, - 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1f, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, - 0x70, 0x63, 0x2e, 0x49, 0x44, 0x52, 0x02, 0x69, 0x64, 0x22, 0xd2, 0x01, 0x0a, 0x21, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, - 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, - 0x57, 0x0a, 0x13, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x75, - 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x47, 0x6c, 0x6f, 0x62, 0x61, - 0x6c, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x11, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x79, 0x6e, - 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x12, 0x54, 0x0a, 0x12, 0x61, 0x73, 0x73, 0x65, - 0x74, 0x5f, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, - 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x10, 0x61, 0x73, - 0x73, 0x65, 0x74, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73, 0x2a, 0x59, - 0x0a, 0x09, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x50, - 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, - 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x4f, 0x46, - 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x53, 0x53, 0x55, 0x41, 0x4e, 0x43, 0x45, 0x10, 0x01, - 0x12, 0x17, 0x0a, 0x13, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, - 0x52, 0x41, 0x4e, 0x53, 0x46, 0x45, 0x52, 0x10, 0x02, 0x2a, 0x39, 0x0a, 0x10, 0x55, 0x6e, 0x69, - 0x76, 0x65, 0x72, 0x73, 0x65, 0x53, 0x79, 0x6e, 0x63, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x0a, - 0x12, 0x53, 0x59, 0x4e, 0x43, 0x5f, 0x49, 0x53, 0x53, 0x55, 0x41, 0x4e, 0x43, 0x45, 0x5f, 0x4f, - 0x4e, 0x4c, 0x59, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x59, 0x4e, 0x43, 0x5f, 0x46, 0x55, - 0x4c, 0x4c, 0x10, 0x01, 0x2a, 0xd1, 0x01, 0x0a, 0x0e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x53, 0x6f, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x4f, 0x52, 0x54, 0x5f, - 0x42, 0x59, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52, - 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x4e, 0x41, 0x4d, 0x45, 0x10, - 0x01, 0x12, 0x14, 0x0a, 0x10, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x41, 0x53, 0x53, - 0x45, 0x54, 0x5f, 0x49, 0x44, 0x10, 0x02, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52, 0x54, 0x5f, - 0x42, 0x59, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x10, 0x03, 0x12, - 0x17, 0x0a, 0x13, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x54, 0x41, 0x4c, - 0x5f, 0x53, 0x59, 0x4e, 0x43, 0x53, 0x10, 0x04, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x4f, 0x52, 0x54, - 0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x54, 0x41, 0x4c, 0x5f, 0x50, 0x52, 0x4f, 0x4f, 0x46, 0x53, - 0x10, 0x05, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x47, 0x45, - 0x4e, 0x45, 0x53, 0x49, 0x53, 0x5f, 0x48, 0x45, 0x49, 0x47, 0x48, 0x54, 0x10, 0x06, 0x12, 0x18, - 0x0a, 0x14, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x59, 0x5f, 0x54, 0x4f, 0x54, 0x41, 0x4c, 0x5f, - 0x53, 0x55, 0x50, 0x50, 0x4c, 0x59, 0x10, 0x07, 0x2a, 0x40, 0x0a, 0x0d, 0x53, 0x6f, 0x72, 0x74, - 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x4f, 0x52, - 0x54, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x41, 0x53, 0x43, 0x10, - 0x00, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x4f, 0x52, 0x54, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, - 0x49, 0x4f, 0x4e, 0x5f, 0x44, 0x45, 0x53, 0x43, 0x10, 0x01, 0x2a, 0x5f, 0x0a, 0x0f, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x15, 0x0a, - 0x11, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x4e, 0x4f, - 0x4e, 0x45, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x41, - 0x53, 0x53, 0x45, 0x54, 0x5f, 0x4e, 0x4f, 0x52, 0x4d, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x1c, 0x0a, - 0x18, 0x46, 0x49, 0x4c, 0x54, 0x45, 0x52, 0x5f, 0x41, 0x53, 0x53, 0x45, 0x54, 0x5f, 0x43, 0x4f, - 0x4c, 0x4c, 0x45, 0x43, 0x54, 0x49, 0x42, 0x4c, 0x45, 0x10, 0x02, 0x32, 0xf6, 0x0c, 0x0a, 0x08, - 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x12, 0x59, 0x0a, 0x0e, 0x4d, 0x75, 0x6c, 0x74, - 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x22, 0x2e, 0x75, 0x6e, 0x69, - 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, - 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x6c, - 0x74, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x4b, 0x0a, 0x0a, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, - 0x73, 0x12, 0x1d, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x4e, 0x0a, 0x0f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, - 0x6f, 0x74, 0x73, 0x12, 0x1b, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, - 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x50, 0x0a, 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x52, - 0x6f, 0x6f, 0x74, 0x12, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, - 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x1a, 0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x55, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, - 0x65, 0x79, 0x73, 0x12, 0x21, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, - 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, 0x79, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, - 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, 0x66, 0x4b, 0x65, - 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0b, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x4c, 0x65, 0x61, 0x76, 0x65, 0x73, 0x12, 0x0f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x44, 0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x4c, 0x65, 0x61, - 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0a, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x4b, 0x65, - 0x79, 0x1a, 0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0b, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x6f, - 0x66, 0x12, 0x17, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x1a, 0x1f, 0x2e, 0x75, 0x6e, 0x69, - 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x74, 0x50, 0x72, - 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x09, 0x50, - 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x1d, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, - 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x50, 0x75, 0x73, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x49, 0x6e, 0x66, 0x6f, 0x12, - 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, - 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0c, 0x53, 0x79, 0x6e, 0x63, 0x55, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x12, 0x18, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, - 0x70, 0x63, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, - 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x79, 0x6e, - 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x15, 0x4c, 0x69, 0x73, - 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x73, 0x12, 0x29, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, - 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x4c, 0x69, 0x73, 0x74, - 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x13, 0x41, 0x64, 0x64, - 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x12, 0x27, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, - 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x75, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x41, 0x64, 0x64, 0x46, 0x65, 0x64, 0x65, 0x72, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x71, 0x0a, 0x16, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, 0x64, - 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x2a, 0x2e, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x75, 0x6e, 0x69, 0x76, - 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x46, 0x65, - 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x0d, 0x55, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x19, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, - 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, - 0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x50, - 0x0a, 0x0f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, - 0x73, 0x12, 0x1c, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x51, 0x75, 0x65, 0x72, 0x79, 0x1a, - 0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x55, 0x6e, - 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x12, 0x50, 0x0a, 0x0b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x12, - 0x1f, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x20, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x74, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x2b, 0x2e, - 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x46, - 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x75, 0x6e, 0x69, - 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x65, 0x74, 0x46, 0x65, 0x64, 0x65, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x7a, 0x0a, 0x19, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x2d, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, - 0x72, 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, - 0x70, 0x63, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x46, 0x65, 0x64, 0x65, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3c, 0x5a, 0x3a, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, - 0x6f, 0x6d, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x6c, 0x61, 0x62, 0x73, - 0x2f, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x6f, 0x74, 0x2d, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x2f, - 0x74, 0x61, 0x70, 0x72, 0x70, 0x63, 0x2f, 0x75, 0x6e, 0x69, 0x76, 0x65, 0x72, 0x73, 0x65, 0x72, - 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, -} +const file_universerpc_universe_proto_rawDesc = "" + + "\n" + + "\x1auniverserpc/universe.proto\x12\vuniverserpc\x1a\x13taprootassets.proto\"\x82\x01\n" + + "\x15MultiverseRootRequest\x125\n" + + "\n" + + "proof_type\x18\x01 \x01(\x0e2\x16.universerpc.ProofTypeR\tproofType\x122\n" + + "\fspecific_ids\x18\x02 \x03(\v2\x0f.universerpc.IDR\vspecificIds\"]\n" + + "\x16MultiverseRootResponse\x12C\n" + + "\x0fmultiverse_root\x18\x01 \x01(\v2\x1a.universerpc.MerkleSumNodeR\x0emultiverseRoot\"\xa7\x01\n" + + "\x10AssetRootRequest\x12+\n" + + "\x12with_amounts_by_id\x18\x01 \x01(\bR\x0fwithAmountsById\x12\x16\n" + + "\x06offset\x18\x02 \x01(\x05R\x06offset\x12\x14\n" + + "\x05limit\x18\x03 \x01(\x05R\x05limit\x128\n" + + "\tdirection\x18\x04 \x01(\x0e2\x1a.universerpc.SortDirectionR\tdirection\"G\n" + + "\rMerkleSumNode\x12\x1b\n" + + "\troot_hash\x18\x01 \x01(\fR\brootHash\x12\x19\n" + + "\broot_sum\x18\x02 \x01(\x03R\arootSum\"\xc7\x01\n" + + "\x02ID\x12\x1b\n" + + "\basset_id\x18\x01 \x01(\fH\x00R\aassetId\x12\"\n" + + "\fasset_id_str\x18\x02 \x01(\tH\x00R\n" + + "assetIdStr\x12\x1d\n" + + "\tgroup_key\x18\x03 \x01(\fH\x00R\bgroupKey\x12$\n" + + "\rgroup_key_str\x18\x04 \x01(\tH\x00R\vgroupKeyStr\x125\n" + + "\n" + + "proof_type\x18\x05 \x01(\x0e2\x16.universerpc.ProofTypeR\tproofTypeB\x04\n" + + "\x02id\"\xae\x02\n" + + "\fUniverseRoot\x12\x1f\n" + + "\x02id\x18\x01 \x01(\v2\x0f.universerpc.IDR\x02id\x129\n" + + "\n" + + "mssmt_root\x18\x03 \x01(\v2\x1a.universerpc.MerkleSumNodeR\tmssmtRoot\x12\x1d\n" + + "\n" + + "asset_name\x18\x04 \x01(\tR\tassetName\x12^\n" + + "\x13amounts_by_asset_id\x18\x05 \x03(\v2/.universerpc.UniverseRoot.AmountsByAssetIdEntryR\x10amountsByAssetId\x1aC\n" + + "\x15AmountsByAssetIdEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01\"\xca\x01\n" + + "\x11AssetRootResponse\x12X\n" + + "\x0euniverse_roots\x18\x01 \x03(\v21.universerpc.AssetRootResponse.UniverseRootsEntryR\runiverseRoots\x1a[\n" + + "\x12UniverseRootsEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12/\n" + + "\x05value\x18\x02 \x01(\v2\x19.universerpc.UniverseRootR\x05value:\x028\x01\"1\n" + + "\x0eAssetRootQuery\x12\x1f\n" + + "\x02id\x18\x01 \x01(\v2\x0f.universerpc.IDR\x02id\"\x93\x01\n" + + "\x11QueryRootResponse\x12>\n" + + "\rissuance_root\x18\x01 \x01(\v2\x19.universerpc.UniverseRootR\fissuanceRoot\x12>\n" + + "\rtransfer_root\x18\x02 \x01(\v2\x19.universerpc.UniverseRootR\ftransferRoot\"2\n" + + "\x0fDeleteRootQuery\x12\x1f\n" + + "\x02id\x18\x01 \x01(\v2\x0f.universerpc.IDR\x02id\"\x14\n" + + "\x12DeleteRootResponse\";\n" + + "\bOutpoint\x12\x19\n" + + "\bhash_str\x18\x01 \x01(\tR\ahashStr\x12\x14\n" + + "\x05index\x18\x02 \x01(\x05R\x05index\"\xba\x01\n" + + "\bAssetKey\x12\x17\n" + + "\x06op_str\x18\x01 \x01(\tH\x00R\x05opStr\x12'\n" + + "\x02op\x18\x02 \x01(\v2\x15.universerpc.OutpointH\x00R\x02op\x12*\n" + + "\x10script_key_bytes\x18\x03 \x01(\fH\x01R\x0escriptKeyBytes\x12&\n" + + "\x0escript_key_str\x18\x04 \x01(\tH\x01R\fscriptKeyStrB\n" + + "\n" + + "\boutpointB\f\n" + + "\n" + + "script_key\"\x9f\x01\n" + + "\x14AssetLeafKeysRequest\x12\x1f\n" + + "\x02id\x18\x01 \x01(\v2\x0f.universerpc.IDR\x02id\x12\x16\n" + + "\x06offset\x18\x02 \x01(\x05R\x06offset\x12\x14\n" + + "\x05limit\x18\x03 \x01(\x05R\x05limit\x128\n" + + "\tdirection\x18\x04 \x01(\x0e2\x1a.universerpc.SortDirectionR\tdirection\"L\n" + + "\x14AssetLeafKeyResponse\x124\n" + + "\n" + + "asset_keys\x18\x01 \x03(\v2\x15.universerpc.AssetKeyR\tassetKeys\"F\n" + + "\tAssetLeaf\x12#\n" + + "\x05asset\x18\x01 \x01(\v2\r.taprpc.AssetR\x05asset\x12\x14\n" + + "\x05proof\x18\x02 \x01(\fR\x05proof\"C\n" + + "\x11AssetLeafResponse\x12.\n" + + "\x06leaves\x18\x01 \x03(\v2\x16.universerpc.AssetLeafR\x06leaves\"`\n" + + "\vUniverseKey\x12\x1f\n" + + "\x02id\x18\x01 \x01(\v2\x0f.universerpc.IDR\x02id\x120\n" + + "\bleaf_key\x18\x02 \x01(\v2\x15.universerpc.AssetKeyR\aleafKey\"\xb4\x03\n" + + "\x12AssetProofResponse\x12*\n" + + "\x03req\x18\x01 \x01(\v2\x18.universerpc.UniverseKeyR\x03req\x12>\n" + + "\runiverse_root\x18\x02 \x01(\v2\x19.universerpc.UniverseRootR\funiverseRoot\x128\n" + + "\x18universe_inclusion_proof\x18\x03 \x01(\fR\x16universeInclusionProof\x125\n" + + "\n" + + "asset_leaf\x18\x04 \x01(\v2\x16.universerpc.AssetLeafR\tassetLeaf\x12C\n" + + "\x0fmultiverse_root\x18\x05 \x01(\v2\x1a.universerpc.MerkleSumNodeR\x0emultiverseRoot\x12<\n" + + "\x1amultiverse_inclusion_proof\x18\x06 \x01(\fR\x18multiverseInclusionProof\x12>\n" + + "\rissuance_data\x18\a \x01(\v2\x19.universerpc.IssuanceDataR\fissuanceData\"\xc2\x01\n" + + "\fIssuanceData\x122\n" + + "\vmeta_reveal\x18\x01 \x01(\v2\x11.taprpc.AssetMetaR\n" + + "metaReveal\x12<\n" + + "\x0egenesis_reveal\x18\x02 \x01(\v2\x15.taprpc.GenesisRevealR\rgenesisReveal\x12@\n" + + "\x10group_key_reveal\x18\x03 \x01(\v2\x16.taprpc.GroupKeyRevealR\x0egroupKeyReveal\"o\n" + + "\n" + + "AssetProof\x12*\n" + + "\x03key\x18\x01 \x01(\v2\x18.universerpc.UniverseKeyR\x03key\x125\n" + + "\n" + + "asset_leaf\x18\x04 \x01(\v2\x16.universerpc.AssetLeafR\tassetLeaf\"}\n" + + "\x10PushProofRequest\x12*\n" + + "\x03key\x18\x01 \x01(\v2\x18.universerpc.UniverseKeyR\x03key\x12=\n" + + "\x06server\x18\x02 \x01(\v2%.universerpc.UniverseFederationServerR\x06server\"?\n" + + "\x11PushProofResponse\x12*\n" + + "\x03key\x18\x01 \x01(\v2\x18.universerpc.UniverseKeyR\x03key\"\r\n" + + "\vInfoRequest\"-\n" + + "\fInfoResponse\x12\x1d\n" + + "\n" + + "runtime_id\x18\x01 \x01(\x03R\truntimeId\"-\n" + + "\n" + + "SyncTarget\x12\x1f\n" + + "\x02id\x18\x01 \x01(\v2\x0f.universerpc.IDR\x02id\"\xaa\x01\n" + + "\vSyncRequest\x12#\n" + + "\runiverse_host\x18\x01 \x01(\tR\funiverseHost\x12:\n" + + "\tsync_mode\x18\x02 \x01(\x0e2\x1d.universerpc.UniverseSyncModeR\bsyncMode\x12:\n" + + "\fsync_targets\x18\x03 \x03(\v2\x17.universerpc.SyncTargetR\vsyncTargets\"\xd4\x01\n" + + "\x0eSyncedUniverse\x12?\n" + + "\x0eold_asset_root\x18\x01 \x01(\v2\x19.universerpc.UniverseRootR\foldAssetRoot\x12?\n" + + "\x0enew_asset_root\x18\x02 \x01(\v2\x19.universerpc.UniverseRootR\fnewAssetRoot\x12@\n" + + "\x10new_asset_leaves\x18\x03 \x03(\v2\x16.universerpc.AssetLeafR\x0enewAssetLeaves\"\x0e\n" + + "\fStatsRequest\"V\n" + + "\fSyncResponse\x12F\n" + + "\x10synced_universes\x18\x01 \x03(\v2\x1b.universerpc.SyncedUniverseR\x0fsyncedUniverses\">\n" + + "\x18UniverseFederationServer\x12\x12\n" + + "\x04host\x18\x01 \x01(\tR\x04host\x12\x0e\n" + + "\x02id\x18\x02 \x01(\x05R\x02id\"\x1e\n" + + "\x1cListFederationServersRequest\"`\n" + + "\x1dListFederationServersResponse\x12?\n" + + "\aservers\x18\x01 \x03(\v2%.universerpc.UniverseFederationServerR\aservers\"]\n" + + "\x1aAddFederationServerRequest\x12?\n" + + "\aservers\x18\x01 \x03(\v2%.universerpc.UniverseFederationServerR\aservers\"\x1d\n" + + "\x1bAddFederationServerResponse\"`\n" + + "\x1dDeleteFederationServerRequest\x12?\n" + + "\aservers\x18\x01 \x03(\v2%.universerpc.UniverseFederationServerR\aservers\" \n" + + "\x1eDeleteFederationServerResponse\"\xb5\x01\n" + + "\rStatsResponse\x12(\n" + + "\x10num_total_assets\x18\x01 \x01(\x03R\x0enumTotalAssets\x12(\n" + + "\x10num_total_groups\x18\x02 \x01(\x03R\x0enumTotalGroups\x12&\n" + + "\x0fnum_total_syncs\x18\x03 \x01(\x03R\rnumTotalSyncs\x12(\n" + + "\x10num_total_proofs\x18\x04 \x01(\x03R\x0enumTotalProofs\"\xcd\x02\n" + + "\x0fAssetStatsQuery\x12*\n" + + "\x11asset_name_filter\x18\x01 \x01(\tR\x0fassetNameFilter\x12&\n" + + "\x0fasset_id_filter\x18\x02 \x01(\fR\rassetIdFilter\x12H\n" + + "\x11asset_type_filter\x18\x03 \x01(\x0e2\x1c.universerpc.AssetTypeFilterR\x0fassetTypeFilter\x124\n" + + "\asort_by\x18\x04 \x01(\x0e2\x1b.universerpc.AssetQuerySortR\x06sortBy\x12\x16\n" + + "\x06offset\x18\x05 \x01(\x05R\x06offset\x12\x14\n" + + "\x05limit\x18\x06 \x01(\x05R\x05limit\x128\n" + + "\tdirection\x18\a \x01(\x0e2\x1a.universerpc.SortDirectionR\tdirection\"\x8d\x02\n" + + "\x12AssetStatsSnapshot\x12\x1b\n" + + "\tgroup_key\x18\x01 \x01(\fR\bgroupKey\x12!\n" + + "\fgroup_supply\x18\x02 \x01(\x03R\vgroupSupply\x12?\n" + + "\fgroup_anchor\x18\x03 \x01(\v2\x1c.universerpc.AssetStatsAssetR\vgroupAnchor\x122\n" + + "\x05asset\x18\x04 \x01(\v2\x1c.universerpc.AssetStatsAssetR\x05asset\x12\x1f\n" + + "\vtotal_syncs\x18\x05 \x01(\x03R\n" + + "totalSyncs\x12!\n" + + "\ftotal_proofs\x18\x06 \x01(\x03R\vtotalProofs\"\xe5\x02\n" + + "\x0fAssetStatsAsset\x12\x19\n" + + "\basset_id\x18\x01 \x01(\fR\aassetId\x12#\n" + + "\rgenesis_point\x18\x02 \x01(\tR\fgenesisPoint\x12!\n" + + "\ftotal_supply\x18\x03 \x01(\x03R\vtotalSupply\x12\x1d\n" + + "\n" + + "asset_name\x18\x04 \x01(\tR\tassetName\x120\n" + + "\n" + + "asset_type\x18\x05 \x01(\x0e2\x11.taprpc.AssetTypeR\tassetType\x12%\n" + + "\x0egenesis_height\x18\x06 \x01(\x05R\rgenesisHeight\x12+\n" + + "\x11genesis_timestamp\x18\a \x01(\x03R\x10genesisTimestamp\x12!\n" + + "\fanchor_point\x18\b \x01(\tR\vanchorPoint\x12'\n" + + "\x0fdecimal_display\x18\t \x01(\rR\x0edecimalDisplay\"V\n" + + "\x12UniverseAssetStats\x12@\n" + + "\vasset_stats\x18\x01 \x03(\v2\x1f.universerpc.AssetStatsSnapshotR\n" + + "assetStats\"b\n" + + "\x12QueryEventsRequest\x12'\n" + + "\x0fstart_timestamp\x18\x01 \x01(\x03R\x0estartTimestamp\x12#\n" + + "\rend_timestamp\x18\x02 \x01(\x03R\fendTimestamp\"Q\n" + + "\x13QueryEventsResponse\x12:\n" + + "\x06events\x18\x01 \x03(\v2\".universerpc.GroupedUniverseEventsR\x06events\"v\n" + + "\x15GroupedUniverseEvents\x12\x12\n" + + "\x04date\x18\x01 \x01(\tR\x04date\x12\x1f\n" + + "\vsync_events\x18\x02 \x01(\x04R\n" + + "syncEvents\x12(\n" + + "\x10new_proof_events\x18\x03 \x01(\x04R\x0enewProofEvents\"\xcf\x01\n" + + "\x1eSetFederationSyncConfigRequest\x12W\n" + + "\x13global_sync_configs\x18\x01 \x03(\v2'.universerpc.GlobalFederationSyncConfigR\x11globalSyncConfigs\x12T\n" + + "\x12asset_sync_configs\x18\x02 \x03(\v2&.universerpc.AssetFederationSyncConfigR\x10assetSyncConfigs\"!\n" + + "\x1fSetFederationSyncConfigResponse\"\xab\x01\n" + + "\x1aGlobalFederationSyncConfig\x125\n" + + "\n" + + "proof_type\x18\x01 \x01(\x0e2\x16.universerpc.ProofTypeR\tproofType\x12*\n" + + "\x11allow_sync_insert\x18\x02 \x01(\bR\x0fallowSyncInsert\x12*\n" + + "\x11allow_sync_export\x18\x03 \x01(\bR\x0fallowSyncExport\"\x94\x01\n" + + "\x19AssetFederationSyncConfig\x12\x1f\n" + + "\x02id\x18\x01 \x01(\v2\x0f.universerpc.IDR\x02id\x12*\n" + + "\x11allow_sync_insert\x18\x02 \x01(\bR\x0fallowSyncInsert\x12*\n" + + "\x11allow_sync_export\x18\x03 \x01(\bR\x0fallowSyncExport\"C\n" + + " QueryFederationSyncConfigRequest\x12\x1f\n" + + "\x02id\x18\x01 \x03(\v2\x0f.universerpc.IDR\x02id\"\xd2\x01\n" + + "!QueryFederationSyncConfigResponse\x12W\n" + + "\x13global_sync_configs\x18\x01 \x03(\v2'.universerpc.GlobalFederationSyncConfigR\x11globalSyncConfigs\x12T\n" + + "\x12asset_sync_configs\x18\x02 \x03(\v2&.universerpc.AssetFederationSyncConfigR\x10assetSyncConfigs*Y\n" + + "\tProofType\x12\x1a\n" + + "\x16PROOF_TYPE_UNSPECIFIED\x10\x00\x12\x17\n" + + "\x13PROOF_TYPE_ISSUANCE\x10\x01\x12\x17\n" + + "\x13PROOF_TYPE_TRANSFER\x10\x02*9\n" + + "\x10UniverseSyncMode\x12\x16\n" + + "\x12SYNC_ISSUANCE_ONLY\x10\x00\x12\r\n" + + "\tSYNC_FULL\x10\x01*\xd1\x01\n" + + "\x0eAssetQuerySort\x12\x10\n" + + "\fSORT_BY_NONE\x10\x00\x12\x16\n" + + "\x12SORT_BY_ASSET_NAME\x10\x01\x12\x14\n" + + "\x10SORT_BY_ASSET_ID\x10\x02\x12\x16\n" + + "\x12SORT_BY_ASSET_TYPE\x10\x03\x12\x17\n" + + "\x13SORT_BY_TOTAL_SYNCS\x10\x04\x12\x18\n" + + "\x14SORT_BY_TOTAL_PROOFS\x10\x05\x12\x1a\n" + + "\x16SORT_BY_GENESIS_HEIGHT\x10\x06\x12\x18\n" + + "\x14SORT_BY_TOTAL_SUPPLY\x10\a*@\n" + + "\rSortDirection\x12\x16\n" + + "\x12SORT_DIRECTION_ASC\x10\x00\x12\x17\n" + + "\x13SORT_DIRECTION_DESC\x10\x01*_\n" + + "\x0fAssetTypeFilter\x12\x15\n" + + "\x11FILTER_ASSET_NONE\x10\x00\x12\x17\n" + + "\x13FILTER_ASSET_NORMAL\x10\x01\x12\x1c\n" + + "\x18FILTER_ASSET_COLLECTIBLE\x10\x022\xf6\f\n" + + "\bUniverse\x12Y\n" + + "\x0eMultiverseRoot\x12\".universerpc.MultiverseRootRequest\x1a#.universerpc.MultiverseRootResponse\x12K\n" + + "\n" + + "AssetRoots\x12\x1d.universerpc.AssetRootRequest\x1a\x1e.universerpc.AssetRootResponse\x12N\n" + + "\x0fQueryAssetRoots\x12\x1b.universerpc.AssetRootQuery\x1a\x1e.universerpc.QueryRootResponse\x12P\n" + + "\x0fDeleteAssetRoot\x12\x1c.universerpc.DeleteRootQuery\x1a\x1f.universerpc.DeleteRootResponse\x12U\n" + + "\rAssetLeafKeys\x12!.universerpc.AssetLeafKeysRequest\x1a!.universerpc.AssetLeafKeyResponse\x12>\n" + + "\vAssetLeaves\x12\x0f.universerpc.ID\x1a\x1e.universerpc.AssetLeafResponse\x12G\n" + + "\n" + + "QueryProof\x12\x18.universerpc.UniverseKey\x1a\x1f.universerpc.AssetProofResponse\x12G\n" + + "\vInsertProof\x12\x17.universerpc.AssetProof\x1a\x1f.universerpc.AssetProofResponse\x12J\n" + + "\tPushProof\x12\x1d.universerpc.PushProofRequest\x1a\x1e.universerpc.PushProofResponse\x12;\n" + + "\x04Info\x12\x18.universerpc.InfoRequest\x1a\x19.universerpc.InfoResponse\x12C\n" + + "\fSyncUniverse\x12\x18.universerpc.SyncRequest\x1a\x19.universerpc.SyncResponse\x12n\n" + + "\x15ListFederationServers\x12).universerpc.ListFederationServersRequest\x1a*.universerpc.ListFederationServersResponse\x12h\n" + + "\x13AddFederationServer\x12'.universerpc.AddFederationServerRequest\x1a(.universerpc.AddFederationServerResponse\x12q\n" + + "\x16DeleteFederationServer\x12*.universerpc.DeleteFederationServerRequest\x1a+.universerpc.DeleteFederationServerResponse\x12F\n" + + "\rUniverseStats\x12\x19.universerpc.StatsRequest\x1a\x1a.universerpc.StatsResponse\x12P\n" + + "\x0fQueryAssetStats\x12\x1c.universerpc.AssetStatsQuery\x1a\x1f.universerpc.UniverseAssetStats\x12P\n" + + "\vQueryEvents\x12\x1f.universerpc.QueryEventsRequest\x1a .universerpc.QueryEventsResponse\x12t\n" + + "\x17SetFederationSyncConfig\x12+.universerpc.SetFederationSyncConfigRequest\x1a,.universerpc.SetFederationSyncConfigResponse\x12z\n" + + "\x19QueryFederationSyncConfig\x12-.universerpc.QueryFederationSyncConfigRequest\x1a..universerpc.QueryFederationSyncConfigResponseB