diff --git a/app/upgrade.go b/app/upgrade.go index cc1dc0bf2..7d4e34531 100644 --- a/app/upgrade.go +++ b/app/upgrade.go @@ -227,6 +227,7 @@ func (app *App) registerSerengetiUpgradeHandler() { app.GashubKeeper.SetMsgGasParams(ctx, *gashubtypes.NewMsgGasParamsWithFixedGas(sdk.MsgTypeURL(&storagemoduletypes.MsgDelegateCreateObject{}), 1.2e3)) app.GashubKeeper.SetMsgGasParams(ctx, *gashubtypes.NewMsgGasParamsWithFixedGas(sdk.MsgTypeURL(&storagemoduletypes.MsgDelegateUpdateObjectContent{}), 1.2e3)) app.GashubKeeper.SetMsgGasParams(ctx, *gashubtypes.NewMsgGasParamsWithFixedGas(sdk.MsgTypeURL(&storagemoduletypes.MsgSealObjectV2{}), 1.2e2)) + app.GashubKeeper.SetMsgGasParams(ctx, *gashubtypes.NewMsgGasParamsWithFixedGas(sdk.MsgTypeURL(&storagemoduletypes.MsgSetBucketFlowRateLimit{}), 1.2e3)) return app.mm.RunMigrations(ctx, app.configurator, fromVM) }) diff --git a/e2e/tests/storage_rate_limit_test.go b/e2e/tests/storage_rate_limit_test.go new file mode 100644 index 000000000..e2e01bd8d --- /dev/null +++ b/e2e/tests/storage_rate_limit_test.go @@ -0,0 +1,406 @@ +package tests + +import ( + "bytes" + "context" + "fmt" + "math" + + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + + storageutils "github.com/bnb-chain/greenfield/testutil/storage" + storagetypes "github.com/bnb-chain/greenfield/x/storage/types" +) + +func (s *StorageTestSuite) TestSetBucketRateLimitToZero() { + var err error + sp := s.BaseSuite.PickStorageProvider() + gvg, found := sp.GetFirstGlobalVirtualGroup() + s.Require().True(found) + user := s.User + // CreateBucket + bucketName := storageutils.GenRandomBucketName() + msgCreateBucket := storagetypes.NewMsgCreateBucket( + user.GetAddr(), bucketName, storagetypes.VISIBILITY_TYPE_PUBLIC_READ, sp.OperatorKey.GetAddr(), + nil, math.MaxUint, nil, 10000000) + msgCreateBucket.PrimarySpApproval.GlobalVirtualGroupFamilyId = gvg.FamilyId + msgCreateBucket.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateBucket.GetApprovalBytes()) + s.Require().NoError(err) + s.SendTxBlock(user, msgCreateBucket) + + // HeadBucket + ctx := context.Background() + queryHeadBucketRequest := storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err := s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.BucketName, bucketName) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.Owner, user.GetAddr().String()) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.GlobalVirtualGroupFamilyId, gvg.FamilyId) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.PaymentAddress, user.GetAddr().String()) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.Visibility, storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.SourceType, storagetypes.SOURCE_TYPE_ORIGIN) + + queryQuotaUpdateTimeResponse, err := s.Client.QueryQuotaUpdateTime(ctx, &storagetypes.QueryQuoteUpdateTimeRequest{ + BucketName: bucketName, + }) + s.Require().NoError(err) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.CreateAt, queryQuotaUpdateTimeResponse.UpdateAt) + + fmt.Printf("User: %s\n", s.User.GetAddr().String()) + fmt.Printf("queryHeadBucketResponse.BucketInfo.Owner: %s\n", queryHeadBucketResponse.BucketInfo.Owner) + fmt.Printf("queryHeadBucketResponse.BucketInfo.PaymentAccount: %s\n", queryHeadBucketResponse.BucketInfo.PaymentAddress) + + // SetBucketRateLimit + msgSetBucketRateLimit := storagetypes.NewMsgSetBucketFlowRateLimit(s.User.GetAddr(), s.User.GetAddr(), s.User.GetAddr(), bucketName, sdkmath.NewInt(0)) + s.SendTxBlock(s.User, msgSetBucketRateLimit) + + queryHeadBucketRequest = storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err = s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + + s.Require().Equal(queryHeadBucketResponse.ExtraInfo.IsRateLimited, true) + s.Require().Equal(queryHeadBucketResponse.ExtraInfo.FlowRateLimit.String(), "0") + + // CreateObject + objectName := storageutils.GenRandomObjectName() + // create test buffer + var buffer bytes.Buffer + // Create 1MiB content where each line contains 1024 characters. + for i := 0; i < 1024; i++ { + buffer.WriteString(fmt.Sprintf("[%05d] %s\n", i, line)) + } + payloadSize := buffer.Len() + checksum := sdk.Keccak256(buffer.Bytes()) + expectChecksum := [][]byte{checksum, checksum, checksum, checksum, checksum, checksum, checksum} + contextType := "text/event-stream" + msgCreateObject := storagetypes.NewMsgCreateObject(user.GetAddr(), bucketName, objectName, uint64(payloadSize), storagetypes.VISIBILITY_TYPE_PRIVATE, expectChecksum, contextType, storagetypes.REDUNDANCY_EC_TYPE, math.MaxUint, nil) + msgCreateObject.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateObject.GetApprovalBytes()) + s.Require().NoError(err) + s.SendTxBlockWithExpectErrorString(msgCreateObject, user, "greater than the flow rate limit") +} + +// TestNotOwnerSetBucketRateLimit_Object +// 1. user create a bucket with 0 read quota +// 2. the payment account set the rate limit +// 3. user create an object in the bucket +// 4. the payment account set the rate limit to 0 +// 5. user create an object in the bucket and it should fail +// 6. the payment account set the rate limit to a positive number +// 7. user create an object in the bucket and it should pass +func (s *StorageTestSuite) TestNotOwnerSetBucketRateLimit_Object() { + var err error + sp := s.BaseSuite.PickStorageProvider() + gvg, found := sp.GetFirstGlobalVirtualGroup() + s.Require().True(found) + user := s.User + paymentAcc := s.GenAndChargeAccounts(1, 1000000)[0] + + // CreateBucket + bucketName := storageutils.GenRandomBucketName() + + msgCreateBucket := storagetypes.NewMsgCreateBucket( + user.GetAddr(), bucketName, storagetypes.VISIBILITY_TYPE_PUBLIC_READ, sp.OperatorKey.GetAddr(), + paymentAcc.GetAddr(), math.MaxUint, nil, 0) + msgCreateBucket.PrimarySpApproval.GlobalVirtualGroupFamilyId = gvg.FamilyId + msgCreateBucket.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateBucket.GetApprovalBytes()) + s.Require().NoError(err) + s.SendTxBlock(user, msgCreateBucket) + + // HeadBucket + ctx := context.Background() + queryHeadBucketRequest := storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err := s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.BucketName, bucketName) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.Owner, user.GetAddr().String()) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.GlobalVirtualGroupFamilyId, gvg.FamilyId) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.PaymentAddress, paymentAcc.GetAddr().String()) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.Visibility, storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.SourceType, storagetypes.SOURCE_TYPE_ORIGIN) + + queryQuotaUpdateTimeResponse, err := s.Client.QueryQuotaUpdateTime(ctx, &storagetypes.QueryQuoteUpdateTimeRequest{ + BucketName: bucketName, + }) + s.Require().NoError(err) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.CreateAt, queryQuotaUpdateTimeResponse.UpdateAt) + + // SetBucketRateLimit + msgSetBucketRateLimit := storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(100000000000000)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + // CreateObject + objectName := storageutils.GenRandomObjectName() + // create test buffer + var buffer bytes.Buffer + // Create 1MiB content where each line contains 1024 characters. + for i := 0; i < 1024; i++ { + buffer.WriteString(fmt.Sprintf("[%05d] %s\n", i, line)) + } + payloadSize := buffer.Len() + checksum := sdk.Keccak256(buffer.Bytes()) + expectChecksum := [][]byte{checksum, checksum, checksum, checksum, checksum, checksum, checksum} + contextType := "text/event-stream" + msgCreateObject := storagetypes.NewMsgCreateObject(user.GetAddr(), bucketName, objectName, uint64(payloadSize), storagetypes.VISIBILITY_TYPE_PRIVATE, expectChecksum, contextType, storagetypes.REDUNDANCY_EC_TYPE, math.MaxUint, nil) + msgCreateObject.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateObject.GetApprovalBytes()) + s.Require().NoError(err) + s.SendTxBlock(user, msgCreateObject) + + // SetBucketRateLimit + msgSetBucketRateLimit = storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(0)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + // CreateObject + objectName = storageutils.GenRandomObjectName() + msgCreateObject = storagetypes.NewMsgCreateObject(user.GetAddr(), bucketName, objectName, uint64(payloadSize), storagetypes.VISIBILITY_TYPE_PRIVATE, expectChecksum, contextType, storagetypes.REDUNDANCY_EC_TYPE, math.MaxUint, nil) + msgCreateObject.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateObject.GetApprovalBytes()) + s.Require().NoError(err) + s.SendTxBlockWithExpectErrorString(msgCreateObject, user, "greater than the flow rate limit") + + // SetBucketRateLimit + msgSetBucketRateLimit = storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(100000000000000)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + // create object + objectName = storageutils.GenRandomObjectName() + msgCreateObject = storagetypes.NewMsgCreateObject(user.GetAddr(), bucketName, objectName, uint64(payloadSize), storagetypes.VISIBILITY_TYPE_PRIVATE, expectChecksum, contextType, storagetypes.REDUNDANCY_EC_TYPE, math.MaxUint, nil) + msgCreateObject.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateObject.GetApprovalBytes()) + s.Require().NoError(err) + + s.SendTxBlock(user, msgCreateObject) +} + +// TestNotOwnerSetBucketRateLimit_Bucket +// 1. user create a bucket with 0 read quota +// 2. the payment account set the rate limit +// 3. user update the read quota to a positive number +// 4. the payment account set the rate limit to 0 +// 5. user update the read quota to a positive number and it should fail +// 6. the payment account set the rate limit to a positive number +// 7. user update the read quota to a positive number and it should pass +func (s *StorageTestSuite) TestNotOwnerSetBucketRateLimit_Bucket() { + var err error + sp := s.BaseSuite.PickStorageProvider() + gvg, found := sp.GetFirstGlobalVirtualGroup() + s.Require().True(found) + user := s.User + paymentAcc := s.GenAndChargeAccounts(1, 1000000)[0] + + // CreateBucket + bucketName := storageutils.GenRandomBucketName() + + msgCreateBucket := storagetypes.NewMsgCreateBucket( + user.GetAddr(), bucketName, storagetypes.VISIBILITY_TYPE_PUBLIC_READ, sp.OperatorKey.GetAddr(), + paymentAcc.GetAddr(), math.MaxUint, nil, 0) + msgCreateBucket.PrimarySpApproval.GlobalVirtualGroupFamilyId = gvg.FamilyId + msgCreateBucket.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateBucket.GetApprovalBytes()) + s.Require().NoError(err) + s.SendTxBlock(user, msgCreateBucket) + + // HeadBucket + ctx := context.Background() + queryHeadBucketRequest := storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err := s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.BucketName, bucketName) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.Owner, user.GetAddr().String()) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.GlobalVirtualGroupFamilyId, gvg.FamilyId) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.PaymentAddress, paymentAcc.GetAddr().String()) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.Visibility, storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.SourceType, storagetypes.SOURCE_TYPE_ORIGIN) + + queryQuotaUpdateTimeResponse, err := s.Client.QueryQuotaUpdateTime(ctx, &storagetypes.QueryQuoteUpdateTimeRequest{ + BucketName: bucketName, + }) + s.Require().NoError(err) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.CreateAt, queryQuotaUpdateTimeResponse.UpdateAt) + + // SetBucketRateLimit + msgSetBucketRateLimit := storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(100000000000)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + // UpdateBucketInfo + var readQuota uint64 = 100 + msgUpdateBucketInfo := storagetypes.NewMsgUpdateBucketInfo( + user.GetAddr(), bucketName, &readQuota, nil, storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.SendTxBlock(user, msgUpdateBucketInfo) + + // SetBucketRateLimit + msgSetBucketRateLimit = storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(0)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + queryHeadBucketRequest = storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err = s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + + s.Require().Equal(queryHeadBucketResponse.ExtraInfo.IsRateLimited, true) + + // update bucket + readQuota = 101 + msgUpdateBucketInfo = storagetypes.NewMsgUpdateBucketInfo( + user.GetAddr(), bucketName, &readQuota, nil, storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.SendTxBlockWithExpectErrorString(msgUpdateBucketInfo, user, "payment account is not changed but the bucket is limited") + + // SetBucketRateLimit + msgSetBucketRateLimit = storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(100000000000)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + queryHeadBucketRequest = storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err = s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + + s.Require().Equal(queryHeadBucketResponse.ExtraInfo.IsRateLimited, false) + + // update bucket + readQuota = 102 + msgUpdateBucketInfo = storagetypes.NewMsgUpdateBucketInfo( + user.GetAddr(), bucketName, &readQuota, nil, storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.SendTxBlock(user, msgUpdateBucketInfo) +} + +// TestNotOwnerSetBucketRateLimit_BucketPaymentAccount +// 1. user create a bucket with positive read quota +// 2. user set the rate limit to 0 +// 3. update the payment account to another payment account, it should fail +// 4. the payment account set the rate limit to 0 +// 5. user update the payment account to another payment account, it should fail +// 6. the payment account set the rate limit to a positive number +// 7. user update the payment account to another payment account, it should pass +func (s *StorageTestSuite) TestNotOwnerSetBucketRateLimit_BucketPaymentAccount() { + var err error + sp := s.BaseSuite.PickStorageProvider() + gvg, found := sp.GetFirstGlobalVirtualGroup() + s.Require().True(found) + user := s.User + paymentAcc := s.GenAndChargeAccounts(1, 1000000)[0] + + // CreateBucket + bucketName := storageutils.GenRandomBucketName() + + msgCreateBucket := storagetypes.NewMsgCreateBucket( + user.GetAddr(), bucketName, storagetypes.VISIBILITY_TYPE_PUBLIC_READ, sp.OperatorKey.GetAddr(), + user.GetAddr(), math.MaxUint, nil, 100) + msgCreateBucket.PrimarySpApproval.GlobalVirtualGroupFamilyId = gvg.FamilyId + msgCreateBucket.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateBucket.GetApprovalBytes()) + s.Require().NoError(err) + s.SendTxBlock(user, msgCreateBucket) + + // HeadBucket + ctx := context.Background() + queryHeadBucketRequest := storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err := s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.BucketName, bucketName) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.Owner, user.GetAddr().String()) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.GlobalVirtualGroupFamilyId, gvg.FamilyId) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.PaymentAddress, s.User.GetAddr().String()) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.Visibility, storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.SourceType, storagetypes.SOURCE_TYPE_ORIGIN) + + queryQuotaUpdateTimeResponse, err := s.Client.QueryQuotaUpdateTime(ctx, &storagetypes.QueryQuoteUpdateTimeRequest{ + BucketName: bucketName, + }) + s.Require().NoError(err) + s.Require().Equal(queryHeadBucketResponse.BucketInfo.CreateAt, queryQuotaUpdateTimeResponse.UpdateAt) + + // SetBucketRateLimit + msgSetBucketRateLimit := storagetypes.NewMsgSetBucketFlowRateLimit(s.User.GetAddr(), s.User.GetAddr(), s.User.GetAddr(), bucketName, sdkmath.NewInt(0)) + s.SendTxBlock(s.User, msgSetBucketRateLimit) + + // SetBucketRateLimit + msgUpdateBucketInfo := storagetypes.NewMsgUpdateBucketInfo( + user.GetAddr(), bucketName, nil, paymentAcc.GetAddr(), storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.SendTxBlockWithExpectErrorString(msgUpdateBucketInfo, user, "the flow rate limit is not set") + + // SetBucketRateLimit + msgSetBucketRateLimit = storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(0)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + queryHeadBucketRequest = storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err = s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + + s.Require().Equal(queryHeadBucketResponse.ExtraInfo.IsRateLimited, true) + + // UpdateBucketInfo + msgUpdateBucketInfo = storagetypes.NewMsgUpdateBucketInfo( + user.GetAddr(), bucketName, nil, paymentAcc.GetAddr(), storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.SendTxBlockWithExpectErrorString(msgUpdateBucketInfo, user, "greater than the flow rate limit") + + // SetBucketRateLimit + msgSetBucketRateLimit = storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(100000000000000)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + // UpdateBucketInfo + msgUpdateBucketInfo = storagetypes.NewMsgUpdateBucketInfo( + user.GetAddr(), bucketName, nil, paymentAcc.GetAddr(), storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.SendTxBlock(user, msgUpdateBucketInfo) + + queryHeadBucketRequest = storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err = s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + + s.Require().Equal(queryHeadBucketResponse.ExtraInfo.IsRateLimited, false) +} + +func (s *StorageTestSuite) TestQueryBucketRateLimit() { + var err error + sp := s.BaseSuite.PickStorageProvider() + gvg, found := sp.GetFirstGlobalVirtualGroup() + s.Require().True(found) + user := s.User + paymentAcc := s.GenAndChargeAccounts(1, 1000000)[0] + + // CreateBucket + bucketName := storageutils.GenRandomBucketName() + + msgCreateBucket := storagetypes.NewMsgCreateBucket( + user.GetAddr(), bucketName, storagetypes.VISIBILITY_TYPE_PUBLIC_READ, sp.OperatorKey.GetAddr(), + paymentAcc.GetAddr(), math.MaxUint, nil, 0) + msgCreateBucket.PrimarySpApproval.GlobalVirtualGroupFamilyId = gvg.FamilyId + msgCreateBucket.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateBucket.GetApprovalBytes()) + s.Require().NoError(err) + s.SendTxBlock(user, msgCreateBucket) + + // SetBucketRateLimit + msgSetBucketRateLimit := storagetypes.NewMsgSetBucketFlowRateLimit(paymentAcc.GetAddr(), s.User.GetAddr(), paymentAcc.GetAddr(), bucketName, sdkmath.NewInt(100000000000000)) + s.SendTxBlock(paymentAcc, msgSetBucketRateLimit) + + // update bucket + var readQuota uint64 = 100 + msgUpdateBucketInfo := storagetypes.NewMsgUpdateBucketInfo( + user.GetAddr(), bucketName, &readQuota, nil, storagetypes.VISIBILITY_TYPE_PUBLIC_READ) + s.SendTxBlock(user, msgUpdateBucketInfo) + + s.Require().NoError(err) + + // QueryBucketRateLimit + ctx := context.Background() + queryBucketRateLimitRequest := storagetypes.QueryPaymentAccountBucketFlowRateLimitRequest{ + PaymentAccount: paymentAcc.GetAddr().String(), + BucketName: bucketName, + BucketOwner: user.GetAddr().String(), + } + queryBucketRateLimitResponse, err := s.Client.QueryPaymentAccountBucketFlowRateLimit(ctx, &queryBucketRateLimitRequest) + s.Require().NoError(err) + s.Require().Equal(queryBucketRateLimitResponse.IsSet, true) + s.Require().Equal(queryBucketRateLimitResponse.FlowRateLimit, sdkmath.NewInt(100000000000000)) +} diff --git a/proto/greenfield/storage/common.proto b/proto/greenfield/storage/common.proto index 83dbbd9a8..73388c209 100644 --- a/proto/greenfield/storage/common.proto +++ b/proto/greenfield/storage/common.proto @@ -110,3 +110,19 @@ message LocalVirtualGroup { // Notice that the minimum unit of charge is 128K uint64 total_charge_size = 4; } + +message BucketFlowRateLimit { + // flow_rate_limit defines the flow rate limit of the bucket + string flow_rate_limit = 1 [ + (cosmos_proto.scalar) = "cosmos.Int", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; +} + +message BucketFlowRateLimitStatus { + // is_bucket_limited defines the flow rate limit status of the bucket, true means limited and the bucket is uncharged + bool is_bucket_limited = 1; + // payment_address is the payment address of the bucket which limited the flow rate + string payment_address = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"]; +} diff --git a/proto/greenfield/storage/events.proto b/proto/greenfield/storage/events.proto index 58e8b1562..e3f5149fa 100644 --- a/proto/greenfield/storage/events.proto +++ b/proto/greenfield/storage/events.proto @@ -631,3 +631,27 @@ message EventCancelUpdateObjectContent { (gogoproto.nullable) = false ]; } + +message EventSetBucketFlowRateLimit { + // operator define the account address of operator who set the bucket flow rate limit + string operator = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // bucket_name define the name of the bucket + string bucket_name = 2; + // payment_address define the payment address for the bucket + string payment_address = 3 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // bucket_owner define the intended owner of the bucket + string bucket_owner = 4 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // flow_rate_limit define the flow rate limit of the bucket + string flow_rate_limit = 5 [ + (cosmos_proto.scalar) = "cosmos.Int", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; +} + +message EventBucketFlowRateLimitStatus { + // bucket_name define the name of the bucket + string bucket_name = 1; + // is_limited define the status of the bucket flow rate limit + bool is_limited = 2; +} diff --git a/proto/greenfield/storage/query.proto b/proto/greenfield/storage/query.proto index 34ecb5c48..abd498557 100644 --- a/proto/greenfield/storage/query.proto +++ b/proto/greenfield/storage/query.proto @@ -150,6 +150,11 @@ service Query { rpc QueryGroupsExistById(QueryGroupsExistByIdRequest) returns (QueryGroupsExistResponse) { option (google.api.http).get = "/greenfield/storage/groups_exist_by_id/{group_ids}"; } + + // Queries the flow rate limit of a bucket for a payment account + rpc QueryPaymentAccountBucketFlowRateLimit(QueryPaymentAccountBucketFlowRateLimitRequest) returns (QueryPaymentAccountBucketFlowRateLimitResponse) { + option (google.api.http).get = "/greenfield/storage/payment_account_bucket_flow_rate_limit/{payment_account}/{bucket_name}"; + } } // QueryParamsRequest is request type for the Query/Params RPC method. @@ -183,6 +188,7 @@ message QueryHeadBucketByIdRequest { message QueryHeadBucketResponse { BucketInfo bucket_info = 1; + BucketExtraInfo extra_info = 2; } message QueryHeadObjectRequest { @@ -416,3 +422,18 @@ message QueryGroupsExistByIdRequest { message QueryGroupsExistResponse { map exists = 1; } + +message QueryPaymentAccountBucketFlowRateLimitRequest { + string payment_account = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + string bucket_owner = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + string bucket_name = 3; +} + +message QueryPaymentAccountBucketFlowRateLimitResponse { + bool is_set = 1; + string flow_rate_limit = 2 [ + (cosmos_proto.scalar) = "cosmos.Int", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; +} diff --git a/proto/greenfield/storage/tx.proto b/proto/greenfield/storage/tx.proto index 7c27c9a72..70da3e2f8 100644 --- a/proto/greenfield/storage/tx.proto +++ b/proto/greenfield/storage/tx.proto @@ -67,6 +67,8 @@ service Msg { // Since: Manchurian upgrade rpc SetTag(MsgSetTag) returns (MsgSetTagResponse); + + rpc SetBucketFlowRateLimit(MsgSetBucketFlowRateLimit) returns (MsgSetBucketFlowRateLimitResponse); } message MsgCreateBucket { @@ -772,3 +774,24 @@ message MsgToggleSPAsDelegatedAgent { } message MsgToggleSPAsDelegatedAgentResponse {} + +message MsgSetBucketFlowRateLimit { + option (cosmos.msg.v1.signer) = "operator"; + + // operator defines the account address of the operator, either the object owner or the updater with granted permission. + string operator = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // bucket_name defines the name of the bucket + string bucket_name = 2; + // bucket_owner defines the account address of the bucket owner + string bucket_owner = 3 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // payment_address defines an account address to pay the fee for the bucket. + string payment_address = 4 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // flow_rate_limit defines the flow rate limit of the bucket + string flow_rate_limit = 5 [ + (cosmos_proto.scalar) = "cosmos.Int", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; +} + +message MsgSetBucketFlowRateLimitResponse {} diff --git a/proto/greenfield/storage/types.proto b/proto/greenfield/storage/types.proto index ecd89b8ef..033dac44a 100644 --- a/proto/greenfield/storage/types.proto +++ b/proto/greenfield/storage/types.proto @@ -219,3 +219,17 @@ message ShadowObjectInfo { // version define the version of object int64 version = 7; } + +message BucketExtraInfo { + bool is_rate_limited = 1; + string flow_rate_limit = 2 [ + (cosmos_proto.scalar) = "cosmos.Int", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; + string current_flow_rate = 3 [ + (cosmos_proto.scalar) = "cosmos.Int", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; +} diff --git a/swagger/static/swagger.yaml b/swagger/static/swagger.yaml index 84a8065d7..6c48b5d32 100644 --- a/swagger/static/swagger.yaml +++ b/swagger/static/swagger.yaml @@ -2632,6 +2632,15 @@ paths: when a bucket is created, by default, this is false, means SP is allowed to create object for delegator + extra_info: + type: object + properties: + is_rate_limited: + type: boolean + flow_rate_limit: + type: string + current_flow_rate: + type: string default: description: An unexpected error response. schema: @@ -2764,6 +2773,15 @@ paths: when a bucket is created, by default, this is false, means SP is allowed to create object for delegator + extra_info: + type: object + properties: + is_rate_limited: + type: boolean + flow_rate_limit: + type: string + current_flow_rate: + type: string default: description: An unexpected error response. schema: @@ -5089,6 +5107,57 @@ paths: format: int64 tags: - Query + /greenfield/storage/payment_account_bucket_flow_rate_limit/{payment_account}/{bucket_name}: + get: + summary: Queries the flow rate limit of a bucket for a payment account + operationId: QueryPaymentAccountBucketFlowRateLimit + responses: + '200': + description: A successful response. + schema: + type: object + properties: + is_set: + type: boolean + flow_rate_limit: + type: string + default: + description: An unexpected error response. + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + value: + type: string + format: byte + parameters: + - name: payment_account + in: path + required: true + type: string + - name: bucket_name + in: path + required: true + type: string + - name: bucket_owner + in: query + required: false + type: string + tags: + - Query /greenfield/storage/policy_by_id/{policy_id}: get: summary: Queries a policy by policy id @@ -34813,6 +34882,15 @@ definitions: - RESOURCE_TYPE_OBJECT - RESOURCE_TYPE_GROUP default: RESOURCE_TYPE_UNSPECIFIED + greenfield.storage.BucketExtraInfo: + type: object + properties: + is_rate_limited: + type: boolean + flow_rate_limit: + type: string + current_flow_rate: + type: string greenfield.storage.BucketInfo: type: object properties: @@ -35605,6 +35683,15 @@ definitions: when a bucket is created, by default, this is false, means SP is allowed to create object for delegator + extra_info: + type: object + properties: + is_rate_limited: + type: boolean + flow_rate_limit: + type: string + current_flow_rate: + type: string greenfield.storage.QueryHeadGroupMemberResponse: type: object properties: @@ -36525,6 +36612,13 @@ definitions: Relayer fee for the ACK or FAIL_ACK package of the mirror object tx to op chain description: QueryParamsResponse is response type for the Query/Params RPC method. + greenfield.storage.QueryPaymentAccountBucketFlowRateLimitResponse: + type: object + properties: + is_set: + type: boolean + flow_rate_limit: + type: string greenfield.storage.QueryPolicyByIdResponse: type: object properties: diff --git a/x/storage/client/cli/tx.go b/x/storage/client/cli/tx.go index ba97ee655..ff23b9e3c 100644 --- a/x/storage/client/cli/tx.go +++ b/x/storage/client/cli/tx.go @@ -41,6 +41,7 @@ func GetTxCmd() *cobra.Command { CmdDiscontinueBucket(), CmdMigrateBucket(), CmdCancelMigrateBucket(), + CmdSetBucketFlowRateLimit(), ) cmd.AddCommand( diff --git a/x/storage/client/cli/tx_set_bucket_flow_rate_limit.go b/x/storage/client/cli/tx_set_bucket_flow_rate_limit.go new file mode 100644 index 000000000..fd49a3fc1 --- /dev/null +++ b/x/storage/client/cli/tx_set_bucket_flow_rate_limit.go @@ -0,0 +1,63 @@ +package cli + +import ( + "fmt" + "strconv" + + sdkmath "cosmossdk.io/math" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/spf13/cobra" + + "github.com/bnb-chain/greenfield/x/storage/types" +) + +var _ = strconv.Itoa(0) + +func CmdSetBucketFlowRateLimit() *cobra.Command { + cmd := &cobra.Command{ + Use: "set-bucket-flow-rate-limit [bucket-name] [payment-account] [bucket-owner] [flow-rate-limit]", + Short: "set flow rate limit for a bucket", + Args: cobra.ExactArgs(4), + RunE: func(cmd *cobra.Command, args []string) (err error) { + argBucketName := args[0] + argPaymentAcc := args[1] + paymentAcc, err := sdk.AccAddressFromHexUnsafe(argPaymentAcc) + if err != nil { + return err + } + argBucketOwner := args[2] + bucketOwner, err := sdk.AccAddressFromHexUnsafe(argBucketOwner) + if err != nil { + return err + } + argFlowRateLimit, ok := sdkmath.NewIntFromString(args[3]) + if !ok { + return fmt.Errorf("invalid flow-rate-limit: %s", args[3]) + } + + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgSetBucketFlowRateLimit( + clientCtx.GetFromAddress(), + bucketOwner, + paymentAcc, + argBucketName, + argFlowRateLimit, + ) + if err = msg.ValidateBasic(); err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} diff --git a/x/storage/keeper/bucket_rate_limit.go b/x/storage/keeper/bucket_rate_limit.go new file mode 100644 index 000000000..0ba90e3a9 --- /dev/null +++ b/x/storage/keeper/bucket_rate_limit.go @@ -0,0 +1,290 @@ +package keeper + +import ( + "fmt" + + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + + paymenttypes "github.com/bnb-chain/greenfield/x/payment/types" + "github.com/bnb-chain/greenfield/x/storage/types" +) + +func (k Keeper) SetBucketFlowRateLimit(ctx sdk.Context, operator sdk.AccAddress, bucketOwner sdk.AccAddress, paymentAccount sdk.AccAddress, bucketName string, rateLimit sdkmath.Int) error { + // check the operator is the same as the payment account owner + if !k.paymentKeeper.IsPaymentAccountOwner(ctx, paymentAccount, operator) { + return paymenttypes.ErrNotPaymentAccountOwner + } + + // get the bucket + bucket, found := k.GetBucketInfo(ctx, bucketName) + + // if the bucket does not use the payment account, just set the flow rate limit + if !found || (found && (bucket.PaymentAddress != paymentAccount.String() || bucket.Owner != bucketOwner.String())) { + // set the flow rate limit to the store + k.setBucketFlowRateLimit(ctx, paymentAccount, bucketOwner, bucketName, &types.BucketFlowRateLimit{ + FlowRateLimit: rateLimit, + }) + return nil + } + + // set the flow rate limit for the bucket for the current bucket owner + err := k.setFlowRateLimit(ctx, bucket, paymentAccount, bucketName, rateLimit) + if err != nil { + return err + } + + // set the flow rate limit to the store + k.setBucketFlowRateLimit(ctx, paymentAccount, bucketOwner, bucketName, &types.BucketFlowRateLimit{ + FlowRateLimit: rateLimit, + }) + + return nil +} + +func (k Keeper) unChargeBucketReadStoreFee(ctx sdk.Context, bucketInfo *types.BucketInfo, + internalBucketInfo *types.InternalBucketInfo) error { + bill, err := k.GetBucketReadStoreBill(ctx, bucketInfo, internalBucketInfo) + if err != nil { + return fmt.Errorf("get bucket bill failed: %s %s", bucketInfo.BucketName, err.Error()) + } + bill.Flows = getNegFlows(bill.Flows) + err = k.paymentKeeper.ApplyUserFlowsList(ctx, []paymenttypes.UserFlows{bill}) + if err != nil { + return fmt.Errorf("apply user flows list failed: %s %w", bucketInfo.BucketName, err) + } + return nil +} + +func (k Keeper) chargeBucketReadStoreFee(ctx sdk.Context, bucketInfo *types.BucketInfo, + internalBucketInfo *types.InternalBucketInfo) error { + internalBucketInfo.PriceTime = ctx.BlockTime().Unix() + bill, err := k.GetBucketReadStoreBill(ctx, bucketInfo, internalBucketInfo) + if err != nil { + return fmt.Errorf("get bucket bill failed: %s %s", bucketInfo.BucketName, err.Error()) + } + err = k.paymentKeeper.ApplyUserFlowsList(ctx, []paymenttypes.UserFlows{bill}) + if err != nil { + return fmt.Errorf("apply user flows list failed: %s %w", bucketInfo.BucketName, err) + } + k.SetInternalBucketInfo(ctx, bucketInfo.Id, internalBucketInfo) + return nil +} + +func getTotalOutFlowRate(flows []paymenttypes.OutFlow) sdkmath.Int { + totalFlowRate := sdkmath.ZeroInt() + for _, flow := range flows { + totalFlowRate = totalFlowRate.Add(flow.Rate) + } + return totalFlowRate +} + +// unChargeAndLimitBucket uncharges the bucket and limits the bucket +func (k Keeper) unChargeAndLimitBucket(ctx sdk.Context, bucketInfo *types.BucketInfo, paymentAccount sdk.AccAddress, bucketName string) error { + k.setBucketFlowRateLimitStatus(ctx, bucketName, &types.BucketFlowRateLimitStatus{ + IsBucketLimited: true, + PaymentAddress: paymentAccount.String(), + }) + + internalBucketInfo := k.MustGetInternalBucketInfo(ctx, bucketInfo.Id) + // if the rate limit is not set and the payment account is not owned by the bucket owner, + // the net flow rate of the bucket should be zero, but it's fine to call `unChargeBucketReadStoreFee`, it will do nothing + return k.unChargeBucketReadStoreFee(ctx, bucketInfo, internalBucketInfo) +} + +// setFlowRateLimit sets the flow rate limit of the bucket +func (k Keeper) setFlowRateLimit(ctx sdk.Context, bucketInfo *types.BucketInfo, paymentAccount sdk.AccAddress, bucketName string, rateLimit sdkmath.Int) error { + currentRateLimit, found := k.getBucketFlowRateLimit(ctx, paymentAccount, sdk.MustAccAddressFromHex(bucketInfo.Owner), bucketName) + + // do nothing if the bucket flow rate limit is already the same as the new rate limit + if found && currentRateLimit.FlowRateLimit.Equal(rateLimit) { + return nil + } + + internalBucketInfo := k.MustGetInternalBucketInfo(ctx, bucketInfo.Id) + isRateLimited := k.IsBucketRateLimited(ctx, bucketName) + + if found && isRateLimited { + internalBucketInfo.PriceTime = ctx.BlockTime().Unix() + + currentBill, err := k.GetBucketReadStoreBill(ctx, bucketInfo, internalBucketInfo) + if err != nil { + return fmt.Errorf("get bucket currentBill failed: %s %s", bucketInfo.BucketName, err.Error()) + } + totalOutFlowRate := getTotalOutFlowRate(currentBill.Flows) + + // if the total net flow rate is less than or equal to the new rate limit, + // resume the charge of the bucket and delete the flow rate limit status + if totalOutFlowRate.LTE(rateLimit) { + err := k.chargeBucketReadStoreFee(ctx, bucketInfo, internalBucketInfo) + if err != nil { + return fmt.Errorf("charge bucket failed: %s %s", bucketInfo.BucketName, err.Error()) + } + k.deleteBucketFlowRateLimitStatus(ctx, bucketName) + return nil + } + + return nil + } + + // if there is no rate limit before or the bucket is not rate limited, we just need to compare the + // total out flow rate with the new rate limit, if the total out flow rate is greater than the new rate limit, + // we should uncharge and limit the bucket + bill, err := k.GetBucketReadStoreBill(ctx, bucketInfo, internalBucketInfo) + if err != nil { + return fmt.Errorf("get bucket bill failed: %s %s", bucketInfo.BucketName, err.Error()) + } + totalOutFlowRate := getTotalOutFlowRate(bill.Flows) + if totalOutFlowRate.GT(rateLimit) { + return k.unChargeAndLimitBucket(ctx, bucketInfo, paymentAccount, bucketName) + } + + return nil +} + +// getBucketFlowRateLimit returns the flow rate limit of the bucket from the store +func (k Keeper) getBucketFlowRateLimit(ctx sdk.Context, paymentAccount, bucketOwner sdk.AccAddress, bucketName string) (*types.BucketFlowRateLimit, bool) { + store := ctx.KVStore(k.storeKey) + + bz := store.Get(types.GetBucketFlowRateLimitKey(paymentAccount, bucketOwner, bucketName)) + if bz == nil { + return nil, false + } + + var rateLimit types.BucketFlowRateLimit + k.cdc.MustUnmarshal(bz, &rateLimit) + return &rateLimit, true +} + +// setBucketFlowRateLimit sets the flow rate limit of the bucket to the store +func (k Keeper) setBucketFlowRateLimit(ctx sdk.Context, paymentAccount, bucketOwner sdk.AccAddress, bucketName string, rateLimit *types.BucketFlowRateLimit) { + store := ctx.KVStore(k.storeKey) + + bz := k.cdc.MustMarshal(rateLimit) + store.Set(types.GetBucketFlowRateLimitKey(paymentAccount, bucketOwner, bucketName), bz) +} + +// setBucketFlowRateLimitStatus sets the flow rate limit status of the bucket to the store +func (k Keeper) setBucketFlowRateLimitStatus(ctx sdk.Context, bucketName string, status *types.BucketFlowRateLimitStatus) { + store := ctx.KVStore(k.storeKey) + + bz := k.cdc.MustMarshal(status) + store.Set(types.GetBucketFlowRateLimitStatusKey(bucketName), bz) + + if err := ctx.EventManager().EmitTypedEvents(&types.EventBucketFlowRateLimitStatus{ + BucketName: bucketName, + IsLimited: status.IsBucketLimited, + }); err != nil { + panic(err) + } +} + +// getBucketFlowRateLimitStatus returns the flow rate limit status of the bucket from the store +func (k Keeper) getBucketFlowRateLimitStatus(ctx sdk.Context, bucketName string) (*types.BucketFlowRateLimitStatus, bool) { + store := ctx.KVStore(k.storeKey) + + bz := store.Get(types.GetBucketFlowRateLimitStatusKey(bucketName)) + if bz == nil { + return nil, false + } + + var status types.BucketFlowRateLimitStatus + k.cdc.MustUnmarshal(bz, &status) + return &status, true +} + +// deleteBucketFlowRateLimitStatus deletes the flow rate limit status of the bucket from the store +func (k Keeper) deleteBucketFlowRateLimitStatus(ctx sdk.Context, bucketName string) { + store := ctx.KVStore(k.storeKey) + store.Delete(types.GetBucketFlowRateLimitStatusKey(bucketName)) + + if err := ctx.EventManager().EmitTypedEvents(&types.EventBucketFlowRateLimitStatus{ + BucketName: bucketName, + IsLimited: false, + }); err != nil { + panic(err) + } +} + +// IsBucketRateLimited checks if the bucket is rate limited +func (k Keeper) IsBucketRateLimited(ctx sdk.Context, bucketName string) bool { + status, found := k.getBucketFlowRateLimitStatus(ctx, bucketName) + if !found { + return false + } + return status.IsBucketLimited +} + +// isBucketFlowRateUnderLimit checks if the flow rate of the bucket is under the flow rate limit +func (k Keeper) isBucketFlowRateUnderLimit(ctx sdk.Context, paymentAccount, bucketOwner sdk.AccAddress, bucketName string, userFlows paymenttypes.UserFlows) error { + totalFlowRate := getTotalOutFlowRate(userFlows.Flows) + + return k.isBucketFlowRateUnderLimitWithRate(ctx, paymentAccount, bucketOwner, bucketName, totalFlowRate) +} + +// shouldCheckRateLimit checks if the flow rate of the bucket should be checked +func (k Keeper) shouldCheckRateLimit(ctx sdk.Context, paymentAccount, bucketOwner sdk.AccAddress, bucketName string) bool { + _, found := k.getBucketFlowRateLimit(ctx, paymentAccount, bucketOwner, bucketName) + if !found { + // if the bucket owner is owner of the payment account and the rate limit is not set, the flow rate is unlimited + return !k.paymentKeeper.IsPaymentAccountOwner(ctx, paymentAccount, bucketOwner) + } + + return true +} + +// isBucketFlowRateUnderLimitWithRate checks if the flow rate of the bucket is under the flow rate limit +func (k Keeper) isBucketFlowRateUnderLimitWithRate(ctx sdk.Context, paymentAccount, bucketOwner sdk.AccAddress, bucketName string, rate sdkmath.Int) error { + // if the total net flow rate is zero, it should be allowed + if rate.IsZero() { + return nil + } + + rateLimit, found := k.getBucketFlowRateLimit(ctx, paymentAccount, bucketOwner, bucketName) + // if the rate limit is not set + if !found { + // if the bucket owner is owner of the payment account and the rate limit is not set, the flow rate is unlimited + if k.paymentKeeper.IsPaymentAccountOwner(ctx, paymentAccount, bucketOwner) { + return nil + } + + return fmt.Errorf("the flow rate limit is not set for the bucket %s", bucketName) + } + + // check the flow rate is under the limit + if rate.GT(rateLimit.FlowRateLimit) { + return fmt.Errorf("the total flow rate of the bucket %s is greater than the flow rate limit", bucketName) + } + return nil +} + +// GetBucketExtraInfo returns the extra info of the bucket +func (k Keeper) GetBucketExtraInfo(ctx sdk.Context, bucketInfo *types.BucketInfo) (*types.BucketExtraInfo, error) { + paymentAcc, err := sdk.AccAddressFromHexUnsafe(bucketInfo.PaymentAddress) + if err != nil { + return nil, err + } + rateLimit, found := k.getBucketFlowRateLimit(ctx, paymentAcc, sdk.MustAccAddressFromHex(bucketInfo.Owner), bucketInfo.BucketName) + + extraInfo := &types.BucketExtraInfo{} + + if !found { + extraInfo.FlowRateLimit = sdk.NewInt(-1) + } else { + extraInfo.FlowRateLimit = rateLimit.FlowRateLimit + } + + isRateLimited := k.IsBucketRateLimited(ctx, bucketInfo.BucketName) + extraInfo.IsRateLimited = isRateLimited + + internalBucketInfo := k.MustGetInternalBucketInfo(ctx, bucketInfo.Id) + + bill, err := k.GetBucketReadStoreBill(ctx, bucketInfo, internalBucketInfo) + if err != nil { + return nil, fmt.Errorf("get bucket bill failed: %s %s", bucketInfo.BucketName, err.Error()) + } + totalOutFlowRate := getTotalOutFlowRate(bill.Flows) + extraInfo.CurrentFlowRate = totalOutFlowRate + + return extraInfo, nil +} diff --git a/x/storage/keeper/bucket_rate_limit_test.go b/x/storage/keeper/bucket_rate_limit_test.go new file mode 100644 index 000000000..32388a337 --- /dev/null +++ b/x/storage/keeper/bucket_rate_limit_test.go @@ -0,0 +1,249 @@ +package keeper_test + +import ( + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/golang/mock/gomock" + + "github.com/bnb-chain/greenfield/testutil/sample" + paymenttypes "github.com/bnb-chain/greenfield/x/payment/types" + sptypes "github.com/bnb-chain/greenfield/x/sp/types" + "github.com/bnb-chain/greenfield/x/storage/types" + virtualgroupmoduletypes "github.com/bnb-chain/greenfield/x/virtualgroup/types" +) + +func (s *TestSuite) TestSetBucketFlowRateLimit() { + operatorAddress := sample.RandAccAddress() + bucketOwner := sample.RandAccAddress() + paymentAccount := sample.RandAccAddress() + bucketName := string(sample.RandStr(10)) + + // case 1: operator is not owner of payment account + s.paymentKeeper.EXPECT().IsPaymentAccountOwner(gomock.Any(), gomock.Any(), gomock.Any()).Return(false) + + err := s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, sdkmath.NewInt(1)) + s.Require().ErrorContains(err, "not payment account owner") + + // case 2: bucket is not found + s.paymentKeeper.EXPECT().IsPaymentAccountOwner(gomock.Any(), gomock.Any(), gomock.Any()).Return(true).AnyTimes() + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, sdkmath.NewInt(1)) + s.Require().NoError(err) + + bucketInfo := &types.BucketInfo{ + Owner: bucketOwner.String(), + BucketName: bucketName, + Id: sdk.NewUint(1), + PaymentAddress: paymentAccount.String(), + ChargedReadQuota: 0, + BucketStatus: types.BUCKET_STATUS_CREATED, + } + s.storageKeeper.StoreBucketInfo(s.ctx, bucketInfo) + + // case 3: different bucket owner + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, sample.RandAccAddress(), paymentAccount, bucketName, sdkmath.NewInt(1)) + s.Require().NoError(err) + + // case 4: bucket does not use the payment account + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, sample.RandAccAddress(), bucketName, sdkmath.NewInt(1)) + s.Require().NoError(err) +} + +func (s *TestSuite) TestSetZeroBucketFlowRateLimit() { + operatorAddress := sample.RandAccAddress() + bucketOwner := sample.RandAccAddress() + paymentAccount := sample.RandAccAddress() + bucketName := string(sample.RandStr(10)) + + bucketInfo := &types.BucketInfo{ + Owner: bucketOwner.String(), + BucketName: bucketName, + Id: sdk.NewUint(1), + PaymentAddress: paymentAccount.String(), + ChargedReadQuota: 100, + } + prepareReadStoreBill(s, bucketInfo) + + s.paymentKeeper.EXPECT().IsPaymentAccountOwner(gomock.Any(), gomock.Any(), gomock.Any()).Return(true).AnyTimes() + s.paymentKeeper.EXPECT().ApplyUserFlowsList(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() + err := s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, sdkmath.NewInt(0)) + s.Require().NoError(err) +} + +func (s *TestSuite) TestSetFlowRateLimit_NotLimited() { + operatorAddress := sample.RandAccAddress() + bucketOwner := sample.RandAccAddress() + paymentAccount := sample.RandAccAddress() + bucketName := string(sample.RandStr(10)) + + bucketInfo := &types.BucketInfo{ + Owner: bucketOwner.String(), + BucketName: bucketName, + Id: sdk.NewUint(1), + PaymentAddress: paymentAccount.String(), + ChargedReadQuota: 100, + } + prepareReadStoreBill(s, bucketInfo) + + s.paymentKeeper.EXPECT().IsPaymentAccountOwner(gomock.Any(), gomock.Any(), gomock.Any()).Return(true).AnyTimes() + s.paymentKeeper.EXPECT().ApplyUserFlowsList(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() + + internalBucketInfo := s.storageKeeper.MustGetInternalBucketInfo(s.ctx, bucketInfo.Id) + bill, err := s.storageKeeper.GetBucketReadStoreBill(s.ctx, bucketInfo, internalBucketInfo) + s.Require().NoError(err) + totalOutFlowRate := getTotalOutFlowRate(bill.Flows) + + // case 1: rate limit does not exist before and is larger than total out flow rate + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, totalOutFlowRate.Add(sdkmath.NewInt(1))) + s.Require().NoError(err) + + isRateLimited := s.storageKeeper.IsBucketRateLimited(s.ctx, bucketName) + s.Require().False(isRateLimited) + + // case 2: rate limit exists before and is equal to the previous flow rate limit + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, totalOutFlowRate.Add(sdkmath.NewInt(1))) + s.Require().NoError(err) + + isRateLimited = s.storageKeeper.IsBucketRateLimited(s.ctx, bucketName) + s.Require().False(isRateLimited) + + // case 3: rate limit exists before and larger than the previous flow rate limit + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, totalOutFlowRate.Add(sdkmath.NewInt(2))) + s.Require().NoError(err) + + isRateLimited = s.storageKeeper.IsBucketRateLimited(s.ctx, bucketName) + s.Require().False(isRateLimited) +} + +func (s *TestSuite) TestSetBucketFlowRateLimit_Limited() { + operatorAddress := sample.RandAccAddress() + bucketOwner := sample.RandAccAddress() + paymentAccount := sample.RandAccAddress() + bucketName := string(sample.RandStr(10)) + + bucketInfo := &types.BucketInfo{ + Owner: bucketOwner.String(), + BucketName: bucketName, + Id: sdk.NewUint(1), + PaymentAddress: paymentAccount.String(), + ChargedReadQuota: 100, + } + prepareReadStoreBill(s, bucketInfo) + + s.paymentKeeper.EXPECT().IsPaymentAccountOwner(gomock.Any(), gomock.Any(), gomock.Any()).Return(true).AnyTimes() + s.paymentKeeper.EXPECT().ApplyUserFlowsList(gomock.Any(), gomock.Any()).Return(nil).AnyTimes() + + internalBucketInfo := s.storageKeeper.MustGetInternalBucketInfo(s.ctx, bucketInfo.Id) + bill, err := s.storageKeeper.GetBucketReadStoreBill(s.ctx, bucketInfo, internalBucketInfo) + s.Require().NoError(err) + totalOutFlowRate := getTotalOutFlowRate(bill.Flows) + + // case 1: rate limit does not exist before and is less than total out flow rate + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, totalOutFlowRate.Sub(sdkmath.NewInt(1))) + s.Require().NoError(err) + + isRateLimited := s.storageKeeper.IsBucketRateLimited(s.ctx, bucketName) + s.Require().True(isRateLimited) + + // case 2: rate limit exists before and is equal to the previous flow rate limit + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, totalOutFlowRate.Sub(sdkmath.NewInt(1))) + s.Require().NoError(err) + + isRateLimited = s.storageKeeper.IsBucketRateLimited(s.ctx, bucketName) + s.Require().True(isRateLimited) + + // case 3: bucket is rate limited and the new rate limit is less than the total out flow rate + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, totalOutFlowRate.Sub(sdkmath.NewInt(2))) + s.Require().NoError(err) + + isRateLimited = s.storageKeeper.IsBucketRateLimited(s.ctx, bucketName) + s.Require().True(isRateLimited) + + // case 4: bucket is rate limited and the new rate limit is larger than the total out flow rate + err = s.storageKeeper.SetBucketFlowRateLimit(s.ctx, operatorAddress, bucketOwner, paymentAccount, bucketName, totalOutFlowRate.Add(sdkmath.NewInt(1))) + s.Require().NoError(err) + + // the bucket should be no longer rate limited + isRateLimited = s.storageKeeper.IsBucketRateLimited(s.ctx, bucketName) + s.Require().False(isRateLimited) +} + +func getTotalOutFlowRate(flows []paymenttypes.OutFlow) sdkmath.Int { + totalFlowRate := sdkmath.ZeroInt() + for _, flow := range flows { + totalFlowRate = totalFlowRate.Add(flow.Rate) + } + return totalFlowRate +} + +func prepareReadStoreBill(s *TestSuite, bucketInfo *types.BucketInfo) { + gvgFamily := &virtualgroupmoduletypes.GlobalVirtualGroupFamily{ + Id: 1, + VirtualPaymentAddress: sample.RandAccAddress().String(), + } + s.virtualGroupKeeper.EXPECT().GetGVGFamily(gomock.Any(), gomock.Any()). + Return(gvgFamily, true).AnyTimes() + + bucketInfo.GlobalVirtualGroupFamilyId = gvgFamily.Id + + primarySp := &sptypes.StorageProvider{ + Status: sptypes.STATUS_IN_SERVICE, + Id: 100, + OperatorAddress: sample.RandAccAddress().String(), + FundingAddress: sample.RandAccAddress().String(), + } + s.spKeeper.EXPECT().GetStorageProvider(gomock.Any(), gomock.Eq(primarySp.Id)). + Return(primarySp, true).AnyTimes() + + price := sptypes.GlobalSpStorePrice{ + ReadPrice: sdk.NewDec(100), + PrimaryStorePrice: sdk.NewDec(1000), + SecondaryStorePrice: sdk.NewDec(500), + } + s.spKeeper.EXPECT().GetGlobalSpStorePriceByTime(gomock.Any(), gomock.Any()). + Return(price, nil).AnyTimes() + params := paymenttypes.DefaultParams() + s.paymentKeeper.EXPECT().GetVersionedParamsWithTs(gomock.Any(), gomock.Any()). + Return(params.VersionedParams, nil).AnyTimes() + + // none empty bucket + lvg1 := &types.LocalVirtualGroup{ + Id: 1, + TotalChargeSize: 100, + GlobalVirtualGroupId: 1, + } + lvg2 := &types.LocalVirtualGroup{ + Id: 2, + TotalChargeSize: 200, + GlobalVirtualGroupId: 2, + } + internalBucketInfo := &types.InternalBucketInfo{ + TotalChargeSize: 300, + LocalVirtualGroups: []*types.LocalVirtualGroup{ + lvg1, lvg2, + }, + } + + gvg1 := &virtualgroupmoduletypes.GlobalVirtualGroup{ + Id: 1, + PrimarySpId: primarySp.Id, + SecondarySpIds: []uint32{101, 102, 103, 104, 105, 106}, + VirtualPaymentAddress: sample.RandAccAddress().String(), + } + gvg2 := &virtualgroupmoduletypes.GlobalVirtualGroup{ + Id: 2, + PrimarySpId: primarySp.Id, + SecondarySpIds: []uint32{201, 202, 203, 204, 205, 206}, + VirtualPaymentAddress: sample.RandAccAddress().String(), + } + s.virtualGroupKeeper.EXPECT().GetGVG(gomock.Any(), gvg1.Id). + Return(gvg1, true).AnyTimes() + s.virtualGroupKeeper.EXPECT().GetGVG(gomock.Any(), gvg2.Id). + Return(gvg2, true).AnyTimes() + + s.storageKeeper.StoreBucketInfo(s.ctx, bucketInfo) + s.storageKeeper.SetInternalBucketInfo(s.ctx, bucketInfo.Id, internalBucketInfo) +} + +func (s *TestSuite) TestChargeBucketReadFee() { + +} diff --git a/x/storage/keeper/grpc_query.go b/x/storage/keeper/grpc_query.go index 5426f0d09..7f1dfce54 100644 --- a/x/storage/keeper/grpc_query.go +++ b/x/storage/keeper/grpc_query.go @@ -62,8 +62,13 @@ func (k Keeper) HeadBucket(goCtx context.Context, req *types.QueryHeadBucketRequ bucketInfo, found := k.GetBucketInfo(ctx, req.BucketName) if found { + extraInfo, err := k.GetBucketExtraInfo(ctx, bucketInfo) + if err != nil { + return nil, err + } return &types.QueryHeadBucketResponse{ BucketInfo: bucketInfo, + ExtraInfo: extraInfo, }, nil } return nil, types.ErrNoSuchBucket @@ -337,7 +342,7 @@ func (k Keeper) QueryLockFee(c context.Context, req *types.QueryLockFeeRequest) return nil, sptypes.ErrStorageProviderNotFound } - amount, err := k.GetObjectLockFee(ctx, createAt, req.PayloadSize) + amount, _, err := k.GetObjectLockFee(ctx, createAt, req.PayloadSize) if err != nil { return nil, status.Error(codes.Internal, err.Error()) } @@ -674,3 +679,33 @@ func (k Keeper) QueryGroupsExistById(goCtx context.Context, req *types.QueryGrou } return &types.QueryGroupsExistResponse{Exists: exists}, nil } + +func (k Keeper) QueryPaymentAccountBucketFlowRateLimit(goCtx context.Context, req *types.QueryPaymentAccountBucketFlowRateLimitRequest) (*types.QueryPaymentAccountBucketFlowRateLimitResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + paymentAcc, err := sdk.AccAddressFromHexUnsafe(req.PaymentAccount) + if err != nil { + return nil, status.Error(codes.InvalidArgument, "invalid payment account address") + } + + bucketOwner, err := sdk.AccAddressFromHexUnsafe(req.BucketOwner) + if err != nil { + return nil, status.Error(codes.InvalidArgument, "invalid bucket owner address") + } + + flowRateLimit, found := k.getBucketFlowRateLimit(ctx, paymentAcc, bucketOwner, req.BucketName) + if !found { + return &types.QueryPaymentAccountBucketFlowRateLimitResponse{ + IsSet: false, + }, nil + } + + return &types.QueryPaymentAccountBucketFlowRateLimitResponse{ + IsSet: true, + FlowRateLimit: flowRateLimit.FlowRateLimit, + }, nil +} diff --git a/x/storage/keeper/keeper.go b/x/storage/keeper/keeper.go index 6cb41fe80..cbdc9ddee 100644 --- a/x/storage/keeper/keeper.go +++ b/x/storage/keeper/keeper.go @@ -267,6 +267,9 @@ func (k Keeper) doDeleteBucket(ctx sdk.Context, operator sdk.AccAddress, bucketI return err } } + + // delete bucket flow rate limit status + k.deleteBucketFlowRateLimitStatus(ctx, bucketInfo.BucketName) return nil } diff --git a/x/storage/keeper/keeper_object_test.go b/x/storage/keeper/keeper_object_test.go index aa23f2adb..20346a9ed 100644 --- a/x/storage/keeper/keeper_object_test.go +++ b/x/storage/keeper/keeper_object_test.go @@ -28,6 +28,7 @@ func (s *TestSuite) TestCreateObject() { BucketStatus: types.BUCKET_STATUS_CREATED, } + s.paymentKeeper.EXPECT().IsPaymentAccountOwner(gomock.Any(), gomock.Any(), gomock.Any()).Return(true).AnyTimes() // case 1: bucket does not exist _, err := s.storageKeeper.CreateObject(s.ctx, operatorAddress, bucketInfo.BucketName, objectName, 100, types.CreateObjectOptions{ diff --git a/x/storage/keeper/msg_server.go b/x/storage/keeper/msg_server.go index c9c39808c..3c2dcf3f3 100644 --- a/x/storage/keeper/msg_server.go +++ b/x/storage/keeper/msg_server.go @@ -823,3 +823,28 @@ func (k Keeper) verifyGVGSignatures(ctx sdk.Context, bucketID math.Uint, dstSP * } return nil } + +func (k msgServer) SetBucketFlowRateLimit(goCtx context.Context, msg *types.MsgSetBucketFlowRateLimit) (*types.MsgSetBucketFlowRateLimitResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + operatorAddr := sdk.MustAccAddressFromHex(msg.Operator) + bucketOwnerAddr := sdk.MustAccAddressFromHex(msg.BucketOwner) + paymentAccountAddr := sdk.MustAccAddressFromHex(msg.PaymentAddress) + + err := k.Keeper.SetBucketFlowRateLimit(ctx, operatorAddr, bucketOwnerAddr, paymentAccountAddr, msg.BucketName, msg.FlowRateLimit) + if err != nil { + return nil, err + } + + if err = ctx.EventManager().EmitTypedEvents(&types.EventSetBucketFlowRateLimit{ + Operator: operatorAddr.String(), + BucketName: msg.BucketName, + BucketOwner: bucketOwnerAddr.String(), + PaymentAddress: paymentAccountAddr.String(), + FlowRateLimit: msg.FlowRateLimit, + }); err != nil { + return nil, err + } + + return &types.MsgSetBucketFlowRateLimitResponse{}, nil +} diff --git a/x/storage/keeper/payment.go b/x/storage/keeper/payment.go index fe23925c4..9fb44c8c2 100644 --- a/x/storage/keeper/payment.go +++ b/x/storage/keeper/payment.go @@ -6,6 +6,7 @@ import ( "cosmossdk.io/errors" sdkmath "cosmossdk.io/math" sdk "github.com/cosmos/cosmos-sdk/types" + upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" "github.com/bnb-chain/greenfield/x/payment/types" sptypes "github.com/bnb-chain/greenfield/x/sp/types" @@ -23,6 +24,14 @@ func (k Keeper) ChargeBucketReadFee(ctx sdk.Context, bucketInfo *storagetypes.Bu if err != nil { return fmt.Errorf("charge bucket read fee failed, get bucket bill failed: %s %s", bucketInfo.BucketName, err.Error()) } + + if ctx.IsUpgraded(upgradetypes.Serengeti) { + err := k.isBucketFlowRateUnderLimit(ctx, sdk.MustAccAddressFromHex(bucketInfo.PaymentAddress), sdk.MustAccAddressFromHex(bucketInfo.Owner), bucketInfo.BucketName, bill) + if err != nil { + return err + } + } + err = k.paymentKeeper.ApplyUserFlowsList(ctx, []types.UserFlows{bill}) if err != nil { ctx.Logger().Error("charge initial read fee failed", "bucket", bucketInfo.BucketName, "err", err.Error()) @@ -37,6 +46,13 @@ func (k Keeper) UnChargeBucketReadFee(ctx sdk.Context, bucketInfo *storagetypes. return fmt.Errorf("unexpected total store charge size: %s, %d", bucketInfo.BucketName, internalBucketInfo.TotalChargeSize) } + if ctx.IsUpgraded(upgradetypes.Serengeti) { + // if the bucket's flow rate limit is set to zero, no need to uncharge, since the bucket is already uncharged + if k.IsBucketRateLimited(ctx, bucketInfo.BucketName) { + return nil + } + } + bill, err := k.GetBucketReadBill(ctx, bucketInfo, internalBucketInfo) if err != nil { return fmt.Errorf("uncharge bucket read fee failed, get bucket bill failed: %s %s", bucketInfo.BucketName, err.Error()) @@ -117,7 +133,7 @@ func (k Keeper) LockShadowObjectStoreFee(ctx sdk.Context, bucketInfo *storagetyp func (k Keeper) lockObjectStoreFee(ctx sdk.Context, bucketInfo *storagetypes.BucketInfo, timestamp int64, payloadSize uint64, objectName string) error { paymentAddr := sdk.MustAccAddressFromHex(bucketInfo.PaymentAddress) - amount, err := k.GetObjectLockFee(ctx, timestamp, payloadSize) + amount, rate, err := k.GetObjectLockFee(ctx, timestamp, payloadSize) if err != nil { return fmt.Errorf("get object store fee rate failed: %s %s %w", bucketInfo.BucketName, objectName, err) } @@ -129,6 +145,25 @@ func (k Keeper) lockObjectStoreFee(ctx sdk.Context, bucketInfo *storagetypes.Buc }) } + if ctx.IsUpgraded(upgradetypes.Serengeti) && k.shouldCheckRateLimit(ctx, paymentAddr, sdk.MustAccAddressFromHex(bucketInfo.Owner), bucketInfo.BucketName) { + internalBucketInfo := k.MustGetInternalBucketInfo(ctx, bucketInfo.Id) + internalBucketInfo.PriceTime = timestamp + nextBill, err := k.GetBucketReadStoreBill(ctx, bucketInfo, internalBucketInfo) + if err != nil { + return fmt.Errorf("get bucket bill failed: %s %s %w", bucketInfo.BucketName, objectName, err) + } + + // the reason to add the rate here is the bill calculated may be empty if the lvg is not set, + // for example, the first object in the bucket, so we need to add the object rate to the next bill rate which may be 0 + nextBillRate := getTotalOutFlowRate(nextBill.Flows) + nextBillRate = nextBillRate.Add(rate) + + err = k.isBucketFlowRateUnderLimitWithRate(ctx, paymentAddr, sdk.MustAccAddressFromHex(bucketInfo.Owner), bucketInfo.BucketName, nextBillRate) + if err != nil { + return err + } + } + change := types.NewDefaultStreamRecordChangeWithAddr(paymentAddr).WithLockBalanceChange(amount) streamRecord, err := k.paymentKeeper.UpdateStreamRecordByAddr(ctx, change) if err != nil { @@ -142,7 +177,7 @@ func (k Keeper) lockObjectStoreFee(ctx sdk.Context, bucketInfo *storagetypes.Buc // UnlockObjectStoreFee unlock store fee if the object is deleted in INIT state func (k Keeper) UnlockObjectStoreFee(ctx sdk.Context, bucketInfo *storagetypes.BucketInfo, objectInfo *storagetypes.ObjectInfo) error { - lockedBalance, err := k.GetObjectLockFee(ctx, objectInfo.GetLatestUpdatedTime(), objectInfo.PayloadSize) + lockedBalance, _, err := k.GetObjectLockFee(ctx, objectInfo.GetLatestUpdatedTime(), objectInfo.PayloadSize) if err != nil { return fmt.Errorf("get object store fee rate failed: %s %s %w", bucketInfo.BucketName, objectInfo.ObjectName, err) } @@ -157,7 +192,7 @@ func (k Keeper) UnlockObjectStoreFee(ctx sdk.Context, bucketInfo *storagetypes.B // UnlockShadowObjectStoreFee unlock store fee if the object is deleted in INIT state func (k Keeper) UnlockShadowObjectStoreFee(ctx sdk.Context, bucketInfo *storagetypes.BucketInfo, objectInfo *storagetypes.ShadowObjectInfo) error { - lockedBalance, err := k.GetObjectLockFee(ctx, objectInfo.GetUpdatedAt(), objectInfo.PayloadSize) + lockedBalance, _, err := k.GetObjectLockFee(ctx, objectInfo.GetUpdatedAt(), objectInfo.PayloadSize) if err != nil { return fmt.Errorf("get shadow object store fee rate failed, objectID: %s %w", objectInfo.Id.String(), err) } @@ -298,6 +333,8 @@ func (k Keeper) ChargeViaBucketChange(ctx sdk.Context, bucketInfo *storagetypes. if err != nil { return fmt.Errorf("charge via bucket change failed, get bucket bill failed, bucket: %s, err: %s", bucketInfo.BucketName, err.Error()) } + prevPaymentAccount := bucketInfo.PaymentAddress + // change bucket internal info if err = changeFunc(bucketInfo, internalBucketInfo); err != nil { return errors.Wrapf(err, "change bucket internal info failed: %s", bucketInfo.BucketName) @@ -309,12 +346,42 @@ func (k Keeper) ChargeViaBucketChange(ctx sdk.Context, bucketInfo *storagetypes. return fmt.Errorf("get new bucket bill failed: %s %w", bucketInfo.BucketName, err) } - // charge according to bill change - err = k.ApplyBillChanges(ctx, prevBill, newBill) - if err != nil { - ctx.Logger().Error("charge via bucket change failed", "bucket", bucketInfo.BucketName, "err", err.Error()) - return err + if ctx.IsUpgraded(upgradetypes.Serengeti) { + isPreviousBucketLimited := k.IsBucketRateLimited(ctx, bucketInfo.BucketName) + + if prevPaymentAccount == bucketInfo.PaymentAddress && isPreviousBucketLimited { + return fmt.Errorf("payment account is not changed but the bucket is limited") + } + + // check the bucket's new flow rate limit + err := k.isBucketFlowRateUnderLimit(ctx, sdk.MustAccAddressFromHex(bucketInfo.PaymentAddress), sdk.MustAccAddressFromHex(bucketInfo.Owner), bucketInfo.BucketName, newBill) + if err != nil { + return err + } + + if isPreviousBucketLimited { + err = k.ApplyBillChanges(ctx, nil, &newBill) + if err != nil { + ctx.Logger().Error("charge via bucket change failed", "bucket", bucketInfo.BucketName, "err", err.Error()) + return err + } + k.deleteBucketFlowRateLimitStatus(ctx, bucketInfo.BucketName) + } else { + err = k.ApplyBillChanges(ctx, &prevBill, &newBill) + if err != nil { + ctx.Logger().Error("charge via bucket change failed", "bucket", bucketInfo.BucketName, "err", err.Error()) + return err + } + } + } else { + // charge according to bill change + err = k.ApplyBillChanges(ctx, &prevBill, &newBill) + if err != nil { + ctx.Logger().Error("charge via bucket change failed", "bucket", bucketInfo.BucketName, "err", err.Error()) + return err + } } + return nil } @@ -366,6 +433,19 @@ func (k Keeper) ChargeViaObjectChange(ctx sdk.Context, bucketInfo *storagetypes. userFlows.Flows = append(userFlows.Flows, getNegFlows(preOutFlows)...) userFlows.Flows = append(userFlows.Flows, newOutFlows...) + + if ctx.IsUpgraded(upgradetypes.Serengeti) { + currentBill, err := k.GetBucketReadStoreBill(ctx, bucketInfo, internalBucketInfo) + if err != nil { + return nil, fmt.Errorf("get bucket bill failed: %s %w", bucketInfo.BucketName, err) + } + + err = k.isBucketFlowRateUnderLimit(ctx, sdk.MustAccAddressFromHex(bucketInfo.PaymentAddress), sdk.MustAccAddressFromHex(bucketInfo.Owner), bucketInfo.BucketName, currentBill) + if err != nil { + return nil, err + } + } + err = k.paymentKeeper.ApplyUserFlowsList(ctx, []types.UserFlows{userFlows}) if err != nil { ctx.Logger().Error("charge object store fee failed", "bucket", bucketInfo.BucketName, @@ -467,6 +547,14 @@ func (k Keeper) GetBucketReadStoreBill(ctx sdk.Context, bucketInfo *storagetypes func (k Keeper) UnChargeBucketReadStoreFee(ctx sdk.Context, bucketInfo *storagetypes.BucketInfo, internalBucketInfo *storagetypes.InternalBucketInfo) error { + + if ctx.IsUpgraded(upgradetypes.Serengeti) { + // if the bucket's flow rate limit is set to zero, no need to uncharge, since the bucket is already uncharged + if k.IsBucketRateLimited(ctx, bucketInfo.BucketName) { + return nil + } + } + bill, err := k.GetBucketReadStoreBill(ctx, bucketInfo, internalBucketInfo) if err != nil { return fmt.Errorf("get bucket bill failed: %s %s", bucketInfo.BucketName, err.Error()) @@ -486,6 +574,14 @@ func (k Keeper) ChargeBucketReadStoreFee(ctx sdk.Context, bucketInfo *storagetyp if err != nil { return fmt.Errorf("get bucket bill failed: %s %s", bucketInfo.BucketName, err.Error()) } + + if ctx.IsUpgraded(upgradetypes.Serengeti) { + err := k.isBucketFlowRateUnderLimit(ctx, sdk.MustAccAddressFromHex(bucketInfo.PaymentAddress), sdk.MustAccAddressFromHex(bucketInfo.Owner), bucketInfo.BucketName, bill) + if err != nil { + return err + } + } + err = k.paymentKeeper.ApplyUserFlowsList(ctx, []types.UserFlows{bill}) if err != nil { return fmt.Errorf("apply user flows list failed: %s %w", bucketInfo.BucketName, err) @@ -493,9 +589,20 @@ func (k Keeper) ChargeBucketReadStoreFee(ctx sdk.Context, bucketInfo *storagetyp return nil } -func (k Keeper) ApplyBillChanges(ctx sdk.Context, prevFlows, currentFlows types.UserFlows) error { - prevFlows.Flows = getNegFlows(prevFlows.Flows) - err := k.paymentKeeper.ApplyUserFlowsList(ctx, []types.UserFlows{prevFlows, currentFlows}) +func (k Keeper) ApplyBillChanges(ctx sdk.Context, prevFlows, currentFlows *types.UserFlows) error { + if prevFlows != nil { + prevFlows.Flows = getNegFlows(prevFlows.Flows) + } + + var flowList []types.UserFlows + if prevFlows != nil { + flowList = append(flowList, *prevFlows) + } + if currentFlows != nil { + flowList = append(flowList, *currentFlows) + } + + err := k.paymentKeeper.ApplyUserFlowsList(ctx, flowList) if err != nil { return fmt.Errorf("apply user flows list failed: %w", err) } @@ -510,14 +617,14 @@ func getNegFlows(flows []types.OutFlow) (negFlows []types.OutFlow) { return negFlows } -func (k Keeper) GetObjectLockFee(ctx sdk.Context, priceTime int64, payloadSize uint64) (amount sdkmath.Int, err error) { +func (k Keeper) GetObjectLockFee(ctx sdk.Context, priceTime int64, payloadSize uint64) (amount, rate sdkmath.Int, err error) { price, err := k.spKeeper.GetGlobalSpStorePriceByTime(ctx, priceTime) if err != nil { - return amount, fmt.Errorf("get store price failed: %d %w", priceTime, err) + return amount, rate, fmt.Errorf("get store price failed: %d %w", priceTime, err) } chargeSize, err := k.GetObjectChargeSize(ctx, payloadSize, priceTime) if err != nil { - return amount, fmt.Errorf("get charge size failed: %d %w", priceTime, err) + return amount, rate, fmt.Errorf("get charge size failed: %d %w", priceTime, err) } primaryRate := price.PrimaryStorePrice.MulInt(sdkmath.NewIntFromUint64(chargeSize)).TruncateInt() @@ -528,13 +635,13 @@ func (k Keeper) GetObjectLockFee(ctx sdk.Context, priceTime int64, payloadSize u versionedParams, err := k.paymentKeeper.GetVersionedParamsWithTs(ctx, priceTime) if err != nil { - return amount, fmt.Errorf("get versioned reserve time error: %w", err) + return amount, rate, fmt.Errorf("get versioned reserve time error: %w", err) } validatorTaxRate := versionedParams.ValidatorTaxRate.MulInt(primaryRate.Add(secondaryRate)).TruncateInt() - rate := primaryRate.Add(secondaryRate).Add(validatorTaxRate) // should also lock for validator tax pool + rate = primaryRate.Add(secondaryRate).Add(validatorTaxRate) // should also lock for validator tax pool amount = rate.Mul(sdkmath.NewIntFromUint64(versionedParams.ReserveTime)) - return amount, nil + return amount, rate, nil } func (k Keeper) GetObjectChargeSize(ctx sdk.Context, payloadSize uint64, ts int64) (size uint64, err error) { diff --git a/x/storage/keeper/payment_test.go b/x/storage/keeper/payment_test.go index 39219dc3d..2b97dc21e 100644 --- a/x/storage/keeper/payment_test.go +++ b/x/storage/keeper/payment_test.go @@ -122,7 +122,7 @@ func (s *TestSuite) TestGetObjectLockFee() { // verify lock fee calculation timeNow := time.Now().Unix() + 1 payloadSize := int64(10 * 1024 * 1024) - amount, err := s.storageKeeper.GetObjectLockFee(s.ctx, timeNow, uint64(payloadSize)) + amount, _, err := s.storageKeeper.GetObjectLockFee(s.ctx, timeNow, uint64(payloadSize)) s.Require().NoError(err) secondarySPNum := int64(s.storageKeeper.GetExpectSecondarySPNumForECObject(s.ctx, timeNow)) spRate := price.PrimaryStorePrice.Add(price.SecondaryStorePrice.MulInt64(secondarySPNum)).MulInt64(payloadSize) diff --git a/x/storage/keeper/verify.go b/x/storage/keeper/verify.go index 4416550e5..36f5072ee 100644 --- a/x/storage/keeper/verify.go +++ b/x/storage/keeper/verify.go @@ -2,6 +2,7 @@ package keeper import ( sdk "github.com/cosmos/cosmos-sdk/types" + upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" paymenttypes "github.com/bnb-chain/greenfield/x/payment/types" ) @@ -14,8 +15,12 @@ func (k Keeper) VerifyPaymentAccount(ctx sdk.Context, paymentAddress string, own return nil, err } - if !k.paymentKeeper.IsPaymentAccountOwner(ctx, paymentAcc, ownerAcc) { - return nil, paymenttypes.ErrNotPaymentAccountOwner + // don't check if the payment account is owned by the owner account + if !ctx.IsUpgraded(upgradetypes.Serengeti) { + if !k.paymentKeeper.IsPaymentAccountOwner(ctx, paymentAcc, ownerAcc) { + return nil, paymenttypes.ErrNotPaymentAccountOwner + } } + return paymentAcc, nil } diff --git a/x/storage/types/codec.go b/x/storage/types/codec.go index b08c39bda..3163365b3 100644 --- a/x/storage/types/codec.go +++ b/x/storage/types/codec.go @@ -27,6 +27,7 @@ func RegisterCodec(cdc *codec.LegacyAmino) { cdc.RegisterConcrete(&MsgCompleteMigrateBucket{}, "storage/CompleteMigrateBucket", nil) cdc.RegisterConcrete(&MsgCancelMigrateBucket{}, "storage/CancelMigrateBucket", nil) cdc.RegisterConcrete(&MsgRejectMigrateBucket{}, "storage/RejectMigrateBucket", nil) + cdc.RegisterConcrete(&MsgSetBucketFlowRateLimit{}, "storage/SetBucketFlowRateLimit", nil) } func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { @@ -133,6 +134,10 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { registry.RegisterImplementations((*sdk.Msg)(nil), &MsgDelegateUpdateObjectContent{}, ) + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgSetBucketFlowRateLimit{}, + ) + msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) } diff --git a/x/storage/types/common.pb.go b/x/storage/types/common.pb.go index 060e8e0e0..321ff92d6 100644 --- a/x/storage/types/common.pb.go +++ b/x/storage/types/common.pb.go @@ -6,6 +6,7 @@ package types import ( fmt "fmt" _ "github.com/cosmos/cosmos-proto" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" io "io" @@ -454,6 +455,98 @@ func (m *LocalVirtualGroup) GetTotalChargeSize() uint64 { return 0 } +type BucketFlowRateLimit struct { + // flow_rate_limit defines the flow rate limit of the bucket + FlowRateLimit github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=flow_rate_limit,json=flowRateLimit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"flow_rate_limit"` +} + +func (m *BucketFlowRateLimit) Reset() { *m = BucketFlowRateLimit{} } +func (m *BucketFlowRateLimit) String() string { return proto.CompactTextString(m) } +func (*BucketFlowRateLimit) ProtoMessage() {} +func (*BucketFlowRateLimit) Descriptor() ([]byte, []int) { + return fileDescriptor_4eff6c0fa4aaf4c9, []int{4} +} +func (m *BucketFlowRateLimit) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BucketFlowRateLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BucketFlowRateLimit.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *BucketFlowRateLimit) XXX_Merge(src proto.Message) { + xxx_messageInfo_BucketFlowRateLimit.Merge(m, src) +} +func (m *BucketFlowRateLimit) XXX_Size() int { + return m.Size() +} +func (m *BucketFlowRateLimit) XXX_DiscardUnknown() { + xxx_messageInfo_BucketFlowRateLimit.DiscardUnknown(m) +} + +var xxx_messageInfo_BucketFlowRateLimit proto.InternalMessageInfo + +type BucketFlowRateLimitStatus struct { + // is_bucket_limited defines the flow rate limit status of the bucket, true means limited and the bucket is uncharged + IsBucketLimited bool `protobuf:"varint,1,opt,name=is_bucket_limited,json=isBucketLimited,proto3" json:"is_bucket_limited,omitempty"` + // payment_address is the payment address of the bucket which limited the flow rate + PaymentAddress string `protobuf:"bytes,2,opt,name=payment_address,json=paymentAddress,proto3" json:"payment_address,omitempty"` +} + +func (m *BucketFlowRateLimitStatus) Reset() { *m = BucketFlowRateLimitStatus{} } +func (m *BucketFlowRateLimitStatus) String() string { return proto.CompactTextString(m) } +func (*BucketFlowRateLimitStatus) ProtoMessage() {} +func (*BucketFlowRateLimitStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_4eff6c0fa4aaf4c9, []int{5} +} +func (m *BucketFlowRateLimitStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BucketFlowRateLimitStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BucketFlowRateLimitStatus.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *BucketFlowRateLimitStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_BucketFlowRateLimitStatus.Merge(m, src) +} +func (m *BucketFlowRateLimitStatus) XXX_Size() int { + return m.Size() +} +func (m *BucketFlowRateLimitStatus) XXX_DiscardUnknown() { + xxx_messageInfo_BucketFlowRateLimitStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_BucketFlowRateLimitStatus proto.InternalMessageInfo + +func (m *BucketFlowRateLimitStatus) GetIsBucketLimited() bool { + if m != nil { + return m.IsBucketLimited + } + return false +} + +func (m *BucketFlowRateLimitStatus) GetPaymentAddress() string { + if m != nil { + return m.PaymentAddress + } + return "" +} + func init() { proto.RegisterEnum("greenfield.storage.SourceType", SourceType_name, SourceType_value) proto.RegisterEnum("greenfield.storage.BucketStatus", BucketStatus_name, BucketStatus_value) @@ -464,64 +557,74 @@ func init() { proto.RegisterType((*GVGMapping)(nil), "greenfield.storage.GVGMapping") proto.RegisterType((*SecondarySpMigrationBucketSignDoc)(nil), "greenfield.storage.SecondarySpMigrationBucketSignDoc") proto.RegisterType((*LocalVirtualGroup)(nil), "greenfield.storage.LocalVirtualGroup") + proto.RegisterType((*BucketFlowRateLimit)(nil), "greenfield.storage.BucketFlowRateLimit") + proto.RegisterType((*BucketFlowRateLimitStatus)(nil), "greenfield.storage.BucketFlowRateLimitStatus") } func init() { proto.RegisterFile("greenfield/storage/common.proto", fileDescriptor_4eff6c0fa4aaf4c9) } var fileDescriptor_4eff6c0fa4aaf4c9 = []byte{ - // 819 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0x4d, 0x6f, 0xe3, 0x44, - 0x18, 0xc7, 0xe3, 0x34, 0xc0, 0x76, 0xb6, 0x94, 0xd4, 0x2a, 0xa4, 0x4d, 0x90, 0x53, 0x7a, 0x2a, - 0x95, 0xb6, 0x39, 0x20, 0xa4, 0x95, 0xd8, 0x8b, 0xed, 0x98, 0xec, 0xb0, 0xa9, 0x13, 0xcd, 0xd8, - 0x91, 0xca, 0x65, 0xe4, 0x97, 0xc1, 0x1d, 0xd6, 0xf1, 0x58, 0x9e, 0x31, 0x22, 0xfb, 0x09, 0x90, - 0xb8, 0x20, 0xbe, 0x00, 0x07, 0x0e, 0x7c, 0x01, 0xbe, 0x02, 0x68, 0x8f, 0x2b, 0x4e, 0x88, 0xc3, - 0x0a, 0xb5, 0x5f, 0x04, 0xf9, 0x25, 0xd9, 0x04, 0x42, 0xb5, 0x82, 0x5b, 0xe6, 0xf9, 0xff, 0xf3, - 0xcc, 0xef, 0x79, 0x9e, 0xf1, 0x0c, 0xe8, 0x47, 0x19, 0xa5, 0xc9, 0x17, 0x8c, 0xc6, 0xe1, 0x40, - 0x48, 0x9e, 0x79, 0x11, 0x1d, 0x04, 0x7c, 0x3e, 0xe7, 0xc9, 0x45, 0x9a, 0x71, 0xc9, 0x55, 0xf5, - 0x95, 0xe1, 0xa2, 0x36, 0x74, 0x8f, 0x03, 0x2e, 0xe6, 0x5c, 0x90, 0xd2, 0x31, 0xa8, 0x16, 0x95, - 0xbd, 0x7b, 0x18, 0xf1, 0x88, 0x57, 0xf1, 0xe2, 0x57, 0x15, 0x3d, 0xfd, 0x55, 0x01, 0xef, 0x63, - 0x1a, 0xf0, 0x24, 0xf4, 0xb2, 0x05, 0x4e, 0x31, 0xf5, 0xe2, 0x89, 0xff, 0x25, 0x0d, 0x24, 0x66, - 0x51, 0x32, 0xe4, 0x81, 0x7a, 0x0c, 0xee, 0x05, 0xd7, 0x1e, 0x4b, 0x08, 0x0b, 0x8f, 0x94, 0x13, - 0xe5, 0x6c, 0x17, 0xbd, 0x55, 0xae, 0x61, 0xa8, 0x7e, 0x0c, 0x3a, 0x51, 0xcc, 0x7d, 0x2f, 0x26, - 0x5f, 0xb1, 0x4c, 0xe6, 0x5e, 0x4c, 0xa2, 0x8c, 0xe7, 0x69, 0xe1, 0x6c, 0x9e, 0x28, 0x67, 0x6f, - 0xa3, 0xc3, 0x4a, 0x9e, 0x55, 0xea, 0xa8, 0x10, 0x61, 0xa8, 0x3e, 0x04, 0xbb, 0xbc, 0xdc, 0xa2, - 0x30, 0xee, 0x14, 0x29, 0x8d, 0xde, 0xf3, 0x97, 0xfd, 0xc6, 0x1f, 0x2f, 0xfb, 0x2d, 0x97, 0x25, - 0xf2, 0xb7, 0x9f, 0x1f, 0xdc, 0xaf, 0xc9, 0x8b, 0x25, 0xba, 0x57, 0xb9, 0x61, 0xa8, 0x76, 0x0b, - 0x16, 0x1a, 0x3c, 0x15, 0xf9, 0xfc, 0xa8, 0x75, 0xa2, 0x9c, 0xed, 0xa1, 0xd5, 0xfa, 0xf4, 0x17, - 0x05, 0x80, 0xd1, 0x6c, 0x74, 0xe9, 0xa5, 0x29, 0x4b, 0x22, 0xf5, 0x11, 0xe8, 0x89, 0x2c, 0x20, - 0xff, 0xc6, 0xa7, 0x94, 0x7c, 0x1d, 0x91, 0x05, 0xa3, 0x6d, 0x88, 0x8f, 0x40, 0x2f, 0x14, 0x92, - 0xdc, 0x5d, 0x5d, 0x27, 0x14, 0x72, 0xeb, 0xbf, 0x3f, 0x01, 0x5d, 0xb1, 0x6c, 0x29, 0x11, 0x29, - 0xf1, 0x63, 0x41, 0x04, 0x8b, 0x12, 0x4f, 0xe6, 0x19, 0x2d, 0x2b, 0xde, 0x43, 0x1d, 0xf1, 0xaa, - 0xe9, 0x46, 0x2c, 0xf0, 0x52, 0x3e, 0xfd, 0xa1, 0x09, 0x3e, 0x58, 0x1b, 0xc8, 0x25, 0x8b, 0x32, - 0x4f, 0x32, 0x9e, 0x18, 0x79, 0xf0, 0x94, 0xbe, 0xce, 0x54, 0x3e, 0x04, 0x07, 0x05, 0x7b, 0x9a, - 0xb1, 0x79, 0xbd, 0xff, 0x8a, 0x78, 0x3f, 0x14, 0x72, 0x5a, 0xc5, 0x71, 0x5d, 0xe6, 0x5d, 0x4d, - 0xda, 0xf9, 0x5f, 0x4d, 0x6a, 0xdd, 0xdd, 0xa4, 0x87, 0x60, 0xd7, 0x2f, 0x4b, 0x2a, 0xbc, 0x6f, - 0xbc, 0xc6, 0x29, 0xa8, 0xdc, 0x30, 0x3c, 0xfd, 0x49, 0x01, 0x07, 0x63, 0x1e, 0x6c, 0x66, 0x54, - 0xf7, 0x41, 0x73, 0x35, 0xd7, 0x26, 0xfb, 0xcf, 0x87, 0xb3, 0x0f, 0xee, 0x17, 0xdf, 0x12, 0x0d, - 0x89, 0x60, 0xcf, 0xaa, 0x61, 0xb5, 0x10, 0xa8, 0x42, 0x98, 0x3d, 0xa3, 0xea, 0x39, 0x38, 0x90, - 0x5c, 0x7a, 0x31, 0x09, 0xae, 0xbd, 0x2c, 0xa2, 0x95, 0xad, 0x55, 0xda, 0xde, 0x29, 0x05, 0xb3, - 0x8c, 0x17, 0xde, 0xf3, 0x6f, 0x15, 0x00, 0x30, 0xcf, 0xb3, 0x80, 0x3a, 0x8b, 0x94, 0xaa, 0xef, - 0x01, 0x15, 0x4f, 0x5c, 0x64, 0x5a, 0xc4, 0xb9, 0x9a, 0x5a, 0x64, 0x82, 0xe0, 0x08, 0xda, 0xed, - 0x86, 0xaa, 0x81, 0xee, 0x7a, 0xfc, 0x12, 0x22, 0x34, 0x41, 0x64, 0x6a, 0xd9, 0x43, 0x68, 0x8f, - 0xda, 0x8a, 0xda, 0x07, 0xbd, 0x75, 0xdd, 0xc0, 0x26, 0x31, 0xd1, 0x04, 0x63, 0x62, 0x3e, 0xd6, - 0xa1, 0xdd, 0x6e, 0xfe, 0x3d, 0xc1, 0x64, 0xba, 0xa1, 0xef, 0x74, 0x5b, 0xdf, 0xfc, 0xa8, 0x35, - 0xce, 0x63, 0xb0, 0x57, 0x1f, 0x22, 0xe9, 0xc9, 0x5c, 0xa8, 0xc7, 0xe0, 0x5d, 0xc3, 0x35, 0x9f, - 0x58, 0x0e, 0xc1, 0x8e, 0xee, 0xb8, 0x98, 0x98, 0xc8, 0xd2, 0x1d, 0x6b, 0x58, 0x11, 0x6d, 0x4a, - 0x43, 0x88, 0xcd, 0x89, 0xed, 0x40, 0xdb, 0xb5, 0x86, 0x6d, 0x45, 0xed, 0x81, 0xce, 0xa6, 0x7e, - 0x09, 0x47, 0x48, 0x77, 0x0a, 0xdc, 0x66, 0xbd, 0xdb, 0x13, 0xb0, 0x8f, 0x68, 0x98, 0x27, 0xa1, - 0x97, 0x04, 0x8b, 0x65, 0xf9, 0xc8, 0x1a, 0xba, 0xf6, 0x50, 0xb7, 0xcd, 0x2b, 0x62, 0x99, 0x25, - 0x6c, 0xbb, 0x51, 0x24, 0x5b, 0x8b, 0x23, 0x6b, 0x3a, 0x86, 0xa6, 0x5e, 0x89, 0x4a, 0x9d, 0x8c, - 0x81, 0xbd, 0xfa, 0x56, 0x5a, 0xa1, 0x4f, 0x8c, 0xcf, 0x2c, 0x73, 0x0b, 0xfa, 0x11, 0x38, 0xdc, - 0x94, 0xb0, 0xa5, 0x8f, 0x4b, 0x68, 0x0d, 0x74, 0x37, 0x95, 0x8d, 0xa2, 0x96, 0xdc, 0xdf, 0x2b, - 0x60, 0x7f, 0xc6, 0x04, 0xf3, 0x59, 0xcc, 0x64, 0x05, 0xde, 0x07, 0xbd, 0x19, 0xc4, 0xd0, 0x80, - 0x63, 0xe8, 0x5c, 0x55, 0x2d, 0x76, 0x6d, 0x3c, 0xb5, 0x4c, 0xf8, 0x29, 0x2c, 0xf7, 0xdc, 0x62, - 0x98, 0xba, 0xc6, 0x18, 0x9a, 0x04, 0x59, 0x7a, 0xdd, 0xaf, 0x7f, 0x18, 0x10, 0x9c, 0xe9, 0x8e, - 0xd5, 0x6e, 0x6e, 0x13, 0xa1, 0xfd, 0xd8, 0x42, 0xd0, 0x59, 0x8e, 0xce, 0x80, 0xcf, 0x6f, 0x34, - 0xe5, 0xc5, 0x8d, 0xa6, 0xfc, 0x79, 0xa3, 0x29, 0xdf, 0xdd, 0x6a, 0x8d, 0x17, 0xb7, 0x5a, 0xe3, - 0xf7, 0x5b, 0xad, 0xf1, 0xf9, 0x20, 0x62, 0xf2, 0x3a, 0xf7, 0x2f, 0x02, 0x3e, 0x1f, 0xf8, 0x89, - 0xff, 0xa0, 0xbc, 0x05, 0x06, 0x6b, 0x4f, 0xc7, 0xd7, 0xab, 0xc7, 0x43, 0x2e, 0x52, 0x2a, 0xfc, - 0x37, 0xcb, 0x7b, 0xff, 0xa3, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x56, 0x70, 0xa5, 0xe0, 0x5f, - 0x06, 0x00, 0x00, + // 946 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xc1, 0x6e, 0xe3, 0x44, + 0x18, 0x8e, 0xd3, 0x00, 0xed, 0x6c, 0xb7, 0x4d, 0x4d, 0xa1, 0x6d, 0x82, 0x92, 0x92, 0x03, 0x2a, + 0x95, 0xda, 0x1c, 0x10, 0xd2, 0x4a, 0xf4, 0x62, 0x3b, 0xde, 0xec, 0xb0, 0xa9, 0x13, 0xcd, 0x38, + 0x95, 0xca, 0x65, 0xe4, 0xd8, 0x53, 0x77, 0xa8, 0xe3, 0xb1, 0x3c, 0x13, 0x96, 0x2e, 0x2f, 0x80, + 0xe0, 0x82, 0x78, 0x01, 0x0e, 0x1c, 0x78, 0x81, 0x7d, 0x05, 0xd0, 0x1e, 0x57, 0x7b, 0x42, 0x1c, + 0x56, 0xa8, 0x7d, 0x11, 0x64, 0x8f, 0x93, 0x4d, 0x20, 0x54, 0x2b, 0x38, 0x25, 0xf3, 0x7d, 0x9f, + 0xe7, 0xff, 0xfe, 0xef, 0xf7, 0x78, 0x40, 0x33, 0x4c, 0x29, 0x8d, 0x2f, 0x18, 0x8d, 0x82, 0xb6, + 0x90, 0x3c, 0xf5, 0x42, 0xda, 0xf6, 0xf9, 0x78, 0xcc, 0xe3, 0xe3, 0x24, 0xe5, 0x92, 0xeb, 0xfa, + 0x6b, 0xc1, 0x71, 0x21, 0xa8, 0xed, 0xf9, 0x5c, 0x8c, 0xb9, 0x20, 0xb9, 0xa2, 0xad, 0x16, 0x4a, + 0x5e, 0xdb, 0x0e, 0x79, 0xc8, 0x15, 0x9e, 0xfd, 0x53, 0x68, 0xeb, 0x37, 0x0d, 0x7c, 0x80, 0xa9, + 0xcf, 0xe3, 0xc0, 0x4b, 0xaf, 0x71, 0x82, 0xa9, 0x17, 0xf5, 0x47, 0x5f, 0x52, 0x5f, 0x62, 0x16, + 0xc6, 0x1d, 0xee, 0xeb, 0x7b, 0x60, 0xd5, 0xbf, 0xf4, 0x58, 0x4c, 0x58, 0xb0, 0xab, 0xed, 0x6b, + 0x07, 0x6b, 0xe8, 0x9d, 0x7c, 0x0d, 0x03, 0xfd, 0x53, 0xb0, 0x13, 0x46, 0x7c, 0xe4, 0x45, 0xe4, + 0x2b, 0x96, 0xca, 0x89, 0x17, 0x91, 0x30, 0xe5, 0x93, 0x24, 0x53, 0x96, 0xf7, 0xb5, 0x83, 0xfb, + 0x68, 0x5b, 0xd1, 0x67, 0x8a, 0xed, 0x66, 0x24, 0x0c, 0xf4, 0x07, 0x60, 0x8d, 0xe7, 0x25, 0x32, + 0xe1, 0x4a, 0xb6, 0xa5, 0x59, 0x7f, 0xfe, 0xaa, 0x59, 0xfa, 0xe3, 0x55, 0xb3, 0x32, 0x64, 0xb1, + 0x7c, 0xf9, 0xec, 0xe8, 0x5e, 0xe1, 0x3c, 0x5b, 0xa2, 0x55, 0xa5, 0x86, 0x81, 0x5e, 0xcb, 0xbc, + 0x50, 0xff, 0x4a, 0x4c, 0xc6, 0xbb, 0x95, 0x7d, 0xed, 0x60, 0x1d, 0xcd, 0xd6, 0xad, 0x5f, 0x35, + 0x00, 0xba, 0x67, 0xdd, 0x53, 0x2f, 0x49, 0x58, 0x1c, 0xea, 0x27, 0xa0, 0x2e, 0x52, 0x9f, 0xfc, + 0x9b, 0x3f, 0x2d, 0xf7, 0xb7, 0x23, 0x52, 0xbf, 0xbb, 0xcc, 0xe2, 0x09, 0xa8, 0x07, 0x42, 0x92, + 0xbb, 0xbb, 0xdb, 0x09, 0x84, 0x5c, 0xfa, 0xf4, 0x67, 0xa0, 0x26, 0xa6, 0x91, 0x12, 0x91, 0x90, + 0x51, 0x24, 0x88, 0x60, 0x61, 0xec, 0xc9, 0x49, 0x4a, 0xf3, 0x8e, 0xd7, 0xd1, 0x8e, 0x78, 0x1d, + 0xba, 0x19, 0x09, 0x3c, 0xa5, 0x5b, 0x3f, 0x95, 0xc1, 0x87, 0x73, 0x03, 0x39, 0x65, 0x61, 0xea, + 0x49, 0xc6, 0x63, 0x73, 0xe2, 0x5f, 0xd1, 0x37, 0x99, 0xca, 0xc7, 0x60, 0x2b, 0xf3, 0x9e, 0xa4, + 0x6c, 0x5c, 0xd4, 0x9f, 0x39, 0xde, 0x08, 0x84, 0x1c, 0x28, 0x1c, 0x17, 0x6d, 0xde, 0x15, 0xd2, + 0xca, 0xff, 0x0a, 0xa9, 0x72, 0x77, 0x48, 0x0f, 0xc0, 0xda, 0x28, 0x6f, 0x29, 0xd3, 0xbe, 0xf5, + 0x06, 0x6f, 0x81, 0x52, 0xc3, 0xa0, 0xf5, 0x8b, 0x06, 0xb6, 0x7a, 0xdc, 0x5f, 0xdc, 0x51, 0xdf, + 0x00, 0xe5, 0xd9, 0x5c, 0xcb, 0xec, 0x3f, 0xbf, 0x9c, 0x4d, 0x70, 0x2f, 0x3b, 0x4b, 0x34, 0x20, + 0x82, 0x3d, 0x55, 0xc3, 0xaa, 0x20, 0xa0, 0x20, 0xcc, 0x9e, 0x52, 0xfd, 0x10, 0x6c, 0x49, 0x2e, + 0xbd, 0x88, 0xf8, 0x97, 0x5e, 0x1a, 0x52, 0x25, 0xab, 0xe4, 0xb2, 0xcd, 0x9c, 0xb0, 0x72, 0x3c, + 0xd3, 0xb6, 0xbe, 0x01, 0xef, 0xaa, 0xb1, 0x3d, 0x8c, 0xf8, 0x13, 0xe4, 0x49, 0xda, 0x63, 0x63, + 0x26, 0xf5, 0x00, 0x6c, 0x5e, 0x44, 0xfc, 0x09, 0x49, 0x3d, 0x49, 0x49, 0x94, 0x41, 0x6a, 0x86, + 0xe6, 0x49, 0x11, 0xc0, 0x47, 0x21, 0x93, 0x97, 0x93, 0xd1, 0xb1, 0xcf, 0xc7, 0xc5, 0x19, 0x2e, + 0x7e, 0x8e, 0x44, 0x70, 0xd5, 0x96, 0xd7, 0x09, 0x15, 0xc7, 0x30, 0x8f, 0x08, 0x14, 0x11, 0xc1, + 0x58, 0xa2, 0xfb, 0x17, 0xf3, 0x55, 0x5a, 0xdf, 0x69, 0x60, 0x6f, 0x49, 0x75, 0x2c, 0x3d, 0x39, + 0x11, 0x59, 0x1b, 0x4c, 0x90, 0x62, 0x02, 0xb9, 0x07, 0xaa, 0xd2, 0x5b, 0x45, 0x9b, 0x4c, 0xa8, + 0xe7, 0x7a, 0x0a, 0xd6, 0x0d, 0xb0, 0x99, 0x78, 0xd7, 0x63, 0x1a, 0x4b, 0xe2, 0x05, 0x41, 0x4a, + 0x85, 0xc8, 0x23, 0x5c, 0x33, 0x77, 0x5f, 0x3e, 0x3b, 0xda, 0x2e, 0x1c, 0x18, 0x8a, 0xc1, 0x32, + 0x65, 0x71, 0x88, 0x36, 0x8a, 0x07, 0x0a, 0xf4, 0xf0, 0x7b, 0x0d, 0x00, 0xcc, 0x27, 0xa9, 0x4f, + 0xdd, 0xeb, 0x84, 0xea, 0xef, 0x03, 0x1d, 0xf7, 0x87, 0xc8, 0xb2, 0x89, 0x7b, 0x3e, 0xb0, 0x49, + 0x1f, 0xc1, 0x2e, 0x74, 0xaa, 0x25, 0xbd, 0x01, 0x6a, 0xf3, 0xf8, 0x29, 0x44, 0xa8, 0x8f, 0xc8, + 0xc0, 0x76, 0x3a, 0xd0, 0xe9, 0x56, 0x35, 0xbd, 0x09, 0xea, 0xf3, 0xbc, 0x89, 0x2d, 0x62, 0xa1, + 0x3e, 0xc6, 0xc4, 0x7a, 0x64, 0x40, 0xa7, 0x5a, 0xfe, 0xfb, 0x06, 0xfd, 0xc1, 0x02, 0xbf, 0x52, + 0xab, 0x7c, 0xfb, 0x73, 0xa3, 0x74, 0x18, 0x81, 0xf5, 0xe2, 0x38, 0xa9, 0x30, 0xf6, 0xc0, 0x7b, + 0xe6, 0xd0, 0x7a, 0x6c, 0xbb, 0x04, 0xbb, 0x86, 0x3b, 0xc4, 0xc4, 0x42, 0xb6, 0xe1, 0xda, 0x1d, + 0xe5, 0x68, 0x91, 0xea, 0x40, 0x6c, 0xf5, 0x1d, 0x17, 0x3a, 0x43, 0xbb, 0x53, 0xd5, 0xf4, 0x3a, + 0xd8, 0x59, 0xe4, 0x4f, 0x61, 0x17, 0x19, 0x6e, 0x66, 0xb7, 0x5c, 0x54, 0x7b, 0x0c, 0x36, 0x10, + 0x0d, 0x26, 0x71, 0xe0, 0xc5, 0xfe, 0xf5, 0xb4, 0x7d, 0x64, 0x77, 0x86, 0x4e, 0xc7, 0x70, 0xac, + 0x73, 0x62, 0x5b, 0xb9, 0xd9, 0x6a, 0x29, 0xdb, 0x6c, 0x0e, 0x47, 0xf6, 0xa0, 0x07, 0x2d, 0x43, + 0x91, 0x5a, 0xb1, 0x19, 0x03, 0xeb, 0xc5, 0xf7, 0x79, 0x66, 0xbd, 0x6f, 0x7e, 0x6e, 0x5b, 0x4b, + 0xac, 0xef, 0x82, 0xed, 0x45, 0x0a, 0xdb, 0x46, 0x2f, 0x37, 0xdd, 0x00, 0xb5, 0x45, 0x66, 0xa1, + 0xa9, 0xa9, 0xef, 0x1f, 0x35, 0xb0, 0x71, 0xc6, 0x04, 0x1b, 0xb1, 0x88, 0x49, 0x65, 0xbc, 0x09, + 0xea, 0x67, 0x10, 0x43, 0x13, 0xf6, 0xa0, 0x7b, 0xae, 0x22, 0x1e, 0x3a, 0x78, 0x60, 0x5b, 0xf0, + 0x21, 0xcc, 0x6b, 0x2e, 0x11, 0x0c, 0x86, 0x66, 0x0f, 0x5a, 0x04, 0xd9, 0x46, 0x91, 0xd7, 0x3f, + 0x04, 0x08, 0x9e, 0x19, 0xae, 0x5d, 0x2d, 0x2f, 0x23, 0xa1, 0xf3, 0xc8, 0x46, 0xd0, 0x9d, 0x8e, + 0xce, 0x84, 0xcf, 0x6f, 0x1a, 0xda, 0x8b, 0x9b, 0x86, 0xf6, 0xe7, 0x4d, 0x43, 0xfb, 0xe1, 0xb6, + 0x51, 0x7a, 0x71, 0xdb, 0x28, 0xfd, 0x7e, 0xdb, 0x28, 0x7d, 0xd1, 0x9e, 0x3b, 0x34, 0xa3, 0x78, + 0x74, 0x94, 0x7f, 0x0f, 0xdb, 0x73, 0x97, 0xe8, 0xd7, 0xb3, 0x6b, 0x34, 0x3f, 0x41, 0xa3, 0xb7, + 0xf3, 0x1b, 0xf0, 0x93, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x70, 0xc6, 0x1b, 0xe5, 0x69, 0x07, + 0x00, 0x00, } func (m *SecondarySpSealObjectSignDoc) Marshal() (dAtA []byte, err error) { @@ -714,6 +817,79 @@ func (m *LocalVirtualGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *BucketFlowRateLimit) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BucketFlowRateLimit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BucketFlowRateLimit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.FlowRateLimit.Size() + i -= size + if _, err := m.FlowRateLimit.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintCommon(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *BucketFlowRateLimitStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BucketFlowRateLimitStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BucketFlowRateLimitStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.PaymentAddress) > 0 { + i -= len(m.PaymentAddress) + copy(dAtA[i:], m.PaymentAddress) + i = encodeVarintCommon(dAtA, i, uint64(len(m.PaymentAddress))) + i-- + dAtA[i] = 0x12 + } + if m.IsBucketLimited { + i-- + if m.IsBucketLimited { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintCommon(dAtA []byte, offset int, v uint64) int { offset -= sovCommon(v) base := offset @@ -811,6 +987,33 @@ func (m *LocalVirtualGroup) Size() (n int) { return n } +func (m *BucketFlowRateLimit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.FlowRateLimit.Size() + n += 1 + l + sovCommon(uint64(l)) + return n +} + +func (m *BucketFlowRateLimitStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IsBucketLimited { + n += 2 + } + l = len(m.PaymentAddress) + if l > 0 { + n += 1 + l + sovCommon(uint64(l)) + } + return n +} + func sovCommon(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -1407,6 +1610,192 @@ func (m *LocalVirtualGroup) Unmarshal(dAtA []byte) error { } return nil } +func (m *BucketFlowRateLimit) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommon + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BucketFlowRateLimit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BucketFlowRateLimit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FlowRateLimit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommon + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommon + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommon + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.FlowRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCommon(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCommon + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BucketFlowRateLimitStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommon + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BucketFlowRateLimitStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BucketFlowRateLimitStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsBucketLimited", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommon + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsBucketLimited = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PaymentAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommon + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommon + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommon + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PaymentAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipCommon(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthCommon + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipCommon(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/storage/types/errors.go b/x/storage/types/errors.go index df60a2626..2ae8ba523 100644 --- a/x/storage/types/errors.go +++ b/x/storage/types/errors.go @@ -54,4 +54,6 @@ var ( ErrMigrationBucketFailed = errors.Register(ModuleName, 3202, "migrate bucket failed.") ErrVirtualGroupOperateFailed = errors.Register(ModuleName, 3203, "operate virtual group failed.") ErrInvalidBlsPubKey = errors.Register(ModuleName, 3204, "invalid bls public key") + + ErrInvalidBucketOwner = errors.Register(ModuleName, 3300, "invalid bucket owner") ) diff --git a/x/storage/types/events.pb.go b/x/storage/types/events.pb.go index 42d16a15a..06c527247 100644 --- a/x/storage/types/events.pb.go +++ b/x/storage/types/events.pb.go @@ -7,6 +7,7 @@ import ( fmt "fmt" _ "github.com/bnb-chain/greenfield/types/resource" _ "github.com/cosmos/cosmos-proto" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" @@ -2677,6 +2678,134 @@ func (m *EventCancelUpdateObjectContent) GetObjectName() string { return "" } +type EventSetBucketFlowRateLimit struct { + // operator define the account address of operator who set the bucket flow rate limit + Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"` + // bucket_name define the name of the bucket + BucketName string `protobuf:"bytes,2,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` + // payment_address define the payment address for the bucket + PaymentAddress string `protobuf:"bytes,3,opt,name=payment_address,json=paymentAddress,proto3" json:"payment_address,omitempty"` + // bucket_owner define the intended owner of the bucket + BucketOwner string `protobuf:"bytes,4,opt,name=bucket_owner,json=bucketOwner,proto3" json:"bucket_owner,omitempty"` + // flow_rate_limit define the flow rate limit of the bucket + FlowRateLimit github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=flow_rate_limit,json=flowRateLimit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"flow_rate_limit"` +} + +func (m *EventSetBucketFlowRateLimit) Reset() { *m = EventSetBucketFlowRateLimit{} } +func (m *EventSetBucketFlowRateLimit) String() string { return proto.CompactTextString(m) } +func (*EventSetBucketFlowRateLimit) ProtoMessage() {} +func (*EventSetBucketFlowRateLimit) Descriptor() ([]byte, []int) { + return fileDescriptor_946dcba4f763ddc4, []int{34} +} +func (m *EventSetBucketFlowRateLimit) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventSetBucketFlowRateLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventSetBucketFlowRateLimit.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EventSetBucketFlowRateLimit) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventSetBucketFlowRateLimit.Merge(m, src) +} +func (m *EventSetBucketFlowRateLimit) XXX_Size() int { + return m.Size() +} +func (m *EventSetBucketFlowRateLimit) XXX_DiscardUnknown() { + xxx_messageInfo_EventSetBucketFlowRateLimit.DiscardUnknown(m) +} + +var xxx_messageInfo_EventSetBucketFlowRateLimit proto.InternalMessageInfo + +func (m *EventSetBucketFlowRateLimit) GetOperator() string { + if m != nil { + return m.Operator + } + return "" +} + +func (m *EventSetBucketFlowRateLimit) GetBucketName() string { + if m != nil { + return m.BucketName + } + return "" +} + +func (m *EventSetBucketFlowRateLimit) GetPaymentAddress() string { + if m != nil { + return m.PaymentAddress + } + return "" +} + +func (m *EventSetBucketFlowRateLimit) GetBucketOwner() string { + if m != nil { + return m.BucketOwner + } + return "" +} + +type EventBucketFlowRateLimitStatus struct { + // bucket_name define the name of the bucket + BucketName string `protobuf:"bytes,1,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` + // is_limited define the status of the bucket flow rate limit + IsLimited bool `protobuf:"varint,2,opt,name=is_limited,json=isLimited,proto3" json:"is_limited,omitempty"` +} + +func (m *EventBucketFlowRateLimitStatus) Reset() { *m = EventBucketFlowRateLimitStatus{} } +func (m *EventBucketFlowRateLimitStatus) String() string { return proto.CompactTextString(m) } +func (*EventBucketFlowRateLimitStatus) ProtoMessage() {} +func (*EventBucketFlowRateLimitStatus) Descriptor() ([]byte, []int) { + return fileDescriptor_946dcba4f763ddc4, []int{35} +} +func (m *EventBucketFlowRateLimitStatus) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EventBucketFlowRateLimitStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EventBucketFlowRateLimitStatus.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EventBucketFlowRateLimitStatus) XXX_Merge(src proto.Message) { + xxx_messageInfo_EventBucketFlowRateLimitStatus.Merge(m, src) +} +func (m *EventBucketFlowRateLimitStatus) XXX_Size() int { + return m.Size() +} +func (m *EventBucketFlowRateLimitStatus) XXX_DiscardUnknown() { + xxx_messageInfo_EventBucketFlowRateLimitStatus.DiscardUnknown(m) +} + +var xxx_messageInfo_EventBucketFlowRateLimitStatus proto.InternalMessageInfo + +func (m *EventBucketFlowRateLimitStatus) GetBucketName() string { + if m != nil { + return m.BucketName + } + return "" +} + +func (m *EventBucketFlowRateLimitStatus) GetIsLimited() bool { + if m != nil { + return m.IsLimited + } + return false +} + func init() { proto.RegisterType((*EventCreateBucket)(nil), "greenfield.storage.EventCreateBucket") proto.RegisterType((*EventDeleteBucket)(nil), "greenfield.storage.EventDeleteBucket") @@ -2712,131 +2841,140 @@ func init() { proto.RegisterType((*EventUpdateObjectContent)(nil), "greenfield.storage.EventUpdateObjectContent") proto.RegisterType((*EventUpdateObjectContentSuccess)(nil), "greenfield.storage.EventUpdateObjectContentSuccess") proto.RegisterType((*EventCancelUpdateObjectContent)(nil), "greenfield.storage.EventCancelUpdateObjectContent") + proto.RegisterType((*EventSetBucketFlowRateLimit)(nil), "greenfield.storage.EventSetBucketFlowRateLimit") + proto.RegisterType((*EventBucketFlowRateLimitStatus)(nil), "greenfield.storage.EventBucketFlowRateLimitStatus") } func init() { proto.RegisterFile("greenfield/storage/events.proto", fileDescriptor_946dcba4f763ddc4) } var fileDescriptor_946dcba4f763ddc4 = []byte{ - // 1895 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5a, 0xcb, 0x8f, 0x23, 0x47, - 0x19, 0xdf, 0xf6, 0x6b, 0xec, 0xf2, 0xd8, 0xde, 0x69, 0x86, 0x8d, 0x99, 0x24, 0x1e, 0xa7, 0x11, - 0x61, 0x12, 0xb1, 0x36, 0xda, 0x04, 0xb4, 0xb7, 0xd5, 0xcc, 0x6c, 0x40, 0x16, 0x24, 0x59, 0xda, - 0x9b, 0x1c, 0xb8, 0xb4, 0xca, 0xdd, 0x35, 0xde, 0x66, 0xbb, 0xbb, 0x9a, 0xaa, 0xea, 0x99, 0x75, - 0xfe, 0x01, 0x4e, 0x48, 0x91, 0x10, 0x12, 0x5c, 0x72, 0x05, 0x09, 0x21, 0x71, 0xc8, 0x95, 0xfb, - 0x1e, 0x93, 0xe5, 0xc2, 0x43, 0x0a, 0x68, 0xf7, 0x02, 0x48, 0x08, 0xce, 0x9c, 0x50, 0x3d, 0xba, - 0xdd, 0xed, 0xf6, 0xac, 0xa7, 0xbd, 0x99, 0xcc, 0x2c, 0x37, 0xd7, 0xe7, 0xaf, 0xca, 0xdf, 0xe3, - 0xf7, 0x3d, 0xea, 0x2b, 0x83, 0xdd, 0x29, 0x41, 0x28, 0x38, 0x72, 0x91, 0xe7, 0x0c, 0x29, 0xc3, - 0x04, 0x4e, 0xd1, 0x10, 0x1d, 0xa3, 0x80, 0xd1, 0x41, 0x48, 0x30, 0xc3, 0xba, 0x3e, 0x67, 0x18, - 0x28, 0x86, 0x9d, 0xaf, 0xd8, 0x98, 0xfa, 0x98, 0x5a, 0x82, 0x63, 0x28, 0x17, 0x92, 0x7d, 0x67, - 0x7b, 0x8a, 0xa7, 0x58, 0xd2, 0xf9, 0x27, 0x45, 0xdd, 0x9d, 0x62, 0x3c, 0xf5, 0xd0, 0x50, 0xac, - 0x26, 0xd1, 0xd1, 0x90, 0xb9, 0x3e, 0xa2, 0x0c, 0xfa, 0x61, 0xc2, 0x30, 0x17, 0x83, 0x20, 0x8a, - 0x23, 0x62, 0xa3, 0x21, 0x9b, 0x85, 0x88, 0x2e, 0x61, 0x88, 0xe5, 0xb4, 0xb1, 0xef, 0xe3, 0x40, - 0x31, 0xf4, 0x96, 0x30, 0xa4, 0x0e, 0x30, 0xfe, 0x50, 0x01, 0x5b, 0x6f, 0x71, 0xc5, 0x0e, 0x09, - 0x82, 0x0c, 0x1d, 0x44, 0xf6, 0x7d, 0xc4, 0xf4, 0x01, 0xa8, 0xe2, 0x93, 0x00, 0x91, 0xae, 0xd6, - 0xd7, 0xf6, 0x1a, 0x07, 0xdd, 0x47, 0x1f, 0x5f, 0xdf, 0x56, 0xfa, 0xec, 0x3b, 0x0e, 0x41, 0x94, - 0x8e, 0x19, 0x71, 0x83, 0xa9, 0x29, 0xd9, 0xf4, 0x5d, 0xd0, 0x9c, 0x88, 0x9d, 0x56, 0x00, 0x7d, - 0xd4, 0x2d, 0xf1, 0x5d, 0x26, 0x90, 0xa4, 0x77, 0xa0, 0x8f, 0xf4, 0x03, 0x00, 0x8e, 0x5d, 0xea, - 0x4e, 0x5c, 0xcf, 0x65, 0xb3, 0x6e, 0xb9, 0xaf, 0xed, 0xb5, 0x6f, 0x18, 0x83, 0xbc, 0x0d, 0x07, - 0xef, 0x27, 0x5c, 0x77, 0x67, 0x21, 0x32, 0x53, 0xbb, 0xf4, 0x17, 0x41, 0xc3, 0x16, 0x42, 0x5a, - 0x90, 0x75, 0x2b, 0x7d, 0x6d, 0xaf, 0x6c, 0xd6, 0x25, 0x61, 0x9f, 0xe9, 0x37, 0x41, 0x43, 0x49, - 0xe0, 0x3a, 0xdd, 0xaa, 0x90, 0xfa, 0xc5, 0x87, 0x9f, 0xed, 0x5e, 0xf9, 0xf3, 0x67, 0xbb, 0x95, - 0xf7, 0xdc, 0x80, 0x3d, 0xfa, 0xf8, 0x7a, 0x53, 0x69, 0xc0, 0x97, 0x66, 0x5d, 0x72, 0x8f, 0x1c, - 0xfd, 0x16, 0x68, 0x4a, 0xc3, 0x5a, 0xdc, 0x2e, 0xdd, 0x9a, 0x90, 0xad, 0xb7, 0x4c, 0xb6, 0xb1, - 0x60, 0x93, 0x72, 0xd1, 0xe4, 0xb3, 0xfe, 0x0d, 0xa0, 0xdb, 0xf7, 0x20, 0x99, 0x22, 0xc7, 0x22, - 0x08, 0x3a, 0xd6, 0x8f, 0x23, 0xcc, 0x60, 0x77, 0xa3, 0xaf, 0xed, 0x55, 0xcc, 0xab, 0xea, 0x1b, - 0x13, 0x41, 0xe7, 0x07, 0x9c, 0xae, 0xef, 0x83, 0x4e, 0x08, 0x67, 0x3e, 0x0a, 0x98, 0x05, 0xa5, - 0x29, 0xbb, 0xf5, 0x15, 0x46, 0x6e, 0xab, 0x0d, 0x8a, 0xaa, 0x1b, 0xa0, 0x15, 0x12, 0xd7, 0x87, - 0x64, 0x66, 0xd1, 0x90, 0xeb, 0xdb, 0xe8, 0x6b, 0x7b, 0x2d, 0xb3, 0xa9, 0x88, 0xe3, 0x70, 0xe4, - 0xe8, 0x07, 0xa0, 0x37, 0xf5, 0xf0, 0x04, 0x7a, 0xd6, 0xb1, 0x4b, 0x58, 0x04, 0x3d, 0x6b, 0x4a, - 0x70, 0x14, 0x5a, 0x47, 0xd0, 0x77, 0xbd, 0x19, 0xdf, 0x04, 0xc4, 0xa6, 0x1d, 0xc9, 0xf5, 0xbe, - 0x64, 0xfa, 0x2e, 0xe7, 0xf9, 0x8e, 0x60, 0x19, 0x39, 0xfa, 0x4d, 0x50, 0xa3, 0x0c, 0xb2, 0x88, - 0x76, 0x9b, 0xc2, 0x28, 0xfd, 0x65, 0x46, 0x91, 0x88, 0x19, 0x0b, 0x3e, 0x53, 0xf1, 0x1b, 0xbf, - 0x28, 0x29, 0x54, 0xdd, 0x46, 0x1e, 0x4a, 0x50, 0xf5, 0x26, 0xa8, 0xe3, 0x10, 0x11, 0xc8, 0xf0, - 0x6a, 0x60, 0x25, 0x9c, 0x73, 0x2c, 0x96, 0xd6, 0xc2, 0x62, 0x39, 0x87, 0xc5, 0x0c, 0x54, 0x2a, - 0x45, 0xa0, 0xb2, 0xda, 0xa8, 0xd5, 0x55, 0x46, 0x35, 0x7e, 0x52, 0x06, 0x5f, 0x16, 0xa6, 0x79, - 0x2f, 0x74, 0x92, 0x80, 0x1b, 0x05, 0x47, 0x78, 0x4d, 0xf3, 0xac, 0x0c, 0xbd, 0x8c, 0xba, 0xe5, - 0x22, 0xea, 0x2e, 0x07, 0x76, 0xe5, 0x14, 0x60, 0x7f, 0x3d, 0x0f, 0x6c, 0x11, 0x87, 0x39, 0xf8, - 0x66, 0x73, 0x41, 0x6d, 0xad, 0x5c, 0xb0, 0xda, 0x13, 0x1b, 0x2b, 0x3d, 0xf1, 0x6b, 0x0d, 0x5c, - 0x93, 0x20, 0x75, 0xa9, 0x8d, 0x03, 0xe6, 0x06, 0x51, 0x8c, 0xd4, 0x8c, 0xcd, 0xb4, 0x22, 0x36, - 0x5b, 0xe9, 0x8e, 0x6b, 0xa0, 0x46, 0x10, 0xa4, 0x38, 0x50, 0xc8, 0x54, 0x2b, 0x9e, 0xdd, 0x1c, - 0x11, 0x2c, 0xa9, 0xec, 0x26, 0x09, 0xfb, 0xcc, 0xf8, 0x59, 0x2d, 0x93, 0xa5, 0xdf, 0x9d, 0xfc, - 0x08, 0xd9, 0x4c, 0xbf, 0x01, 0x36, 0x44, 0xfe, 0x3b, 0x03, 0x5e, 0x62, 0xc6, 0xcf, 0x3f, 0x9a, - 0x76, 0x41, 0x13, 0x0b, 0x71, 0x24, 0x43, 0x45, 0x32, 0x48, 0x52, 0x1e, 0x7f, 0xb5, 0x22, 0xb6, - 0xbc, 0x09, 0x1a, 0xea, 0x68, 0xe5, 0xcf, 0x55, 0x3b, 0x25, 0xf7, 0xc8, 0xc9, 0x67, 0xc8, 0x7a, - 0x3e, 0x43, 0xbe, 0x02, 0x36, 0x43, 0x38, 0xf3, 0x30, 0x74, 0x2c, 0xea, 0x7e, 0x80, 0x44, 0x12, - 0xad, 0x98, 0x4d, 0x45, 0x1b, 0xbb, 0x1f, 0x2c, 0x56, 0x2d, 0xb0, 0x16, 0x52, 0x5f, 0x01, 0x9b, - 0x1c, 0x5c, 0x3c, 0x2c, 0x44, 0x7d, 0x69, 0x0a, 0x03, 0x35, 0x15, 0x4d, 0x14, 0x90, 0x4c, 0x61, - 0xdb, 0xcc, 0x15, 0xb6, 0x38, 0x09, 0xb7, 0x4e, 0x4f, 0xc2, 0x12, 0x10, 0xd9, 0x24, 0xac, 0x7f, - 0x0f, 0x74, 0x08, 0x72, 0xa2, 0xc0, 0x81, 0x81, 0x3d, 0x93, 0x3f, 0xde, 0x3e, 0x5d, 0x05, 0x33, - 0x61, 0x15, 0x2a, 0xb4, 0x49, 0x66, 0xbd, 0x58, 0x25, 0x3b, 0x85, 0xab, 0xe4, 0x4b, 0xa0, 0x61, - 0xdf, 0x43, 0xf6, 0x7d, 0x1a, 0xf9, 0xb4, 0x7b, 0xb5, 0x5f, 0xde, 0xdb, 0x34, 0xe7, 0x04, 0xfd, - 0x0d, 0x70, 0xcd, 0xc3, 0x76, 0x2e, 0x9c, 0x5d, 0xa7, 0xbb, 0x25, 0x3c, 0xf7, 0x25, 0xf1, 0x6d, - 0x3a, 0x8c, 0x47, 0x8e, 0xf1, 0x6f, 0x0d, 0xbc, 0x20, 0xa3, 0x02, 0x06, 0x36, 0xf2, 0x32, 0xb1, - 0x71, 0x4e, 0xc9, 0x74, 0x01, 0xed, 0xe5, 0x1c, 0xda, 0x73, 0xc8, 0xab, 0xe4, 0x91, 0x97, 0xc1, - 0x75, 0xad, 0x00, 0xae, 0x79, 0xf1, 0xe8, 0x08, 0x8d, 0xc7, 0x08, 0x7a, 0x17, 0xac, 0x69, 0x46, - 0x8b, 0x6a, 0x91, 0xe8, 0x9c, 0x43, 0xba, 0x56, 0x10, 0xd2, 0xdf, 0x02, 0x2f, 0x2c, 0x4d, 0xfb, - 0x49, 0xbe, 0xdf, 0xce, 0xe7, 0xfb, 0x91, 0xf3, 0x14, 0x74, 0xd5, 0x4f, 0x45, 0x57, 0x16, 0xb0, - 0x8d, 0x05, 0xc0, 0x1a, 0x1f, 0xc5, 0x9e, 0x38, 0xc4, 0xe1, 0xec, 0x99, 0x3c, 0xf1, 0x2a, 0xe8, - 0x50, 0x62, 0x5b, 0x79, 0x6f, 0xb4, 0x28, 0xb1, 0x0f, 0xe6, 0x0e, 0x51, 0x7c, 0x79, 0xa7, 0x70, - 0xbe, 0x77, 0xe7, 0x7e, 0x79, 0x15, 0x74, 0x1c, 0xca, 0x32, 0xe7, 0xc9, 0xa4, 0xdc, 0x72, 0x28, - 0xcb, 0x9e, 0xc7, 0xf9, 0xd2, 0xe7, 0x55, 0x13, 0xbe, 0xd4, 0x79, 0xb7, 0x40, 0x2b, 0xf5, 0xbb, - 0x67, 0x43, 0x6c, 0x33, 0x11, 0x49, 0x34, 0xd8, 0xad, 0xd4, 0x0f, 0x9d, 0x2d, 0x95, 0x37, 0x13, - 0x19, 0xd6, 0x74, 0x9f, 0xf1, 0x5f, 0x2d, 0xd3, 0x82, 0x5e, 0xa6, 0x60, 0xa9, 0x14, 0x09, 0x96, - 0xd3, 0x95, 0xaf, 0x9e, 0xae, 0xfc, 0xdf, 0x35, 0xd5, 0x64, 0x9a, 0x48, 0x44, 0xd1, 0x25, 0xcb, - 0x16, 0x85, 0x0c, 0xf0, 0x32, 0x00, 0x47, 0x98, 0x58, 0x91, 0x68, 0x97, 0x85, 0xd2, 0x75, 0xb3, - 0x71, 0x84, 0x89, 0xec, 0x9f, 0x97, 0x76, 0x71, 0x4a, 0xd7, 0x05, 0xa9, 0xb5, 0x65, 0xad, 0xf1, - 0x5c, 0xa8, 0x52, 0x11, 0xa1, 0xd6, 0xea, 0xe2, 0x7e, 0x5a, 0xca, 0xb4, 0xfe, 0x0a, 0xdf, 0xe7, - 0xd8, 0xfa, 0x9f, 0xa3, 0x57, 0xb2, 0xad, 0x51, 0x75, 0x9d, 0xd6, 0xc8, 0xf8, 0x8f, 0x06, 0xae, - 0xa6, 0xba, 0x5a, 0x01, 0xde, 0xc2, 0xa3, 0x87, 0x97, 0x01, 0x90, 0x11, 0x91, 0xb2, 0x41, 0x43, - 0x50, 0x84, 0x86, 0xdf, 0x06, 0xf5, 0x24, 0x60, 0xce, 0x70, 0xf9, 0xd9, 0x98, 0xaa, 0xec, 0xbf, - 0xd0, 0xef, 0x54, 0x0a, 0xf7, 0x3b, 0xdb, 0xa0, 0x8a, 0x1e, 0x30, 0x02, 0x55, 0x52, 0x95, 0x0b, - 0xe3, 0x97, 0xb1, 0xca, 0x32, 0x2b, 0x2d, 0xa8, 0x5c, 0x5a, 0x47, 0xe5, 0xf2, 0xd3, 0x54, 0xae, - 0x9c, 0x5d, 0x65, 0xe3, 0x4f, 0x9a, 0x2a, 0x69, 0xdf, 0x47, 0xf0, 0x58, 0x89, 0x76, 0x0b, 0xb4, - 0x7d, 0xe4, 0x4f, 0x10, 0x49, 0xee, 0x74, 0xab, 0xdc, 0xd2, 0x92, 0xfc, 0xf1, 0x65, 0xef, 0x92, - 0xe8, 0xf6, 0xaf, 0x92, 0xca, 0x12, 0x32, 0xf4, 0x84, 0x72, 0x6f, 0x0b, 0x41, 0xbf, 0xa0, 0xa9, - 0xc4, 0xf9, 0xe8, 0xa5, 0xdf, 0x89, 0xfd, 0x43, 0x2d, 0x86, 0xb9, 0x8f, 0xba, 0xd5, 0x7e, 0x79, - 0xaf, 0x79, 0xe3, 0xf5, 0x65, 0x48, 0x15, 0x06, 0x48, 0xa9, 0x7e, 0x1b, 0x31, 0xe8, 0x7a, 0xe6, - 0xa6, 0x3a, 0xe1, 0x2e, 0xde, 0x77, 0x1c, 0xfd, 0x36, 0xd8, 0x4a, 0x9d, 0x28, 0x73, 0x57, 0xb7, - 0xd6, 0x2f, 0x3f, 0x55, 0xc9, 0x4e, 0x72, 0x84, 0xc4, 0xb5, 0xf1, 0x97, 0x52, 0x52, 0x80, 0x02, - 0x74, 0xf2, 0x7f, 0x63, 0xee, 0x85, 0xac, 0x50, 0x2d, 0x9c, 0x15, 0x6e, 0x83, 0x0d, 0x65, 0x2a, - 0x61, 0xd3, 0x62, 0x8e, 0x8a, 0xb7, 0x1a, 0x3f, 0x8f, 0x6b, 0x5e, 0x8e, 0x47, 0xff, 0x26, 0xa8, - 0x49, 0xae, 0x95, 0xc6, 0x55, 0x7c, 0xfa, 0x08, 0x74, 0xd0, 0x83, 0xd0, 0x25, 0x90, 0xb9, 0x38, - 0xb0, 0x98, 0xab, 0xb2, 0x68, 0xf3, 0xc6, 0xce, 0x40, 0x8e, 0xa7, 0x07, 0xf1, 0x78, 0x7a, 0x70, - 0x37, 0x1e, 0x4f, 0x1f, 0x54, 0x3e, 0xfc, 0xeb, 0xae, 0x66, 0xb6, 0xe7, 0x1b, 0xf9, 0x57, 0xc6, - 0x3f, 0xb5, 0x4c, 0x81, 0x13, 0xd2, 0xbd, 0xc5, 0xf3, 0xde, 0xf3, 0xed, 0xf5, 0xe5, 0xa9, 0xfc, - 0x61, 0xdc, 0x60, 0xbe, 0xed, 0x12, 0x82, 0xc9, 0x33, 0xcd, 0x38, 0x8b, 0x0d, 0xf1, 0x0a, 0xcd, - 0x2c, 0x0d, 0xd0, 0x72, 0x10, 0x65, 0x96, 0x7d, 0x0f, 0xba, 0xc1, 0xbc, 0x6d, 0x6c, 0x72, 0xe2, - 0x21, 0xa7, 0x8d, 0x1c, 0xe3, 0x77, 0xf1, 0x45, 0x3a, 0xad, 0x8a, 0x89, 0x68, 0xe4, 0x31, 0xde, - 0xe9, 0xa8, 0xcb, 0x9a, 0x26, 0x36, 0xc6, 0x57, 0xb1, 0x0b, 0x16, 0xf9, 0x1f, 0x59, 0xeb, 0x3f, - 0xb7, 0xdd, 0xed, 0x59, 0x74, 0xfd, 0x34, 0xeb, 0x1e, 0xa9, 0xeb, 0xb3, 0xba, 0xe7, 0x82, 0x75, - 0xfa, 0x7d, 0xdc, 0x08, 0x49, 0x9d, 0x2e, 0x55, 0xef, 0x97, 0x93, 0xbf, 0x92, 0x97, 0xff, 0x37, - 0x71, 0x0a, 0x4e, 0xc9, 0xbf, 0xc2, 0x25, 0x17, 0x28, 0xed, 0xb1, 0x02, 0xd0, 0x98, 0x41, 0x0f, - 0xdd, 0xc1, 0x9e, 0x6b, 0xcf, 0x0e, 0x3d, 0x04, 0x83, 0x28, 0xd4, 0x77, 0x40, 0x7d, 0xe2, 0x61, - 0xfb, 0xfe, 0x3b, 0x91, 0x2f, 0xe4, 0x2d, 0x9b, 0xc9, 0x9a, 0x97, 0x3b, 0x75, 0x9b, 0x71, 0x83, - 0x23, 0xac, 0xca, 0xc2, 0xd2, 0x72, 0x27, 0xcb, 0x3e, 0xbf, 0xcb, 0x98, 0xc0, 0x49, 0x3e, 0x1b, - 0x8f, 0x34, 0xb0, 0xad, 0xac, 0x34, 0x95, 0x75, 0xe2, 0x0b, 0x4c, 0x93, 0x85, 0xde, 0x3a, 0x5e, - 0x03, 0x5b, 0x0e, 0x65, 0xd6, 0xb2, 0xd9, 0x5d, 0xdb, 0xa1, 0xec, 0xce, 0x7c, 0x7c, 0x67, 0xfc, - 0x56, 0x03, 0x3b, 0xa9, 0xb1, 0xe3, 0x65, 0x57, 0x8d, 0x43, 0xb5, 0x9b, 0x1a, 0x06, 0x48, 0x79, - 0xd1, 0x65, 0x95, 0xf6, 0xa3, 0x12, 0x78, 0x49, 0x0d, 0xd6, 0xfc, 0x90, 0x03, 0xe9, 0xd2, 0x43, - 0x67, 0xf5, 0x5b, 0x54, 0x65, 0xe5, 0x53, 0xeb, 0x6b, 0x60, 0x8b, 0x12, 0x7b, 0x01, 0x7e, 0x32, - 0x6d, 0xb6, 0x29, 0xb1, 0xd3, 0xf0, 0xb3, 0x40, 0x53, 0x8d, 0x80, 0xd9, 0x5d, 0x38, 0xe5, 0xf1, - 0x1b, 0xff, 0x33, 0x40, 0x4d, 0x38, 0x92, 0xb5, 0xfe, 0x26, 0xa8, 0x30, 0x38, 0xa5, 0x2a, 0x70, - 0xfb, 0xcb, 0xc7, 0xfe, 0xaa, 0x3b, 0x85, 0x53, 0x6a, 0x0a, 0x6e, 0xe3, 0x57, 0x25, 0x85, 0x97, - 0xf4, 0x98, 0xe2, 0x50, 0xbe, 0x57, 0xac, 0x69, 0xfd, 0xf5, 0x07, 0x2d, 0xcf, 0xfe, 0xfe, 0xb4, - 0xf8, 0xce, 0x53, 0xcd, 0xbf, 0xf3, 0x64, 0x46, 0xbd, 0xb5, 0xc5, 0xb7, 0x89, 0x2e, 0xd8, 0x38, - 0x46, 0x84, 0xba, 0x38, 0x10, 0x93, 0xcb, 0xb2, 0x19, 0x2f, 0x8d, 0x4f, 0xcb, 0x60, 0xf7, 0x34, - 0x4b, 0x8d, 0x23, 0xdb, 0xe6, 0x17, 0xe0, 0xe7, 0xd2, 0x60, 0x99, 0x17, 0xab, 0x6a, 0xfe, 0xc5, - 0xea, 0x75, 0xb0, 0x15, 0x12, 0x74, 0x6c, 0x65, 0x0c, 0x5b, 0x13, 0x86, 0xed, 0xf0, 0x2f, 0xee, - 0xa4, 0x8c, 0xbb, 0x07, 0xae, 0x06, 0xe8, 0x24, 0xcb, 0x2a, 0xff, 0x1c, 0xd1, 0x0e, 0xd0, 0x49, - 0x9a, 0xf3, 0x6b, 0xa0, 0x2d, 0x4e, 0x9d, 0xfb, 0xa2, 0x2e, 0x7c, 0xd1, 0xe2, 0xd4, 0xc3, 0xc4, - 0x1f, 0x5f, 0x05, 0x2d, 0x7e, 0xe0, 0xe2, 0x70, 0x7e, 0x33, 0x40, 0x27, 0x87, 0xcb, 0x9c, 0x06, - 0x32, 0x4e, 0xe3, 0x65, 0x58, 0xce, 0x12, 0x1d, 0x0b, 0x32, 0xf1, 0x1c, 0x57, 0x36, 0x1b, 0x8a, - 0xb2, 0xcf, 0x78, 0xc9, 0xea, 0xa5, 0xb2, 0xfb, 0xe7, 0x17, 0x03, 0x17, 0xd8, 0x91, 0x1d, 0x8c, - 0x1e, 0x3e, 0xee, 0x69, 0x9f, 0x3c, 0xee, 0x69, 0x7f, 0x7b, 0xdc, 0xd3, 0x3e, 0x7c, 0xd2, 0xbb, - 0xf2, 0xc9, 0x93, 0xde, 0x95, 0x3f, 0x3e, 0xe9, 0x5d, 0xf9, 0xe1, 0x70, 0xea, 0xb2, 0x7b, 0xd1, - 0x64, 0x60, 0x63, 0x7f, 0x38, 0x09, 0x26, 0xd7, 0x45, 0x17, 0x31, 0x4c, 0xfd, 0x69, 0xe8, 0x41, - 0xf6, 0x6f, 0x43, 0x93, 0x9a, 0xb8, 0x0d, 0xbe, 0xf1, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf9, - 0x82, 0xe2, 0x4e, 0x22, 0x25, 0x00, 0x00, + // 2015 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5a, 0xcd, 0x8f, 0x1b, 0x49, + 0x15, 0x4f, 0xfb, 0x6b, 0xec, 0xe7, 0xb1, 0x9d, 0x69, 0x86, 0xac, 0x99, 0x6c, 0x3c, 0xde, 0x46, + 0x84, 0xd9, 0x15, 0xf1, 0xa0, 0xec, 0x82, 0x22, 0x81, 0x14, 0xcd, 0x4c, 0x76, 0x91, 0x45, 0x76, + 0x13, 0xda, 0xd9, 0x3d, 0x70, 0x69, 0xca, 0xdd, 0x65, 0xa7, 0x49, 0xbb, 0xcb, 0x74, 0x95, 0x67, + 0xe2, 0xfd, 0x07, 0x38, 0x21, 0xad, 0x84, 0x90, 0xe0, 0xb2, 0x57, 0x90, 0x10, 0x12, 0x87, 0xbd, + 0x72, 0xcf, 0x71, 0x37, 0x5c, 0x60, 0x91, 0x16, 0x94, 0x5c, 0x00, 0x09, 0xc1, 0x99, 0x13, 0xaa, + 0x8f, 0x6e, 0x77, 0xbb, 0x3d, 0xf1, 0xb4, 0xb3, 0xb3, 0x33, 0xe1, 0x34, 0xd3, 0xcf, 0xaf, 0xaa, + 0xdf, 0xc7, 0xef, 0x7d, 0xd4, 0xab, 0x86, 0xed, 0x61, 0x80, 0xb1, 0x3f, 0x70, 0xb1, 0xe7, 0xec, + 0x52, 0x46, 0x02, 0x34, 0xc4, 0xbb, 0xf8, 0x10, 0xfb, 0x8c, 0x76, 0xc6, 0x01, 0x61, 0x44, 0xd7, + 0x67, 0x0c, 0x1d, 0xc5, 0xb0, 0xf5, 0x15, 0x9b, 0xd0, 0x11, 0xa1, 0x96, 0xe0, 0xd8, 0x95, 0x0f, + 0x92, 0x7d, 0x6b, 0x73, 0x48, 0x86, 0x44, 0xd2, 0xf9, 0x7f, 0x8a, 0xba, 0x3d, 0x24, 0x64, 0xe8, + 0xe1, 0x5d, 0xf1, 0xd4, 0x9f, 0x0c, 0x76, 0x99, 0x3b, 0xc2, 0x94, 0xa1, 0xd1, 0x38, 0x62, 0x98, + 0x89, 0x11, 0x60, 0x4a, 0x26, 0x81, 0x8d, 0x77, 0xd9, 0x74, 0x8c, 0xe9, 0x02, 0x86, 0x50, 0x4e, + 0x9b, 0x8c, 0x46, 0xc4, 0x57, 0x0c, 0xad, 0x05, 0x0c, 0xb1, 0x0d, 0x8c, 0x3f, 0x16, 0x60, 0xe3, + 0x4d, 0xae, 0xd8, 0x41, 0x80, 0x11, 0xc3, 0xfb, 0x13, 0xfb, 0x01, 0x66, 0x7a, 0x07, 0x8a, 0xe4, + 0xc8, 0xc7, 0x41, 0x53, 0x6b, 0x6b, 0x3b, 0x95, 0xfd, 0xe6, 0xe3, 0x8f, 0xae, 0x6d, 0x2a, 0x7d, + 0xf6, 0x1c, 0x27, 0xc0, 0x94, 0xf6, 0x58, 0xe0, 0xfa, 0x43, 0x53, 0xb2, 0xe9, 0xdb, 0x50, 0xed, + 0x8b, 0x95, 0x96, 0x8f, 0x46, 0xb8, 0x99, 0xe3, 0xab, 0x4c, 0x90, 0xa4, 0x77, 0xd0, 0x08, 0xeb, + 0xfb, 0x00, 0x87, 0x2e, 0x75, 0xfb, 0xae, 0xe7, 0xb2, 0x69, 0x33, 0xdf, 0xd6, 0x76, 0xea, 0xd7, + 0x8d, 0x4e, 0xda, 0x86, 0x9d, 0xf7, 0x22, 0xae, 0x7b, 0xd3, 0x31, 0x36, 0x63, 0xab, 0xf4, 0xcb, + 0x50, 0xb1, 0x85, 0x90, 0x16, 0x62, 0xcd, 0x42, 0x5b, 0xdb, 0xc9, 0x9b, 0x65, 0x49, 0xd8, 0x63, + 0xfa, 0x0d, 0xa8, 0x28, 0x09, 0x5c, 0xa7, 0x59, 0x14, 0x52, 0x5f, 0x7e, 0xf4, 0xd9, 0xf6, 0x85, + 0x4f, 0x3f, 0xdb, 0x2e, 0xbc, 0xeb, 0xfa, 0xec, 0xf1, 0x47, 0xd7, 0xaa, 0x4a, 0x03, 0xfe, 0x68, + 0x96, 0x25, 0x77, 0xd7, 0xd1, 0x6f, 0x42, 0x55, 0x1a, 0xd6, 0xe2, 0x76, 0x69, 0x96, 0x84, 0x6c, + 0xad, 0x45, 0xb2, 0xf5, 0x04, 0x9b, 0x94, 0x8b, 0x46, 0xff, 0xeb, 0xdf, 0x00, 0xdd, 0xbe, 0x8f, + 0x82, 0x21, 0x76, 0xac, 0x00, 0x23, 0xc7, 0xfa, 0xc9, 0x84, 0x30, 0xd4, 0x5c, 0x6b, 0x6b, 0x3b, + 0x05, 0xf3, 0xa2, 0xfa, 0xc5, 0xc4, 0xc8, 0xf9, 0x01, 0xa7, 0xeb, 0x7b, 0xd0, 0x18, 0xa3, 0xe9, + 0x08, 0xfb, 0xcc, 0x42, 0xd2, 0x94, 0xcd, 0xf2, 0x12, 0x23, 0xd7, 0xd5, 0x02, 0x45, 0xd5, 0x0d, + 0xa8, 0x8d, 0x03, 0x77, 0x84, 0x82, 0xa9, 0x45, 0xc7, 0x5c, 0xdf, 0x4a, 0x5b, 0xdb, 0xa9, 0x99, + 0x55, 0x45, 0xec, 0x8d, 0xbb, 0x8e, 0xbe, 0x0f, 0xad, 0xa1, 0x47, 0xfa, 0xc8, 0xb3, 0x0e, 0xdd, + 0x80, 0x4d, 0x90, 0x67, 0x0d, 0x03, 0x32, 0x19, 0x5b, 0x03, 0x34, 0x72, 0xbd, 0x29, 0x5f, 0x04, + 0x62, 0xd1, 0x96, 0xe4, 0x7a, 0x4f, 0x32, 0x7d, 0x8f, 0xf3, 0xbc, 0x25, 0x58, 0xba, 0x8e, 0x7e, + 0x03, 0x4a, 0x94, 0x21, 0x36, 0xa1, 0xcd, 0xaa, 0x30, 0x4a, 0x7b, 0x91, 0x51, 0x24, 0x62, 0x7a, + 0x82, 0xcf, 0x54, 0xfc, 0xc6, 0x2f, 0x73, 0x0a, 0x55, 0xb7, 0xb0, 0x87, 0x23, 0x54, 0xbd, 0x01, + 0x65, 0x32, 0xc6, 0x01, 0x62, 0x64, 0x39, 0xb0, 0x22, 0xce, 0x19, 0x16, 0x73, 0x2b, 0x61, 0x31, + 0x9f, 0xc2, 0x62, 0x02, 0x2a, 0x85, 0x2c, 0x50, 0x59, 0x6e, 0xd4, 0xe2, 0x32, 0xa3, 0x1a, 0x3f, + 0xcd, 0xc3, 0x97, 0x85, 0x69, 0xde, 0x1d, 0x3b, 0x51, 0xc0, 0x75, 0xfd, 0x01, 0x59, 0xd1, 0x3c, + 0x4b, 0x43, 0x2f, 0xa1, 0x6e, 0x3e, 0x8b, 0xba, 0x8b, 0x81, 0x5d, 0x38, 0x06, 0xd8, 0x5f, 0x4f, + 0x03, 0x5b, 0xc4, 0x61, 0x0a, 0xbe, 0xc9, 0x5c, 0x50, 0x5a, 0x29, 0x17, 0x2c, 0xf7, 0xc4, 0xda, + 0x52, 0x4f, 0xfc, 0x46, 0x83, 0x4b, 0x12, 0xa4, 0x2e, 0xb5, 0x89, 0xcf, 0x5c, 0x7f, 0x12, 0x22, + 0x35, 0x61, 0x33, 0x2d, 0x8b, 0xcd, 0x96, 0xba, 0xe3, 0x12, 0x94, 0x02, 0x8c, 0x28, 0xf1, 0x15, + 0x32, 0xd5, 0x13, 0xcf, 0x6e, 0x8e, 0x08, 0x96, 0x58, 0x76, 0x93, 0x84, 0x3d, 0x66, 0xfc, 0xbc, + 0x94, 0xc8, 0xd2, 0x77, 0xfa, 0x3f, 0xc6, 0x36, 0xd3, 0xaf, 0xc3, 0x9a, 0xc8, 0x7f, 0x27, 0xc0, + 0x4b, 0xc8, 0xf8, 0xf9, 0x47, 0xd3, 0x36, 0x54, 0x89, 0x10, 0x47, 0x32, 0x14, 0x24, 0x83, 0x24, + 0xa5, 0xf1, 0x57, 0xca, 0x62, 0xcb, 0x1b, 0x50, 0x51, 0x5b, 0x2b, 0x7f, 0x2e, 0x5b, 0x29, 0xb9, + 0xbb, 0x4e, 0x3a, 0x43, 0x96, 0xd3, 0x19, 0xf2, 0x15, 0x58, 0x1f, 0xa3, 0xa9, 0x47, 0x90, 0x63, + 0x51, 0xf7, 0x7d, 0x2c, 0x92, 0x68, 0xc1, 0xac, 0x2a, 0x5a, 0xcf, 0x7d, 0x7f, 0xbe, 0x6a, 0xc1, + 0x4a, 0x48, 0x7d, 0x05, 0xd6, 0x39, 0xb8, 0x78, 0x58, 0x88, 0xfa, 0x52, 0x15, 0x06, 0xaa, 0x2a, + 0x9a, 0x28, 0x20, 0x89, 0xc2, 0xb6, 0x9e, 0x2a, 0x6c, 0x61, 0x12, 0xae, 0x1d, 0x9f, 0x84, 0x25, + 0x20, 0x92, 0x49, 0x58, 0xff, 0x3e, 0x34, 0x02, 0xec, 0x4c, 0x7c, 0x07, 0xf9, 0xf6, 0x54, 0xbe, + 0xbc, 0x7e, 0xbc, 0x0a, 0x66, 0xc4, 0x2a, 0x54, 0xa8, 0x07, 0x89, 0xe7, 0xf9, 0x2a, 0xd9, 0xc8, + 0x5c, 0x25, 0x5f, 0x86, 0x8a, 0x7d, 0x1f, 0xdb, 0x0f, 0xe8, 0x64, 0x44, 0x9b, 0x17, 0xdb, 0xf9, + 0x9d, 0x75, 0x73, 0x46, 0xd0, 0x5f, 0x87, 0x4b, 0x1e, 0xb1, 0x53, 0xe1, 0xec, 0x3a, 0xcd, 0x0d, + 0xe1, 0xb9, 0x2f, 0x89, 0x5f, 0xe3, 0x61, 0xdc, 0x75, 0x8c, 0x7f, 0x6b, 0xf0, 0x92, 0x8c, 0x0a, + 0xe4, 0xdb, 0xd8, 0x4b, 0xc4, 0xc6, 0x29, 0x25, 0xd3, 0x39, 0xb4, 0xe7, 0x53, 0x68, 0x4f, 0x21, + 0xaf, 0x90, 0x46, 0x5e, 0x02, 0xd7, 0xa5, 0x0c, 0xb8, 0xe6, 0xc5, 0xa3, 0x21, 0x34, 0xee, 0x61, + 0xe4, 0x9d, 0xb1, 0xa6, 0x09, 0x2d, 0x8a, 0x59, 0xa2, 0x73, 0x06, 0xe9, 0x52, 0x46, 0x48, 0x7f, + 0x0b, 0x5e, 0x5a, 0x98, 0xf6, 0xa3, 0x7c, 0xbf, 0x99, 0xce, 0xf7, 0x5d, 0xe7, 0x19, 0xe8, 0x2a, + 0x1f, 0x8b, 0xae, 0x24, 0x60, 0x2b, 0x73, 0x80, 0x35, 0x3e, 0x0c, 0x3d, 0x71, 0x40, 0xc6, 0xd3, + 0xe7, 0xf2, 0xc4, 0x55, 0x68, 0xd0, 0xc0, 0xb6, 0xd2, 0xde, 0xa8, 0xd1, 0xc0, 0xde, 0x9f, 0x39, + 0x44, 0xf1, 0xa5, 0x9d, 0xc2, 0xf9, 0xee, 0xcc, 0xfc, 0x72, 0x15, 0x1a, 0x0e, 0x65, 0x89, 0xfd, + 0x64, 0x52, 0xae, 0x39, 0x94, 0x25, 0xf7, 0xe3, 0x7c, 0xf1, 0xfd, 0x8a, 0x11, 0x5f, 0x6c, 0xbf, + 0x9b, 0x50, 0x8b, 0xbd, 0xf7, 0x64, 0x88, 0xad, 0x46, 0x22, 0x89, 0x06, 0xbb, 0x16, 0x7b, 0xd1, + 0xc9, 0x52, 0x79, 0x35, 0x92, 0x61, 0x45, 0xf7, 0x19, 0xff, 0xd5, 0x12, 0x2d, 0xe8, 0x79, 0x0a, + 0x96, 0x42, 0x96, 0x60, 0x39, 0x5e, 0xf9, 0xe2, 0xf1, 0xca, 0xff, 0x5d, 0x53, 0x4d, 0xa6, 0x89, + 0x45, 0x14, 0x9d, 0xb3, 0x6c, 0x91, 0xc9, 0x00, 0x57, 0x00, 0x06, 0x24, 0xb0, 0x26, 0xa2, 0x5d, + 0x16, 0x4a, 0x97, 0xcd, 0xca, 0x80, 0x04, 0xb2, 0x7f, 0x5e, 0xd8, 0xc5, 0x29, 0x5d, 0xe7, 0xa4, + 0xd6, 0x16, 0xb5, 0xc6, 0x33, 0xa1, 0x72, 0x59, 0x84, 0x5a, 0xa9, 0x8b, 0xfb, 0x59, 0x2e, 0xd1, + 0xfa, 0x2b, 0x7c, 0x9f, 0x62, 0xeb, 0x7f, 0x8a, 0x5e, 0x49, 0xb6, 0x46, 0xc5, 0x55, 0x5a, 0x23, + 0xe3, 0x3f, 0x1a, 0x5c, 0x8c, 0x75, 0xb5, 0x02, 0xbc, 0x99, 0x47, 0x0f, 0x57, 0x00, 0x64, 0x44, + 0xc4, 0x6c, 0x50, 0x11, 0x14, 0xa1, 0xe1, 0xb7, 0xa1, 0x1c, 0x05, 0xcc, 0x09, 0x0e, 0x3f, 0x6b, + 0x43, 0x95, 0xfd, 0xe7, 0xfa, 0x9d, 0x42, 0xe6, 0x7e, 0x67, 0x13, 0x8a, 0xf8, 0x21, 0x0b, 0x90, + 0x4a, 0xaa, 0xf2, 0xc1, 0xf8, 0x55, 0xa8, 0xb2, 0xcc, 0x4a, 0x73, 0x2a, 0xe7, 0x56, 0x51, 0x39, + 0xff, 0x2c, 0x95, 0x0b, 0x27, 0x57, 0xd9, 0xf8, 0xb3, 0xa6, 0x4a, 0xda, 0x6d, 0x8c, 0x0e, 0x95, + 0x68, 0x37, 0xa1, 0x3e, 0xc2, 0xa3, 0x3e, 0x0e, 0xa2, 0x33, 0xdd, 0x32, 0xb7, 0xd4, 0x24, 0x7f, + 0x78, 0xd8, 0x3b, 0x27, 0xba, 0xfd, 0x2b, 0xa7, 0xb2, 0x84, 0x0c, 0x3d, 0xa1, 0xdc, 0xdb, 0x42, + 0xd0, 0x2f, 0x68, 0x2a, 0x71, 0x3a, 0x7a, 0xe9, 0x77, 0x43, 0xff, 0x50, 0x8b, 0x11, 0xee, 0xa3, + 0x66, 0xb1, 0x9d, 0xdf, 0xa9, 0x5e, 0x7f, 0x6d, 0x11, 0x52, 0x85, 0x01, 0x62, 0xaa, 0xdf, 0xc2, + 0x0c, 0xb9, 0x9e, 0xb9, 0xae, 0x76, 0xb8, 0x47, 0xf6, 0x1c, 0x47, 0xbf, 0x05, 0x1b, 0xb1, 0x1d, + 0x65, 0xee, 0x6a, 0x96, 0xda, 0xf9, 0x67, 0x2a, 0xd9, 0x88, 0xb6, 0x90, 0xb8, 0x36, 0xfe, 0x92, + 0x8b, 0x0a, 0x90, 0x8f, 0x8f, 0xfe, 0x6f, 0xcc, 0x3d, 0x97, 0x15, 0x8a, 0x99, 0xb3, 0xc2, 0x2d, + 0x58, 0x53, 0xa6, 0x12, 0x36, 0xcd, 0xe6, 0xa8, 0x70, 0xa9, 0xf1, 0x8b, 0xb0, 0xe6, 0xa5, 0x78, + 0xf4, 0x6f, 0x42, 0x49, 0x72, 0x2d, 0x35, 0xae, 0xe2, 0xd3, 0xbb, 0xd0, 0xc0, 0x0f, 0xc7, 0x6e, + 0x80, 0x98, 0x4b, 0x7c, 0x8b, 0xb9, 0x2a, 0x8b, 0x56, 0xaf, 0x6f, 0x75, 0xe4, 0x78, 0xba, 0x13, + 0x8e, 0xa7, 0x3b, 0xf7, 0xc2, 0xf1, 0xf4, 0x7e, 0xe1, 0x83, 0xbf, 0x6e, 0x6b, 0x66, 0x7d, 0xb6, + 0x90, 0xff, 0x64, 0xfc, 0x53, 0x4b, 0x14, 0x38, 0x21, 0xdd, 0x9b, 0x3c, 0xef, 0xbd, 0xd8, 0x5e, + 0x5f, 0x9c, 0xca, 0x1f, 0x85, 0x0d, 0xe6, 0xdb, 0x6e, 0x10, 0x90, 0xe0, 0xb9, 0x66, 0x9c, 0xd9, + 0x86, 0x78, 0x99, 0x66, 0x96, 0x06, 0xd4, 0x1c, 0x4c, 0x99, 0x65, 0xdf, 0x47, 0xae, 0x3f, 0x6b, + 0x1b, 0xab, 0x9c, 0x78, 0xc0, 0x69, 0x5d, 0xc7, 0xf8, 0x7d, 0x78, 0x90, 0x8e, 0xab, 0x62, 0x62, + 0x3a, 0xf1, 0x18, 0xef, 0x74, 0xd4, 0x61, 0x4d, 0x13, 0x0b, 0xc3, 0xa3, 0xd8, 0x19, 0x8b, 0xfc, + 0x8f, 0xa4, 0xf5, 0x5f, 0xd8, 0xee, 0xf6, 0x24, 0xba, 0x7e, 0x92, 0x74, 0x8f, 0xd4, 0xf5, 0x79, + 0xdd, 0x73, 0xc6, 0x3a, 0xfd, 0x21, 0x6c, 0x84, 0xa4, 0x4e, 0xe7, 0xaa, 0xf7, 0x4b, 0xc9, 0x5f, + 0x48, 0xcb, 0xff, 0xdb, 0x30, 0x05, 0xc7, 0xe4, 0x5f, 0xe2, 0x92, 0x33, 0x94, 0xf6, 0x50, 0x01, + 0xa8, 0xc7, 0x90, 0x87, 0xef, 0x12, 0xcf, 0xb5, 0xa7, 0x07, 0x1e, 0x46, 0xfe, 0x64, 0xac, 0x6f, + 0x41, 0xb9, 0xef, 0x11, 0xfb, 0xc1, 0x3b, 0x93, 0x91, 0x90, 0x37, 0x6f, 0x46, 0xcf, 0xbc, 0xdc, + 0xa9, 0xd3, 0x8c, 0xeb, 0x0f, 0x88, 0x2a, 0x0b, 0x0b, 0xcb, 0x9d, 0x2c, 0xfb, 0xfc, 0x2c, 0x63, + 0x82, 0x13, 0xfd, 0x6f, 0x3c, 0xd6, 0x60, 0x53, 0x59, 0x69, 0x28, 0xeb, 0xc4, 0x17, 0x98, 0x26, + 0x33, 0xdd, 0x75, 0xbc, 0x0a, 0x1b, 0x0e, 0x65, 0xd6, 0xa2, 0xd9, 0x5d, 0xdd, 0xa1, 0xec, 0xee, + 0x6c, 0x7c, 0x67, 0xfc, 0x4e, 0x83, 0xad, 0xd8, 0xd8, 0xf1, 0xbc, 0xab, 0xc6, 0xa1, 0xda, 0x8c, + 0x0d, 0x03, 0xa4, 0xbc, 0xf8, 0xbc, 0x4a, 0xfb, 0x61, 0x0e, 0x5e, 0x56, 0x83, 0xb5, 0xd1, 0x98, + 0x03, 0xe9, 0xdc, 0x43, 0x67, 0xf9, 0x5d, 0x54, 0x61, 0xe9, 0x55, 0xeb, 0xab, 0xb0, 0x41, 0x03, + 0x7b, 0x0e, 0x7e, 0x32, 0x6d, 0xd6, 0x69, 0x60, 0xc7, 0xe1, 0x67, 0x41, 0x55, 0x8d, 0x80, 0xd9, + 0x3d, 0x34, 0xe4, 0xf1, 0x1b, 0x7e, 0x19, 0xa0, 0x26, 0x1c, 0xd1, 0xb3, 0xfe, 0x06, 0x14, 0x18, + 0x1a, 0x52, 0x15, 0xb8, 0xed, 0xc5, 0x63, 0x7f, 0xd5, 0x9d, 0xa2, 0x21, 0x35, 0x05, 0xb7, 0xf1, + 0xeb, 0x9c, 0xc2, 0x4b, 0x7c, 0x4c, 0x71, 0x20, 0xef, 0x2b, 0x56, 0xb4, 0xfe, 0xea, 0x83, 0x96, + 0xe7, 0xbf, 0x7f, 0x9a, 0xbf, 0xe7, 0x29, 0xa6, 0xef, 0x79, 0x12, 0xa3, 0xde, 0xd2, 0xfc, 0xdd, + 0x44, 0x13, 0xd6, 0x0e, 0x71, 0x40, 0x5d, 0xe2, 0x8b, 0xc9, 0x65, 0xde, 0x0c, 0x1f, 0x8d, 0x4f, + 0xf2, 0xb0, 0x7d, 0x9c, 0xa5, 0x7a, 0x13, 0xdb, 0xe6, 0x07, 0xe0, 0x17, 0xd2, 0x60, 0x89, 0x1b, + 0xab, 0x62, 0xfa, 0xc6, 0xea, 0x35, 0xd8, 0x18, 0x07, 0xf8, 0xd0, 0x4a, 0x18, 0xb6, 0x24, 0x0c, + 0xdb, 0xe0, 0x3f, 0xdc, 0x8d, 0x19, 0x77, 0x07, 0x2e, 0xfa, 0xf8, 0x28, 0xc9, 0x2a, 0x3f, 0x8e, + 0xa8, 0xfb, 0xf8, 0x28, 0xce, 0xf9, 0x35, 0xa8, 0x8b, 0x5d, 0x67, 0xbe, 0x28, 0x0b, 0x5f, 0xd4, + 0x38, 0xf5, 0x20, 0xf2, 0xc7, 0x57, 0xa1, 0xc6, 0x37, 0x9c, 0x1f, 0xce, 0xaf, 0xfb, 0xf8, 0xe8, + 0x60, 0x91, 0xd3, 0x20, 0xe1, 0x34, 0x5e, 0x86, 0xe5, 0x2c, 0xd1, 0xb1, 0x10, 0x13, 0xd7, 0x71, + 0x79, 0xb3, 0xa2, 0x28, 0x7b, 0x8c, 0x97, 0xac, 0x56, 0x2c, 0xbb, 0x7f, 0x7e, 0x31, 0x70, 0x86, + 0x1d, 0x99, 0xf1, 0x69, 0x0e, 0x2e, 0x87, 0x49, 0x43, 0xa6, 0xd1, 0xb7, 0x3c, 0x72, 0x64, 0x22, + 0x86, 0x6f, 0xbb, 0x23, 0xf7, 0xd4, 0x34, 0x5a, 0xf0, 0xad, 0x4b, 0x3e, 0xe3, 0xb7, 0x2e, 0xdf, + 0x81, 0x75, 0xf5, 0x0e, 0xd9, 0x19, 0x16, 0x96, 0xac, 0x57, 0x12, 0xdd, 0x11, 0xfd, 0xa1, 0x03, + 0x8d, 0x81, 0x47, 0x8e, 0x2c, 0x5e, 0xef, 0x2c, 0x8f, 0x6b, 0xaa, 0x2e, 0xaa, 0xbe, 0xab, 0xcc, + 0x76, 0x75, 0xe8, 0xb2, 0xfb, 0x93, 0x7e, 0xc7, 0x26, 0x23, 0xf5, 0xbd, 0x96, 0xfa, 0x73, 0x8d, + 0x3a, 0x0f, 0xd4, 0x77, 0x52, 0x5d, 0x61, 0x58, 0x50, 0x6f, 0xeb, 0xfa, 0xcc, 0xac, 0x0d, 0xe2, + 0xc6, 0x33, 0x7e, 0xa4, 0x00, 0xb3, 0xc0, 0xb0, 0xbd, 0x85, 0xcd, 0x78, 0x7a, 0x10, 0x7d, 0x05, + 0xc0, 0xa5, 0x52, 0x42, 0x2c, 0xe3, 0xbd, 0x6c, 0x56, 0x5c, 0x7a, 0x5b, 0x12, 0xf6, 0xbb, 0x8f, + 0x9e, 0xb4, 0xb4, 0x8f, 0x9f, 0xb4, 0xb4, 0xbf, 0x3d, 0x69, 0x69, 0x1f, 0x3c, 0x6d, 0x5d, 0xf8, + 0xf8, 0x69, 0xeb, 0xc2, 0x9f, 0x9e, 0xb6, 0x2e, 0xfc, 0x70, 0x37, 0xa6, 0x40, 0xdf, 0xef, 0x5f, + 0x13, 0x4d, 0xe0, 0x6e, 0xec, 0x9b, 0xaf, 0x87, 0xc9, 0xaf, 0xbe, 0xfa, 0x25, 0x71, 0x98, 0x7f, + 0xfd, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x7a, 0x66, 0xb1, 0x47, 0xe1, 0x26, 0x00, 0x00, } func (m *EventCreateBucket) Marshal() (dAtA []byte, err error) { @@ -4935,6 +5073,107 @@ func (m *EventCancelUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } +func (m *EventSetBucketFlowRateLimit) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventSetBucketFlowRateLimit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventSetBucketFlowRateLimit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.FlowRateLimit.Size() + i -= size + if _, err := m.FlowRateLimit.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvents(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if len(m.BucketOwner) > 0 { + i -= len(m.BucketOwner) + copy(dAtA[i:], m.BucketOwner) + i = encodeVarintEvents(dAtA, i, uint64(len(m.BucketOwner))) + i-- + dAtA[i] = 0x22 + } + if len(m.PaymentAddress) > 0 { + i -= len(m.PaymentAddress) + copy(dAtA[i:], m.PaymentAddress) + i = encodeVarintEvents(dAtA, i, uint64(len(m.PaymentAddress))) + i-- + dAtA[i] = 0x1a + } + if len(m.BucketName) > 0 { + i -= len(m.BucketName) + copy(dAtA[i:], m.BucketName) + i = encodeVarintEvents(dAtA, i, uint64(len(m.BucketName))) + i-- + dAtA[i] = 0x12 + } + if len(m.Operator) > 0 { + i -= len(m.Operator) + copy(dAtA[i:], m.Operator) + i = encodeVarintEvents(dAtA, i, uint64(len(m.Operator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EventBucketFlowRateLimitStatus) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EventBucketFlowRateLimitStatus) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EventBucketFlowRateLimitStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IsLimited { + i-- + if m.IsLimited { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(m.BucketName) > 0 { + i -= len(m.BucketName) + copy(dAtA[i:], m.BucketName) + i = encodeVarintEvents(dAtA, i, uint64(len(m.BucketName))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintEvents(dAtA []byte, offset int, v uint64) int { offset -= sovEvents(v) base := offset @@ -5876,6 +6115,49 @@ func (m *EventCancelUpdateObjectContent) Size() (n int) { return n } +func (m *EventSetBucketFlowRateLimit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Operator) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + l = len(m.BucketName) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + l = len(m.PaymentAddress) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + l = len(m.BucketOwner) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + l = m.FlowRateLimit.Size() + n += 1 + l + sovEvents(uint64(l)) + return n +} + +func (m *EventBucketFlowRateLimitStatus) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.BucketName) + if l > 0 { + n += 1 + l + sovEvents(uint64(l)) + } + if m.IsLimited { + n += 2 + } + return n +} + func sovEvents(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -12807,6 +13089,320 @@ func (m *EventCancelUpdateObjectContent) Unmarshal(dAtA []byte) error { } return nil } +func (m *EventSetBucketFlowRateLimit) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventSetBucketFlowRateLimit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventSetBucketFlowRateLimit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Operator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BucketName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PaymentAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PaymentAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BucketOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FlowRateLimit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.FlowRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EventBucketFlowRateLimitStatus) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EventBucketFlowRateLimitStatus: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EventBucketFlowRateLimitStatus: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BucketName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsLimited", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsLimited = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipEvents(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvents + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipEvents(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/storage/types/keys.go b/x/storage/types/keys.go index 49406a8ca..4714353c5 100644 --- a/x/storage/types/keys.go +++ b/x/storage/types/keys.go @@ -63,6 +63,9 @@ var ( DeleteStalePoliciesPrefix = []byte{0x52} MigrateBucketPrefix = []byte{0x61} + + BucketRateLimitPrefix = []byte{0x71} + BucketRateLimitStatusPrefix = []byte{0x72} ) // GetBucketKey return the bucket name store key @@ -172,3 +175,15 @@ func GetLockedObjectCountKey(bucketId math.Uint) []byte { var seq sequence.Sequence[math.Uint] return append(LockedObjectCountPrefix, seq.EncodeSequence(bucketId)...) } + +// GetBucketFlowRateLimitKey return the bucket rate limit store key +func GetBucketFlowRateLimitKey(paymentAccount, bucketOwner sdk.AccAddress, bucketName string) []byte { + bucketNameHash := sdk.Keccak256([]byte(bucketName)) + return append(BucketRateLimitPrefix, append(paymentAccount.Bytes(), append(bucketOwner, bucketNameHash...)...)...) +} + +// GetBucketFlowRateLimitStatusKey return the bucket rate limit store key +func GetBucketFlowRateLimitStatusKey(bucketName string) []byte { + bucketNameHash := sdk.Keccak256([]byte(bucketName)) + return append(BucketRateLimitPrefix, bucketNameHash...) +} diff --git a/x/storage/types/message_set_bucket_rate_limit.go b/x/storage/types/message_set_bucket_rate_limit.go new file mode 100644 index 000000000..48dcad252 --- /dev/null +++ b/x/storage/types/message_set_bucket_rate_limit.go @@ -0,0 +1,72 @@ +package types + +import ( + sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + + "github.com/bnb-chain/greenfield/types/s3util" +) + +const TypeMsgSetBucketFlowRateLimit = "set_bucket_flow_rate_limit" + +var _ sdk.Msg = &MsgSetBucketFlowRateLimit{} + +func NewMsgSetBucketFlowRateLimit(operator, bucketOwner, paymentAccount sdk.AccAddress, bucketName string, rateLimit sdkmath.Int) *MsgSetBucketFlowRateLimit { + return &MsgSetBucketFlowRateLimit{ + Operator: operator.String(), + PaymentAddress: paymentAccount.String(), + BucketName: bucketName, + BucketOwner: bucketOwner.String(), + FlowRateLimit: rateLimit, + } +} + +func (msg *MsgSetBucketFlowRateLimit) Route() string { + return RouterKey +} + +func (msg *MsgSetBucketFlowRateLimit) Type() string { + return TypeMsgSetBucketFlowRateLimit +} + +func (msg *MsgSetBucketFlowRateLimit) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgSetBucketFlowRateLimit) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgSetBucketFlowRateLimit) ValidateBasic() error { + _, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + return sdkerrors.ErrInvalidAddress.Wrapf("invalid operator address (%s)", err) + } + + _, err = sdk.AccAddressFromHexUnsafe(msg.PaymentAddress) + if err != nil { + return sdkerrors.ErrInvalidAddress.Wrapf("invalid payment address (%s)", err) + } + + _, err = sdk.AccAddressFromHexUnsafe(msg.BucketOwner) + if err != nil { + return sdkerrors.ErrInvalidAddress.Wrapf("invalid bucket owner address (%s)", err) + } + + err = s3util.CheckValidBucketName(msg.BucketName) + if err != nil { + return err + } + + if msg.FlowRateLimit.IsNegative() { + return sdkerrors.ErrInvalidRequest.Wrap("flow rate limit cannot be negative") + } + + return nil +} diff --git a/x/storage/types/message_set_bucket_rate_limit_test.go b/x/storage/types/message_set_bucket_rate_limit_test.go new file mode 100644 index 000000000..b8ff866da --- /dev/null +++ b/x/storage/types/message_set_bucket_rate_limit_test.go @@ -0,0 +1,85 @@ +package types + +import ( + "testing" + + sdkmath "cosmossdk.io/math" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/stretchr/testify/require" + + gnfderrors "github.com/bnb-chain/greenfield/types/errors" + + "github.com/bnb-chain/greenfield/testutil/sample" +) + +func TestMsgSetBucketFlowRateLimit_ValidateBasic(t *testing.T) { + tests := []struct { + name string + msg MsgSetBucketFlowRateLimit + err error + }{ + { + name: "invalid address", + msg: MsgSetBucketFlowRateLimit{ + Operator: "invalid_address", + BucketName: testBucketName, + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "invalid address", + msg: MsgSetBucketFlowRateLimit{ + Operator: sample.RandAccAddressHex(), + PaymentAddress: "invalid address", + BucketName: testBucketName, + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "invalid address", + msg: MsgSetBucketFlowRateLimit{ + Operator: sample.RandAccAddressHex(), + PaymentAddress: sample.RandAccAddressHex(), + BucketOwner: "invalid address", + BucketName: testBucketName, + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "invalid bucket name", + msg: MsgSetBucketFlowRateLimit{ + Operator: sample.RandAccAddressHex(), + PaymentAddress: sample.RandAccAddressHex(), + BucketOwner: sample.RandAccAddressHex(), + BucketName: string(testInvalidBucketNameWithLongLength[:]), + }, + err: gnfderrors.ErrInvalidBucketName, + }, { + name: "invalid flow rate limit", + msg: MsgSetBucketFlowRateLimit{ + Operator: sample.RandAccAddressHex(), + PaymentAddress: sample.RandAccAddressHex(), + BucketOwner: sample.RandAccAddressHex(), + BucketName: testBucketName, + FlowRateLimit: sdkmath.NewInt(-1), + }, + err: sdkerrors.ErrInvalidRequest, + }, { + name: "valid case", + msg: MsgSetBucketFlowRateLimit{ + Operator: sample.RandAccAddressHex(), + PaymentAddress: sample.RandAccAddressHex(), + BucketOwner: sample.RandAccAddressHex(), + BucketName: testBucketName, + FlowRateLimit: sdkmath.NewInt(1), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.msg.ValidateBasic() + if tt.err != nil { + require.ErrorIs(t, err, tt.err) + return + } + require.NoError(t, err) + }) + } +} diff --git a/x/storage/types/query.pb.go b/x/storage/types/query.pb.go index 403655a3a..021ab67d7 100644 --- a/x/storage/types/query.pb.go +++ b/x/storage/types/query.pb.go @@ -298,7 +298,8 @@ func (m *QueryHeadBucketByIdRequest) GetBucketId() string { } type QueryHeadBucketResponse struct { - BucketInfo *BucketInfo `protobuf:"bytes,1,opt,name=bucket_info,json=bucketInfo,proto3" json:"bucket_info,omitempty"` + BucketInfo *BucketInfo `protobuf:"bytes,1,opt,name=bucket_info,json=bucketInfo,proto3" json:"bucket_info,omitempty"` + ExtraInfo *BucketExtraInfo `protobuf:"bytes,2,opt,name=extra_info,json=extraInfo,proto3" json:"extra_info,omitempty"` } func (m *QueryHeadBucketResponse) Reset() { *m = QueryHeadBucketResponse{} } @@ -341,6 +342,13 @@ func (m *QueryHeadBucketResponse) GetBucketInfo() *BucketInfo { return nil } +func (m *QueryHeadBucketResponse) GetExtraInfo() *BucketExtraInfo { + if m != nil { + return m.ExtraInfo + } + return nil +} + type QueryHeadObjectRequest struct { BucketName string `protobuf:"bytes,1,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` ObjectName string `protobuf:"bytes,2,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"` @@ -2317,6 +2325,119 @@ func (m *QueryGroupsExistResponse) GetExists() map[string]bool { return nil } +type QueryPaymentAccountBucketFlowRateLimitRequest struct { + PaymentAccount string `protobuf:"bytes,1,opt,name=payment_account,json=paymentAccount,proto3" json:"payment_account,omitempty"` + BucketOwner string `protobuf:"bytes,2,opt,name=bucket_owner,json=bucketOwner,proto3" json:"bucket_owner,omitempty"` + BucketName string `protobuf:"bytes,3,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` +} + +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) Reset() { + *m = QueryPaymentAccountBucketFlowRateLimitRequest{} +} +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) String() string { + return proto.CompactTextString(m) +} +func (*QueryPaymentAccountBucketFlowRateLimitRequest) ProtoMessage() {} +func (*QueryPaymentAccountBucketFlowRateLimitRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_b1b80b580af04cb0, []int{48} +} +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryPaymentAccountBucketFlowRateLimitRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryPaymentAccountBucketFlowRateLimitRequest.Merge(m, src) +} +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryPaymentAccountBucketFlowRateLimitRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryPaymentAccountBucketFlowRateLimitRequest proto.InternalMessageInfo + +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) GetPaymentAccount() string { + if m != nil { + return m.PaymentAccount + } + return "" +} + +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) GetBucketOwner() string { + if m != nil { + return m.BucketOwner + } + return "" +} + +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) GetBucketName() string { + if m != nil { + return m.BucketName + } + return "" +} + +type QueryPaymentAccountBucketFlowRateLimitResponse struct { + IsSet bool `protobuf:"varint,1,opt,name=is_set,json=isSet,proto3" json:"is_set,omitempty"` + FlowRateLimit github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=flow_rate_limit,json=flowRateLimit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"flow_rate_limit"` +} + +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) Reset() { + *m = QueryPaymentAccountBucketFlowRateLimitResponse{} +} +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) String() string { + return proto.CompactTextString(m) +} +func (*QueryPaymentAccountBucketFlowRateLimitResponse) ProtoMessage() {} +func (*QueryPaymentAccountBucketFlowRateLimitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_b1b80b580af04cb0, []int{49} +} +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryPaymentAccountBucketFlowRateLimitResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryPaymentAccountBucketFlowRateLimitResponse.Merge(m, src) +} +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryPaymentAccountBucketFlowRateLimitResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryPaymentAccountBucketFlowRateLimitResponse proto.InternalMessageInfo + +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) GetIsSet() bool { + if m != nil { + return m.IsSet + } + return false +} + func init() { proto.RegisterType((*QueryParamsRequest)(nil), "greenfield.storage.QueryParamsRequest") proto.RegisterType((*QueryParamsResponse)(nil), "greenfield.storage.QueryParamsResponse") @@ -2368,180 +2489,193 @@ func init() { proto.RegisterType((*QueryGroupsExistByIdRequest)(nil), "greenfield.storage.QueryGroupsExistByIdRequest") proto.RegisterType((*QueryGroupsExistResponse)(nil), "greenfield.storage.QueryGroupsExistResponse") proto.RegisterMapType((map[string]bool)(nil), "greenfield.storage.QueryGroupsExistResponse.ExistsEntry") + proto.RegisterType((*QueryPaymentAccountBucketFlowRateLimitRequest)(nil), "greenfield.storage.QueryPaymentAccountBucketFlowRateLimitRequest") + proto.RegisterType((*QueryPaymentAccountBucketFlowRateLimitResponse)(nil), "greenfield.storage.QueryPaymentAccountBucketFlowRateLimitResponse") } func init() { proto.RegisterFile("greenfield/storage/query.proto", fileDescriptor_b1b80b580af04cb0) } var fileDescriptor_b1b80b580af04cb0 = []byte{ - // 2688 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0xcd, 0x6f, 0x1c, 0x49, - 0x15, 0x4f, 0xdb, 0x59, 0xc7, 0x2e, 0x9b, 0xac, 0xa9, 0xf5, 0xee, 0x3a, 0x93, 0xc4, 0x49, 0x7a, - 0x43, 0x92, 0x4d, 0xe2, 0xe9, 0xc4, 0x49, 0x50, 0x9c, 0x2f, 0x64, 0xaf, 0xed, 0x30, 0x28, 0x1f, - 0xce, 0xc4, 0x18, 0x11, 0x09, 0x35, 0x35, 0xdd, 0x35, 0x93, 0x5e, 0xcf, 0x74, 0x4f, 0xba, 0x7b, - 0xe2, 0xcc, 0x5a, 0x23, 0xc4, 0x5e, 0xe0, 0x88, 0x40, 0x48, 0x48, 0x80, 0x84, 0x40, 0x7c, 0x5e, - 0x10, 0xec, 0x0a, 0x09, 0x71, 0xe0, 0x00, 0x48, 0x2b, 0x21, 0xa4, 0xd5, 0x72, 0x41, 0x7b, 0x58, - 0x41, 0xc2, 0x1f, 0x82, 0xba, 0xea, 0x55, 0x77, 0xf5, 0xc7, 0x74, 0x8f, 0xd7, 0xc3, 0xc9, 0xd3, - 0xd5, 0xf5, 0xde, 0xfb, 0xbd, 0x8f, 0x7a, 0x55, 0xfd, 0x2b, 0xa3, 0xb9, 0x86, 0x4b, 0xa9, 0x5d, - 0xb7, 0x68, 0xd3, 0xd4, 0x3c, 0xdf, 0x71, 0x49, 0x83, 0x6a, 0x4f, 0x3a, 0xd4, 0xed, 0x96, 0xdb, - 0xae, 0xe3, 0x3b, 0x18, 0x47, 0xef, 0xcb, 0xf0, 0xbe, 0x74, 0xd6, 0x70, 0xbc, 0x96, 0xe3, 0x69, - 0x35, 0xe2, 0xc1, 0x64, 0xed, 0xe9, 0xc5, 0x1a, 0xf5, 0xc9, 0x45, 0xad, 0x4d, 0x1a, 0x96, 0x4d, - 0x7c, 0xcb, 0xb1, 0xb9, 0x7c, 0xe9, 0x10, 0x9f, 0xab, 0xb3, 0x27, 0x8d, 0x3f, 0xc0, 0xab, 0x99, - 0x86, 0xd3, 0x70, 0xf8, 0x78, 0xf0, 0x0b, 0x46, 0x8f, 0x34, 0x1c, 0xa7, 0xd1, 0xa4, 0x1a, 0x69, - 0x5b, 0x1a, 0xb1, 0x6d, 0xc7, 0x67, 0xda, 0x84, 0x8c, 0x2a, 0xc1, 0x6d, 0x53, 0xb7, 0x65, 0x79, - 0x9e, 0xe5, 0xd8, 0x9a, 0xe1, 0xb4, 0x5a, 0xa1, 0xc9, 0x13, 0xd9, 0x73, 0xfc, 0x6e, 0x9b, 0x0a, - 0x35, 0xc7, 0x32, 0xbc, 0x6e, 0x13, 0x97, 0xb4, 0xc4, 0x84, 0xac, 0xb0, 0xc8, 0x0a, 0xde, 0x90, - 0xde, 0x3f, 0xb5, 0x5c, 0xbf, 0x43, 0x9a, 0x0d, 0xd7, 0xe9, 0xb4, 0xe5, 0x49, 0xea, 0x0c, 0xc2, - 0x0f, 0x82, 0xe8, 0xac, 0x33, 0xcd, 0x55, 0xfa, 0xa4, 0x43, 0x3d, 0x5f, 0xbd, 0x8f, 0x5e, 0x89, - 0x8d, 0x7a, 0x6d, 0xc7, 0xf6, 0x28, 0xbe, 0x8a, 0xc6, 0x38, 0x82, 0x59, 0xe5, 0xb8, 0x72, 0x66, - 0x72, 0xa1, 0x54, 0x4e, 0x47, 0xbe, 0xcc, 0x65, 0x96, 0xf7, 0x7f, 0xf0, 0xc9, 0xb1, 0x7d, 0x55, - 0x98, 0xaf, 0xde, 0x44, 0x47, 0x25, 0x85, 0xcb, 0xdd, 0x0d, 0xab, 0x45, 0x3d, 0x9f, 0xb4, 0xda, - 0x60, 0x11, 0x1f, 0x41, 0x13, 0xbe, 0x18, 0x63, 0xda, 0x47, 0xab, 0xd1, 0x80, 0xfa, 0x08, 0xcd, - 0xf5, 0x13, 0xdf, 0x33, 0xb4, 0x45, 0xf4, 0x1a, 0xd3, 0xfd, 0x45, 0x4a, 0xcc, 0xe5, 0x8e, 0xb1, - 0x45, 0x7d, 0x81, 0xe9, 0x18, 0x9a, 0xac, 0xb1, 0x01, 0xdd, 0x26, 0x2d, 0xca, 0x14, 0x4f, 0x54, - 0x11, 0x1f, 0xba, 0x47, 0x5a, 0x54, 0x5d, 0x44, 0xa5, 0x84, 0xe8, 0x72, 0xb7, 0x62, 0x0a, 0xf1, - 0xc3, 0x68, 0x02, 0xc4, 0x2d, 0x13, 0x84, 0xc7, 0xf9, 0x40, 0xc5, 0x54, 0x1f, 0xa1, 0xd7, 0x53, - 0x56, 0xc1, 0x95, 0x2f, 0x84, 0x66, 0x2d, 0xbb, 0xee, 0x80, 0x3f, 0x73, 0x59, 0xfe, 0x70, 0xc1, - 0x8a, 0x5d, 0x77, 0x04, 0xac, 0xe0, 0xb7, 0xfa, 0x48, 0xf2, 0xe8, 0x7e, 0xed, 0x6d, 0x6a, 0x0c, - 0xec, 0x51, 0x30, 0xc1, 0x61, 0x12, 0x7c, 0xc2, 0x08, 0x9f, 0xc0, 0x87, 0x52, 0x2e, 0x73, 0xdd, - 0x09, 0x97, 0x41, 0x3c, 0x72, 0x99, 0x0f, 0x54, 0x4c, 0xf5, 0xeb, 0xe8, 0x48, 0x28, 0xfa, 0xf0, - 0x31, 0x31, 0x9d, 0xed, 0x61, 0x83, 0xfb, 0xa3, 0x22, 0x45, 0x55, 0x28, 0x8f, 0xa2, 0x2a, 0xa0, - 0x15, 0x44, 0x95, 0x0b, 0xf2, 0xa8, 0x3a, 0xe1, 0x6f, 0xfc, 0x35, 0x34, 0xd3, 0x68, 0x3a, 0x35, - 0xd2, 0xd4, 0x61, 0x31, 0xe9, 0x6c, 0x35, 0x31, 0x18, 0x93, 0x0b, 0xe7, 0x64, 0x4d, 0xf2, 0x6a, - 0x2b, 0xdf, 0x66, 0x42, 0x9b, 0x7c, 0xe8, 0x76, 0x30, 0x54, 0xc5, 0x8d, 0xd4, 0x98, 0x5a, 0x87, - 0x15, 0x92, 0x8e, 0x0e, 0x38, 0xb0, 0x9a, 0xe5, 0xc0, 0xc9, 0x2c, 0x07, 0x64, 0xf1, 0xa4, 0x1b, - 0x2a, 0x81, 0x10, 0xdd, 0xb1, 0x3c, 0x9f, 0xd7, 0x8f, 0x58, 0xf5, 0x78, 0x0d, 0xa1, 0xa8, 0x37, - 0x82, 0x81, 0x53, 0x65, 0xe8, 0x87, 0x41, 0x23, 0x2d, 0xf3, 0xae, 0x0b, 0x8d, 0xb4, 0xbc, 0x4e, - 0x1a, 0x14, 0x64, 0xab, 0x92, 0xa4, 0xfa, 0x0b, 0x05, 0xcd, 0xa6, 0x6d, 0x80, 0x1b, 0x4b, 0x68, - 0x4a, 0xaa, 0xee, 0x60, 0xb9, 0x8e, 0x0e, 0x50, 0xde, 0x93, 0x51, 0x79, 0x7b, 0xf8, 0x76, 0x0c, - 0x27, 0x8f, 0xff, 0xe9, 0x42, 0x9c, 0xdc, 0x7e, 0x0c, 0xe8, 0xbb, 0x8a, 0x14, 0x0c, 0x1e, 0xaf, - 0x61, 0x07, 0x23, 0x59, 0xd5, 0x23, 0xa9, 0x26, 0xf2, 0x6d, 0x05, 0x9d, 0x48, 0x82, 0x58, 0xee, - 0x82, 0xef, 0xe6, 0xb0, 0xe1, 0xc4, 0x9a, 0xd2, 0x48, 0xa2, 0x29, 0xc5, 0x12, 0x17, 0xc6, 0x23, - 0x4a, 0x9c, 0x54, 0x7f, 0xb9, 0x89, 0x93, 0x4a, 0x6f, 0x32, 0x2a, 0xbd, 0x21, 0x26, 0xee, 0x3c, - 0x7a, 0x99, 0xe1, 0xbc, 0xb7, 0xb6, 0x21, 0x02, 0x74, 0x08, 0x8d, 0xfb, 0xce, 0x16, 0xb5, 0xa3, - 0xce, 0x73, 0x80, 0x3d, 0x57, 0x4c, 0xf5, 0xab, 0xd0, 0x0f, 0x79, 0x4c, 0x99, 0x4c, 0xd8, 0x14, - 0x26, 0x5a, 0xd4, 0x27, 0xba, 0x49, 0x7c, 0x02, 0x41, 0x55, 0xfb, 0x57, 0xe2, 0x5d, 0xea, 0x93, - 0x15, 0xe2, 0x93, 0xea, 0x78, 0x0b, 0x7e, 0x85, 0xaa, 0xb9, 0xc7, 0x9f, 0x46, 0x35, 0x97, 0xcc, - 0x50, 0xfd, 0x15, 0xf4, 0x2a, 0x53, 0xcd, 0xda, 0x83, 0xac, 0xf9, 0x56, 0x5a, 0xf3, 0x89, 0x2c, - 0xcd, 0x4c, 0x30, 0x43, 0xf1, 0x37, 0x15, 0x68, 0xc4, 0xeb, 0x4e, 0xd3, 0x32, 0xba, 0x6b, 0x8e, - 0xbb, 0x64, 0x18, 0x4e, 0xc7, 0x0e, 0x1b, 0x71, 0x09, 0x8d, 0xbb, 0xd4, 0x73, 0x3a, 0xae, 0x21, - 0xba, 0x70, 0xf8, 0x8c, 0x57, 0xd1, 0x67, 0xdb, 0xae, 0x65, 0x1b, 0x56, 0x9b, 0x34, 0x75, 0x62, - 0x9a, 0x2e, 0xf5, 0x3c, 0x5e, 0x47, 0xcb, 0xb3, 0x1f, 0xbd, 0x3f, 0x3f, 0x03, 0xc9, 0x5c, 0xe2, - 0x6f, 0x1e, 0xfa, 0xae, 0x65, 0x37, 0xaa, 0xd3, 0xa1, 0x08, 0x8c, 0xab, 0x9b, 0xe2, 0x3c, 0x90, - 0x82, 0x00, 0x4e, 0x5e, 0x41, 0x63, 0x6d, 0xf6, 0x0e, 0x3c, 0x3c, 0x2a, 0x7b, 0x18, 0x9d, 0x98, - 0xca, 0x5c, 0x41, 0x15, 0x26, 0xab, 0x1f, 0x0b, 0xdf, 0x36, 0xa9, 0x6b, 0xd5, 0xbb, 0xeb, 0xe1, - 0x44, 0xe1, 0xdb, 0x65, 0x34, 0xee, 0xb4, 0xa9, 0x4b, 0x7c, 0xc7, 0xe5, 0xbe, 0xe5, 0xc0, 0x0e, - 0x67, 0x16, 0x2e, 0xe2, 0xe4, 0xd6, 0x34, 0x9a, 0xdc, 0x9a, 0xf0, 0x32, 0x9a, 0x24, 0x46, 0x50, - 0xbb, 0x7a, 0x70, 0xfa, 0x9a, 0xdd, 0x7f, 0x5c, 0x39, 0x73, 0x30, 0x9e, 0x36, 0xc9, 0xa9, 0x25, - 0x36, 0x73, 0xa3, 0xdb, 0xa6, 0x55, 0x44, 0xc2, 0xdf, 0x61, 0xd0, 0xd2, 0xbe, 0x45, 0x41, 0xa3, - 0xf5, 0x3a, 0x35, 0x7c, 0xe6, 0xda, 0xc1, 0xbe, 0x41, 0x5b, 0x65, 0x93, 0xaa, 0x30, 0x59, 0x7d, - 0x02, 0x95, 0x16, 0x6c, 0x3d, 0x7c, 0x83, 0x82, 0x60, 0x2d, 0xa2, 0x49, 0xb6, 0x87, 0xe9, 0xce, - 0xb6, 0x4d, 0x8b, 0xe3, 0x85, 0xd8, 0xe4, 0xfb, 0xc1, 0x5c, 0x7c, 0x14, 0xf1, 0x27, 0x39, 0x60, - 0x13, 0x6c, 0x84, 0x35, 0xbd, 0x4d, 0xe9, 0x88, 0x02, 0x26, 0xc1, 0x87, 0x1b, 0x42, 0x50, 0xda, - 0xe5, 0x8e, 0xf6, 0x2d, 0x6f, 0xd6, 0x63, 0xb8, 0x5e, 0xb6, 0xbb, 0xfd, 0x50, 0x01, 0xc5, 0x41, - 0x07, 0x63, 0x33, 0x86, 0xde, 0xd0, 0x13, 0x41, 0x19, 0x19, 0x3c, 0x28, 0xea, 0x4f, 0xe5, 0xfd, - 0x46, 0xa0, 0x03, 0xbf, 0x6f, 0x67, 0xc0, 0xfb, 0x34, 0xbd, 0x11, 0xdf, 0x12, 0xf8, 0x78, 0x9b, - 0x1e, 0x61, 0x6d, 0xba, 0x20, 0x82, 0x28, 0x8c, 0xa0, 0xa7, 0xfe, 0x5a, 0x41, 0x87, 0xe3, 0xb9, - 0xb9, 0x4b, 0x5b, 0x35, 0xea, 0x8a, 0x38, 0x5e, 0x40, 0x63, 0x2d, 0x36, 0x50, 0x58, 0x0f, 0x30, - 0x6f, 0x0f, 0x11, 0x4b, 0x94, 0xd1, 0x68, 0xb2, 0x8c, 0xa8, 0x74, 0xa4, 0x8c, 0x41, 0x0d, 0xcf, - 0x4c, 0x53, 0x5c, 0x5c, 0x42, 0x9c, 0xe8, 0xc3, 0xd2, 0xb2, 0x90, 0x35, 0x70, 0xc4, 0xfc, 0x41, - 0xad, 0xc3, 0xa1, 0x37, 0xec, 0x56, 0xb1, 0x55, 0x92, 0xd7, 0x2e, 0xcf, 0x23, 0x1c, 0xb5, 0x4b, - 0x48, 0x8b, 0xd8, 0x77, 0xa3, 0xae, 0xc8, 0x13, 0x61, 0xaa, 0x1b, 0x10, 0xf9, 0xa4, 0x9d, 0xbd, - 0xf5, 0xc4, 0x2b, 0xb0, 0x24, 0xf8, 0x70, 0xe2, 0xb8, 0xce, 0xe7, 0x48, 0xc7, 0x75, 0x3e, 0x50, - 0x31, 0xd5, 0x75, 0xa8, 0x55, 0x59, 0x6c, 0x6f, 0x40, 0x7e, 0xac, 0xc0, 0x67, 0xe5, 0x1d, 0xc7, - 0xd8, 0x5a, 0xa3, 0x34, 0x5a, 0x99, 0x41, 0x90, 0x5a, 0xc4, 0xed, 0xea, 0x5e, 0x3b, 0xdc, 0x54, - 0x94, 0x01, 0x36, 0x95, 0x40, 0xe6, 0x61, 0x1b, 0xc6, 0x03, 0x77, 0x0c, 0x97, 0x12, 0x9f, 0xea, - 0xc4, 0x67, 0x31, 0x1e, 0xad, 0x8e, 0xf3, 0x81, 0x25, 0x1f, 0x9f, 0x40, 0x53, 0x6d, 0xd2, 0x6d, - 0x3a, 0xc4, 0xd4, 0x3d, 0xeb, 0x1d, 0x5e, 0x4b, 0xfb, 0xab, 0x93, 0x30, 0xf6, 0xd0, 0x7a, 0x87, - 0xaa, 0x4d, 0x34, 0x13, 0x87, 0x07, 0xee, 0x6e, 0xa0, 0x31, 0xd2, 0x0a, 0x76, 0x27, 0xc0, 0x74, - 0x23, 0xf8, 0x7e, 0xfc, 0xf8, 0x93, 0x63, 0xa7, 0x1a, 0x96, 0xff, 0xb8, 0x53, 0x2b, 0x1b, 0x4e, - 0x0b, 0x58, 0x03, 0xf8, 0x33, 0xef, 0x99, 0x5b, 0xf0, 0x95, 0x5d, 0xb1, 0xfd, 0x8f, 0xde, 0x9f, - 0x47, 0xe0, 0x41, 0xc5, 0xf6, 0xab, 0xa0, 0x4b, 0xbd, 0x25, 0x2d, 0x33, 0x7e, 0xbe, 0x58, 0x7d, - 0xe6, 0xbb, 0x64, 0xe0, 0x8f, 0x4f, 0xb9, 0xf6, 0x63, 0xf2, 0x61, 0xed, 0x23, 0x1a, 0x0c, 0xc8, - 0x8d, 0xf4, 0x54, 0x56, 0x1b, 0xa8, 0xd8, 0x3e, 0x75, 0x6d, 0xd2, 0x94, 0x8e, 0xdb, 0x13, 0x4c, - 0x92, 0x75, 0xd4, 0x9b, 0x50, 0xfb, 0x15, 0x6f, 0xdd, 0xb5, 0x0c, 0xfa, 0xd6, 0x63, 0x62, 0x37, - 0xa8, 0x39, 0x30, 0xca, 0xff, 0x1c, 0x00, 0x37, 0x93, 0xf2, 0x80, 0x72, 0x16, 0x1d, 0x30, 0xf8, - 0x10, 0x13, 0x1e, 0xaf, 0x8a, 0x47, 0xfc, 0x36, 0xc2, 0x46, 0xc7, 0x75, 0xa9, 0xed, 0xeb, 0x2e, - 0x25, 0xa6, 0xde, 0x0e, 0xc4, 0xa1, 0x79, 0xec, 0x26, 0x03, 0x2b, 0xd4, 0x90, 0x32, 0xb0, 0x42, - 0x8d, 0xea, 0x34, 0xe8, 0xad, 0x52, 0x62, 0x32, 0x50, 0x78, 0x07, 0x1d, 0x16, 0xb6, 0xc2, 0x4a, - 0xf4, 0x1d, 0x97, 0x82, 0xd1, 0xd1, 0x21, 0x18, 0x9d, 0x05, 0x03, 0xeb, 0x50, 0xb5, 0x81, 0x7a, - 0x6e, 0xfc, 0x1b, 0xe8, 0xa8, 0x30, 0xee, 0x51, 0xc3, 0xb1, 0xcd, 0xa4, 0xf9, 0xfd, 0x43, 0x30, - 0x5f, 0x02, 0x13, 0x0f, 0x85, 0x05, 0x09, 0x40, 0x17, 0x89, 0xb7, 0xfa, 0x53, 0xd2, 0xb4, 0xcc, - 0xe0, 0xc8, 0xa3, 0xfb, 0xe4, 0x99, 0xee, 0x12, 0x9f, 0xce, 0xbe, 0x34, 0x04, 0xeb, 0xaf, 0x83, - 0xfe, 0x4d, 0xa1, 0x7e, 0x83, 0x3c, 0xab, 0x12, 0x9f, 0xe2, 0x1a, 0x3a, 0x68, 0xd3, 0x6d, 0x39, - 0xc1, 0x63, 0x43, 0x30, 0x37, 0x65, 0xd3, 0xed, 0x28, 0xb9, 0x1e, 0x7a, 0x3d, 0xb0, 0x91, 0x95, - 0xd8, 0x03, 0x43, 0x30, 0x36, 0x63, 0xd3, 0xed, 0x74, 0x52, 0xb7, 0xd1, 0xa1, 0xc0, 0x68, 0x76, - 0x42, 0xc7, 0x87, 0x60, 0xf6, 0x35, 0x9b, 0x6e, 0x67, 0x25, 0xf3, 0x09, 0x0a, 0xde, 0x64, 0x25, - 0x72, 0x62, 0x08, 0x56, 0x5f, 0xb1, 0xe9, 0x76, 0x32, 0x89, 0x61, 0x27, 0x7b, 0xd0, 0x71, 0x7c, - 0xfa, 0xe5, 0xb6, 0x49, 0x7c, 0xba, 0x61, 0xb5, 0xe8, 0xc0, 0x3d, 0xe2, 0x3a, 0x74, 0xb2, 0x94, - 0x3c, 0xf4, 0x88, 0xc3, 0x68, 0xa2, 0xc3, 0x46, 0x83, 0xbe, 0x3e, 0xc6, 0xfb, 0x3a, 0x1f, 0x58, - 0xf2, 0x55, 0x1b, 0x0e, 0xc5, 0xd2, 0xe6, 0xed, 0xad, 0x3e, 0xb3, 0x3c, 0x5f, 0xfa, 0x30, 0x0c, - 0x37, 0x5e, 0xf8, 0x30, 0xe4, 0xa7, 0x1d, 0x13, 0x2f, 0xa0, 0x03, 0xfc, 0x60, 0xc0, 0x8f, 0x49, - 0x79, 0xbb, 0x8d, 0x98, 0xa8, 0xbe, 0xa7, 0x00, 0x17, 0x99, 0x61, 0x10, 0xf0, 0x6e, 0xa2, 0x31, - 0x1a, 0x0c, 0x88, 0x6f, 0xe4, 0x5b, 0x59, 0x5d, 0x37, 0x5f, 0x47, 0x99, 0x3d, 0x79, 0xab, 0xb6, - 0xef, 0x76, 0xab, 0xa0, 0xad, 0xb4, 0x88, 0x26, 0xa5, 0x61, 0x3c, 0x8d, 0x46, 0xb7, 0x68, 0x17, - 0x7c, 0x0a, 0x7e, 0xe2, 0x19, 0xf4, 0xd2, 0x53, 0xd2, 0xec, 0xf0, 0x2e, 0x39, 0x5e, 0xe5, 0x0f, - 0xd7, 0x46, 0xae, 0x2a, 0x6a, 0x07, 0x36, 0x73, 0x7e, 0xe8, 0x8c, 0xc5, 0x67, 0x0f, 0x87, 0xfc, - 0x63, 0x42, 0x34, 0x48, 0x2c, 0xc4, 0x10, 0x26, 0x04, 0x89, 0xf5, 0xd4, 0x6b, 0x50, 0x19, 0x92, - 0xd9, 0xc4, 0xf9, 0x43, 0xa4, 0x86, 0xc7, 0x6a, 0xa2, 0x3a, 0x0e, 0xb9, 0xf1, 0xd4, 0x5f, 0x0a, - 0x32, 0x22, 0x86, 0x19, 0x42, 0xbc, 0x9e, 0x08, 0xf1, 0xd5, 0xfc, 0x10, 0xff, 0x5f, 0x83, 0xbb, - 0xf0, 0xa7, 0x93, 0xe8, 0x25, 0x66, 0x0b, 0xf7, 0xd0, 0x18, 0xe7, 0x98, 0xf1, 0xa9, 0xbe, 0x80, - 0x62, 0x4c, 0x7b, 0xe9, 0x74, 0xe1, 0x3c, 0x8e, 0x59, 0x55, 0xdf, 0xfd, 0xe7, 0x7f, 0xbf, 0x37, - 0x72, 0x04, 0x97, 0xb4, 0xbe, 0xf7, 0x02, 0xf8, 0xb7, 0xe2, 0xeb, 0x27, 0xc5, 0x93, 0xe3, 0x8b, - 0x05, 0x76, 0xd2, 0x94, 0x7c, 0x69, 0x61, 0x37, 0x22, 0x80, 0xb2, 0xcc, 0x50, 0x9e, 0xc1, 0xa7, - 0xfa, 0xa3, 0xd4, 0x76, 0x42, 0x5e, 0xbf, 0x87, 0x7f, 0xa4, 0x20, 0x14, 0x1d, 0x60, 0xf0, 0xd9, - 0xbe, 0x26, 0x53, 0xec, 0x7c, 0xe9, 0xdc, 0x40, 0x73, 0x01, 0xd7, 0x15, 0x86, 0x4b, 0xc3, 0xf3, - 0x59, 0xb8, 0x1e, 0x07, 0xbb, 0x0f, 0xef, 0x47, 0xda, 0x8e, 0xd4, 0xaa, 0x7a, 0xf8, 0x57, 0x0a, - 0x3a, 0x18, 0x27, 0xf7, 0x71, 0x79, 0x00, 0xb3, 0x52, 0x8d, 0xef, 0x0e, 0xe6, 0x22, 0x83, 0x79, - 0x09, 0x5f, 0x2c, 0x80, 0xa9, 0xd7, 0x82, 0x23, 0x7b, 0x08, 0xd6, 0x32, 0x7b, 0xf8, 0x07, 0x0a, - 0xfa, 0x4c, 0xa4, 0xf1, 0xde, 0xda, 0x06, 0x7e, 0xa3, 0xaf, 0xe5, 0x88, 0x36, 0x2b, 0xf5, 0x8f, - 0x78, 0x8a, 0x2d, 0x53, 0x3f, 0xcf, 0xd0, 0x5d, 0xc0, 0xe5, 0x22, 0x74, 0x76, 0xdd, 0xd7, 0x76, - 0x04, 0x1b, 0xd7, 0xc3, 0xbf, 0x81, 0x24, 0x73, 0xaa, 0xab, 0x20, 0xc9, 0xb1, 0x3b, 0x81, 0x82, - 0xe8, 0xc5, 0x19, 0x72, 0xf5, 0x2d, 0x86, 0xef, 0x26, 0xbe, 0xde, 0x17, 0x1f, 0x27, 0x64, 0xe2, - 0x49, 0xd6, 0x76, 0x24, 0xe6, 0x26, 0x4a, 0x79, 0x74, 0xb9, 0x51, 0x90, 0xf2, 0xd4, 0x2d, 0xc8, - 0xee, 0x40, 0x17, 0xa7, 0x1c, 0xe0, 0x41, 0xca, 0xc3, 0xfb, 0x95, 0x1e, 0xfe, 0x8b, 0x82, 0xa6, - 0x93, 0xd7, 0x05, 0xf8, 0x42, 0xae, 0xf1, 0x8c, 0x7b, 0x97, 0xd2, 0xc5, 0x5d, 0x48, 0x00, 0xe8, - 0x2f, 0x31, 0xd0, 0x2b, 0x78, 0xb9, 0x2f, 0x68, 0x8f, 0x89, 0x0d, 0x12, 0x70, 0x51, 0xb8, 0x21, - 0x85, 0xba, 0xd7, 0xc2, 0x4d, 0x71, 0xb1, 0x03, 0x14, 0xae, 0x40, 0x14, 0x2f, 0xdc, 0xef, 0x2a, - 0x68, 0x52, 0xba, 0xc3, 0xc0, 0xfd, 0x13, 0x9b, 0xbe, 0x4d, 0x29, 0x9d, 0x1f, 0x6c, 0x32, 0x40, - 0x3c, 0xc3, 0x20, 0xaa, 0xf8, 0x78, 0x16, 0xc4, 0xa6, 0xe5, 0xf9, 0xb0, 0xb6, 0x3c, 0xfc, 0x13, - 0x00, 0x05, 0xfc, 0x7c, 0x01, 0xa8, 0xf8, 0xad, 0x46, 0x01, 0xa8, 0x04, 0xe5, 0x9f, 0x1f, 0x37, - 0x06, 0x8a, 0xc7, 0xcd, 0x4b, 0xb4, 0xcd, 0x3f, 0x2b, 0xe8, 0xd5, 0xcc, 0xdb, 0x0c, 0x7c, 0x65, - 0x10, 0xfb, 0xa9, 0xdb, 0x8f, 0x5d, 0xc2, 0x5e, 0x62, 0xb0, 0xaf, 0xe3, 0xc5, 0x22, 0xd8, 0xc1, - 0x9a, 0x0a, 0x5b, 0x68, 0xac, 0x9b, 0x7e, 0x5f, 0x41, 0x53, 0x21, 0xa9, 0x34, 0x70, 0x4d, 0xbe, - 0x99, 0x7f, 0x0a, 0x91, 0x4b, 0xb2, 0x78, 0x43, 0x82, 0x93, 0x55, 0xbc, 0x22, 0xff, 0xae, 0x00, - 0x57, 0x9b, 0x24, 0xce, 0x73, 0xd6, 0x7d, 0x1f, 0x9a, 0x3f, 0x67, 0xdd, 0xf7, 0x63, 0xe5, 0xd5, - 0xbb, 0x0c, 0xf5, 0x6d, 0xbc, 0x9a, 0xb9, 0xbd, 0x73, 0x2a, 0xa9, 0xee, 0xb8, 0x3a, 0xe1, 0x72, - 0xda, 0x8e, 0x20, 0xc2, 0x7a, 0xda, 0x4e, 0xea, 0xda, 0xa0, 0x87, 0xff, 0xa1, 0xa0, 0xe9, 0x24, - 0x99, 0x9d, 0xe3, 0x48, 0x1f, 0x4e, 0x3f, 0xc7, 0x91, 0x7e, 0x4c, 0xb9, 0xba, 0xc1, 0x1c, 0xb9, - 0x87, 0xef, 0x64, 0x39, 0xf2, 0x94, 0x49, 0xe9, 0xd2, 0xff, 0x65, 0xec, 0x88, 0x9b, 0x80, 0x5e, - 0xb2, 0x95, 0x49, 0xa4, 0x7e, 0x0f, 0xff, 0x5c, 0x41, 0x13, 0x61, 0xd5, 0xe0, 0x37, 0x73, 0xfb, - 0xaa, 0x4c, 0x21, 0x96, 0xce, 0x0e, 0x32, 0x75, 0x90, 0xea, 0x8e, 0x2a, 0x47, 0xdb, 0x91, 0x4e, - 0xf5, 0x3d, 0xf1, 0xc4, 0xd7, 0x67, 0x70, 0xea, 0x8a, 0x28, 0xe8, 0x9c, 0x0d, 0x39, 0xc5, 0xa2, - 0x97, 0xce, 0x0d, 0x34, 0x77, 0x90, 0x22, 0x67, 0x0b, 0x91, 0xa1, 0xf2, 0xe2, 0x58, 0xf1, 0xcf, - 0x14, 0xf4, 0x72, 0x82, 0xd1, 0xc5, 0x5a, 0x71, 0x84, 0x62, 0x34, 0x75, 0xe9, 0xc2, 0xe0, 0x02, - 0x80, 0x76, 0x9e, 0xa1, 0x3d, 0x8d, 0x3f, 0x57, 0xb0, 0x24, 0x81, 0xd5, 0xfe, 0xab, 0x60, 0x33, - 0xe3, 0x6c, 0x6d, 0xce, 0x69, 0x21, 0x93, 0x3e, 0x2e, 0x69, 0x03, 0xcf, 0x07, 0x9c, 0x77, 0x18, - 0xce, 0x35, 0xbc, 0x52, 0xb0, 0x08, 0xa1, 0x0c, 0x32, 0x97, 0xa0, 0xf8, 0xec, 0xea, 0x05, 0xdb, - 0xc9, 0xcb, 0x09, 0x9e, 0x37, 0xa7, 0x20, 0x52, 0x1c, 0x72, 0x4e, 0x41, 0xa4, 0x89, 0x63, 0xf5, - 0x32, 0x83, 0x5e, 0xc6, 0xe7, 0x73, 0xa0, 0xc3, 0x39, 0x27, 0x24, 0xa6, 0x7b, 0xf8, 0x5b, 0x0a, - 0x9a, 0x92, 0x89, 0x59, 0xdc, 0xff, 0xa3, 0x29, 0xce, 0x2c, 0x97, 0xce, 0x14, 0x4f, 0x04, 0x64, - 0x27, 0x19, 0xb2, 0x39, 0x7c, 0x24, 0xb3, 0x54, 0x1d, 0x63, 0x4b, 0xaf, 0x53, 0x8a, 0x7f, 0x07, - 0x95, 0x29, 0xf1, 0xad, 0x05, 0x95, 0x99, 0x66, 0x76, 0x0b, 0x2a, 0x33, 0x83, 0xca, 0x55, 0xaf, - 0x33, 0x70, 0x57, 0xf0, 0xa5, 0xa2, 0x83, 0x37, 0xa3, 0x6d, 0x13, 0x9b, 0xf1, 0xef, 0x45, 0x9d, - 0xc6, 0x19, 0xd8, 0x9c, 0x3a, 0xcd, 0xa4, 0x7a, 0x73, 0xea, 0x34, 0x9b, 0xda, 0x55, 0xaf, 0x31, - 0xd4, 0x97, 0xf1, 0x42, 0x16, 0x6a, 0xcb, 0xe3, 0x5c, 0x98, 0x0e, 0x74, 0x6f, 0x02, 0xf4, 0x1f, - 0x14, 0xe0, 0xe2, 0x1f, 0x74, 0x1c, 0x9f, 0x44, 0x9c, 0x50, 0x4e, 0xb4, 0xb3, 0xd9, 0xa7, 0x9c, - 0x68, 0xf7, 0xa1, 0x9b, 0xf2, 0xa3, 0xfd, 0x24, 0xc0, 0xa3, 0x03, 0x1d, 0x15, 0x7c, 0xc8, 0x26, - 0x80, 0xff, 0x4d, 0x7c, 0x82, 0xa7, 0xa8, 0x9d, 0x9c, 0x4f, 0xf0, 0x7e, 0xdc, 0x55, 0xce, 0x27, - 0x78, 0x5f, 0xe6, 0x48, 0x5d, 0x61, 0xf0, 0x6f, 0xe1, 0x1b, 0x59, 0xf0, 0xe5, 0x0e, 0xe6, 0xe9, - 0x8c, 0xfa, 0x10, 0xcd, 0xd7, 0x32, 0x7b, 0xda, 0x0e, 0xbc, 0xe9, 0xe1, 0xf7, 0x14, 0x34, 0x9d, - 0xe4, 0x4f, 0x72, 0x8e, 0x9a, 0x69, 0x5e, 0x29, 0xe7, 0xcc, 0x96, 0x41, 0xc9, 0x0c, 0x80, 0x3a, - 0x01, 0x37, 0xbd, 0xaf, 0x79, 0xbd, 0x60, 0x7d, 0xce, 0x64, 0x11, 0x4e, 0x39, 0x65, 0x93, 0x4d, - 0x4d, 0xed, 0x12, 0x7d, 0x6e, 0xa9, 0xcb, 0xe8, 0x45, 0x77, 0x0b, 0x69, 0xaf, 0xde, 0x72, 0xe5, - 0x83, 0xe7, 0x73, 0xca, 0x87, 0xcf, 0xe7, 0x94, 0x7f, 0x3f, 0x9f, 0x53, 0xbe, 0xf3, 0x62, 0x6e, - 0xdf, 0x87, 0x2f, 0xe6, 0xf6, 0xfd, 0xeb, 0xc5, 0xdc, 0xbe, 0x47, 0x9a, 0x44, 0xd1, 0xd6, 0xec, - 0xda, 0xbc, 0xf1, 0x98, 0x58, 0xb6, 0x6c, 0xe1, 0x59, 0xfc, 0xff, 0x3e, 0x6b, 0x63, 0xec, 0x7f, - 0x3a, 0x2f, 0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x5f, 0xea, 0x4b, 0x33, 0x31, 0x2b, 0x00, 0x00, + // 2854 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x5a, 0xdb, 0x6f, 0x1c, 0x49, + 0xd5, 0x4f, 0xdb, 0x89, 0x63, 0x97, 0xbd, 0x89, 0xbf, 0x5a, 0xef, 0xae, 0x77, 0x92, 0x38, 0x9b, + 0xde, 0xfd, 0xbc, 0xd9, 0x24, 0x9e, 0xce, 0x15, 0xc5, 0xb9, 0x21, 0x7b, 0x6d, 0x07, 0xa3, 0x5c, + 0x9c, 0xb1, 0x31, 0x22, 0x02, 0x35, 0x35, 0xd3, 0x35, 0x93, 0x5e, 0xcf, 0x74, 0x4f, 0xba, 0x7b, + 0xe2, 0xcc, 0x5a, 0x23, 0xc4, 0xbe, 0xc0, 0x23, 0x62, 0x85, 0x84, 0xc4, 0x45, 0x08, 0xc4, 0x55, + 0x42, 0x08, 0x76, 0x85, 0xc4, 0x13, 0x0f, 0x80, 0xb4, 0x12, 0x42, 0x0a, 0xcb, 0x0b, 0xda, 0x87, + 0x15, 0x24, 0xfc, 0x21, 0xa8, 0xab, 0x4e, 0x75, 0x57, 0x5f, 0xa6, 0xbb, 0x1d, 0x0f, 0x4f, 0x9e, + 0xa9, 0xa9, 0x73, 0xce, 0xef, 0x5c, 0xea, 0xd4, 0xa9, 0x73, 0x8c, 0x66, 0x1a, 0x0e, 0xa5, 0x56, + 0xdd, 0xa4, 0x4d, 0x43, 0x73, 0x3d, 0xdb, 0x21, 0x0d, 0xaa, 0x3d, 0xec, 0x50, 0xa7, 0x5b, 0x6e, + 0x3b, 0xb6, 0x67, 0x63, 0x1c, 0xfe, 0x5e, 0x86, 0xdf, 0x4b, 0xa7, 0x6a, 0xb6, 0xdb, 0xb2, 0x5d, + 0xad, 0x4a, 0x5c, 0xd8, 0xac, 0x3d, 0x3a, 0x57, 0xa5, 0x1e, 0x39, 0xa7, 0xb5, 0x49, 0xc3, 0xb4, + 0x88, 0x67, 0xda, 0x16, 0xa7, 0x2f, 0xbd, 0xca, 0xf7, 0xea, 0xec, 0x9b, 0xc6, 0xbf, 0xc0, 0x4f, + 0x53, 0x0d, 0xbb, 0x61, 0xf3, 0x75, 0xff, 0x13, 0xac, 0x1e, 0x6d, 0xd8, 0x76, 0xa3, 0x49, 0x35, + 0xd2, 0x36, 0x35, 0x62, 0x59, 0xb6, 0xc7, 0xb8, 0x09, 0x1a, 0x55, 0x82, 0xdb, 0xa6, 0x4e, 0xcb, + 0x74, 0x5d, 0xd3, 0xb6, 0xb4, 0x9a, 0xdd, 0x6a, 0x05, 0x22, 0x4f, 0xa4, 0xef, 0xf1, 0xba, 0x6d, + 0x2a, 0xd8, 0x1c, 0x4f, 0xd1, 0xba, 0x4d, 0x1c, 0xd2, 0x12, 0x1b, 0xd2, 0xcc, 0x22, 0x33, 0x78, + 0x5d, 0xfa, 0xfd, 0x91, 0xe9, 0x78, 0x1d, 0xd2, 0x6c, 0x38, 0x76, 0xa7, 0x2d, 0x6f, 0x52, 0xa7, + 0x10, 0xbe, 0xe7, 0x5b, 0x67, 0x8d, 0x71, 0xae, 0xd0, 0x87, 0x1d, 0xea, 0x7a, 0xea, 0x5d, 0xf4, + 0x62, 0x64, 0xd5, 0x6d, 0xdb, 0x96, 0x4b, 0xf1, 0x65, 0x34, 0xc2, 0x11, 0x4c, 0x2b, 0xaf, 0x29, + 0x27, 0xc7, 0xcf, 0x97, 0xca, 0x49, 0xcb, 0x97, 0x39, 0xcd, 0xe2, 0xfe, 0x8f, 0x3e, 0x3d, 0xbe, + 0xaf, 0x02, 0xfb, 0xd5, 0xeb, 0xe8, 0x98, 0xc4, 0x70, 0xb1, 0xbb, 0x61, 0xb6, 0xa8, 0xeb, 0x91, + 0x56, 0x1b, 0x24, 0xe2, 0xa3, 0x68, 0xcc, 0x13, 0x6b, 0x8c, 0xfb, 0x70, 0x25, 0x5c, 0x50, 0xef, + 0xa3, 0x99, 0x7e, 0xe4, 0x7b, 0x86, 0x36, 0x8f, 0x5e, 0x66, 0xbc, 0x3f, 0x47, 0x89, 0xb1, 0xd8, + 0xa9, 0x6d, 0x51, 0x4f, 0x60, 0x3a, 0x8e, 0xc6, 0xab, 0x6c, 0x41, 0xb7, 0x48, 0x8b, 0x32, 0xc6, + 0x63, 0x15, 0xc4, 0x97, 0xee, 0x90, 0x16, 0x55, 0xe7, 0x51, 0x29, 0x46, 0xba, 0xd8, 0x5d, 0x35, + 0x04, 0xf9, 0x11, 0x34, 0x06, 0xe4, 0xa6, 0x01, 0xc4, 0xa3, 0x7c, 0x61, 0xd5, 0x50, 0x7f, 0xa8, + 0xa0, 0x57, 0x12, 0x62, 0x41, 0x97, 0xcf, 0x06, 0x72, 0x4d, 0xab, 0x6e, 0x83, 0x42, 0x33, 0x69, + 0x0a, 0x71, 0xc2, 0x55, 0xab, 0x6e, 0x0b, 0x5c, 0xfe, 0x67, 0xbc, 0x88, 0x10, 0x7d, 0xec, 0x39, + 0x84, 0xd3, 0x0f, 0x31, 0xfa, 0xd7, 0xfb, 0xd3, 0x2f, 0xfb, 0x7b, 0x19, 0x93, 0x31, 0x2a, 0x3e, + 0xaa, 0xf7, 0x25, 0xb3, 0xdc, 0xad, 0xbe, 0x43, 0x6b, 0x85, 0xcd, 0xe2, 0x6f, 0xb0, 0x19, 0x05, + 0xdf, 0x30, 0xc4, 0x37, 0xf0, 0xa5, 0x84, 0xdd, 0x38, 0xef, 0x98, 0xdd, 0x80, 0x3c, 0xb4, 0x1b, + 0x5f, 0x58, 0x35, 0xd4, 0xaf, 0xa2, 0xa3, 0x01, 0xe9, 0xfa, 0x03, 0x62, 0xd8, 0xdb, 0x83, 0x06, + 0xf7, 0x07, 0xd9, 0x33, 0x82, 0x79, 0xe8, 0x19, 0x01, 0x2d, 0xc7, 0x33, 0x9c, 0x90, 0x7b, 0xc6, + 0x0e, 0x3e, 0xe3, 0xaf, 0xa0, 0xa9, 0x46, 0xd3, 0xae, 0x92, 0xa6, 0x0e, 0x27, 0x52, 0x67, 0x47, + 0x12, 0x7c, 0x74, 0x5a, 0xe6, 0x24, 0x1f, 0xd9, 0xf2, 0x4d, 0x46, 0xb4, 0xc9, 0x97, 0x6e, 0xfa, + 0x4b, 0x15, 0xdc, 0x48, 0xac, 0xa9, 0x75, 0x38, 0x66, 0x49, 0xeb, 0x80, 0x02, 0xcb, 0x69, 0x0a, + 0xbc, 0x91, 0xa6, 0x80, 0x4c, 0x1e, 0x57, 0x43, 0x25, 0x60, 0xa2, 0x5b, 0xa6, 0xeb, 0xf1, 0x18, + 0x12, 0xa9, 0x03, 0xaf, 0x20, 0x14, 0x26, 0x58, 0x10, 0x30, 0x5b, 0x86, 0xa4, 0xea, 0x67, 0xe3, + 0x32, 0x4f, 0xdd, 0x90, 0x8d, 0xcb, 0x6b, 0xa4, 0x41, 0x81, 0xb6, 0x22, 0x51, 0xaa, 0x3f, 0x53, + 0xd0, 0x74, 0x52, 0x06, 0xa8, 0xb1, 0x80, 0x26, 0xa4, 0x13, 0xe2, 0x9f, 0xf9, 0xe1, 0x02, 0x47, + 0x64, 0x3c, 0x3c, 0x22, 0x2e, 0xbe, 0x19, 0xc1, 0xc9, 0xed, 0xff, 0x66, 0x2e, 0x4e, 0x2e, 0x3f, + 0x02, 0xf4, 0x3d, 0x45, 0x32, 0x06, 0xb7, 0xd7, 0xa0, 0x8d, 0x11, 0x8f, 0xea, 0xa1, 0x44, 0x26, + 0xfa, 0xa6, 0x82, 0x4e, 0xc4, 0x41, 0x2c, 0x76, 0x41, 0x77, 0x63, 0xd0, 0x70, 0x22, 0x99, 0x6d, + 0x28, 0x96, 0xd9, 0x22, 0x8e, 0x0b, 0xec, 0x11, 0x3a, 0x4e, 0x8a, 0xbf, 0x4c, 0xc7, 0x49, 0xa1, + 0x37, 0x1e, 0x86, 0xde, 0x00, 0x1d, 0x77, 0x06, 0x1d, 0x66, 0x38, 0xef, 0xac, 0x6c, 0x08, 0x03, + 0xbd, 0x8a, 0x46, 0x3d, 0x7b, 0x8b, 0x5a, 0x61, 0xe6, 0x39, 0xc8, 0xbe, 0xaf, 0x1a, 0xea, 0x97, + 0x20, 0x1f, 0x72, 0x9b, 0x32, 0x9a, 0x20, 0x29, 0x8c, 0xb5, 0xa8, 0x47, 0x74, 0x83, 0x78, 0x04, + 0x8c, 0xaa, 0xf6, 0x8f, 0xc4, 0xdb, 0xd4, 0x23, 0x4b, 0xc4, 0x23, 0x95, 0xd1, 0x16, 0x7c, 0x0a, + 0x58, 0x73, 0x8d, 0x9f, 0x87, 0x35, 0xa7, 0x4c, 0x61, 0xfd, 0x45, 0xf4, 0x12, 0x63, 0xcd, 0xd2, + 0x83, 0xcc, 0xf9, 0x46, 0x92, 0xf3, 0x89, 0x34, 0xce, 0x8c, 0x30, 0x85, 0xf1, 0xd7, 0x15, 0x48, + 0xc4, 0x6b, 0x76, 0xd3, 0xac, 0x75, 0x57, 0x6c, 0x67, 0xa1, 0x56, 0xb3, 0x3b, 0x56, 0x90, 0x88, + 0x4b, 0x68, 0xd4, 0xa1, 0xae, 0xdd, 0x71, 0x6a, 0x22, 0x0b, 0x07, 0xdf, 0xf1, 0x32, 0xfa, 0xbf, + 0xb6, 0x63, 0x5a, 0x35, 0xb3, 0x4d, 0x9a, 0x3a, 0x31, 0x0c, 0x87, 0xba, 0x2e, 0x8f, 0xa3, 0xc5, + 0xe9, 0x8f, 0x3f, 0x9c, 0x9b, 0x02, 0x67, 0x2e, 0xf0, 0x5f, 0xd6, 0x3d, 0xc7, 0xb4, 0x1a, 0x95, + 0xc9, 0x80, 0x04, 0xd6, 0xd5, 0x4d, 0x51, 0x54, 0x24, 0x20, 0x80, 0x92, 0x97, 0xd0, 0x48, 0x9b, + 0xfd, 0x06, 0x1a, 0x1e, 0x93, 0x35, 0x0c, 0xcb, 0xae, 0x32, 0x67, 0x50, 0x81, 0xcd, 0xea, 0x27, + 0x42, 0xb7, 0x4d, 0xea, 0x98, 0xf5, 0xee, 0x5a, 0xb0, 0x51, 0xe8, 0x76, 0x11, 0x8d, 0xda, 0x6d, + 0xea, 0x10, 0xcf, 0x76, 0xb8, 0x6e, 0x19, 0xb0, 0x83, 0x9d, 0xb9, 0x87, 0x38, 0x7e, 0x35, 0x0d, + 0xc7, 0xaf, 0x26, 0xbc, 0x88, 0xc6, 0x49, 0xcd, 0x8f, 0x5d, 0xdd, 0x2f, 0xe1, 0xa6, 0xf7, 0xbf, + 0xa6, 0x9c, 0x3c, 0x14, 0x75, 0x9b, 0xa4, 0xd4, 0x02, 0xdb, 0xb9, 0xd1, 0x6d, 0xd3, 0x0a, 0x22, + 0xc1, 0xe7, 0xc0, 0x68, 0x49, 0xdd, 0x42, 0xa3, 0xd1, 0x7a, 0x9d, 0xd6, 0x3c, 0xa6, 0xda, 0xa1, + 0xbe, 0x46, 0x5b, 0x66, 0x9b, 0x2a, 0xb0, 0x59, 0x7d, 0x08, 0x91, 0xe6, 0x5f, 0x3d, 0xfc, 0x82, + 0x02, 0x63, 0xcd, 0xa3, 0x71, 0x76, 0x87, 0xe9, 0xf6, 0xb6, 0x45, 0xf3, 0xed, 0x85, 0xd8, 0xe6, + 0xbb, 0xfe, 0x5e, 0x7c, 0x0c, 0xf1, 0x6f, 0xb2, 0xc1, 0xc6, 0xd8, 0x0a, 0x4b, 0x7a, 0x9b, 0x52, + 0x89, 0x02, 0x22, 0x41, 0x87, 0x6b, 0x82, 0x50, 0xba, 0xe5, 0x8e, 0xf5, 0x0d, 0x6f, 0x5e, 0xfa, + 0x34, 0xc4, 0x47, 0xf5, 0x7b, 0x0a, 0x30, 0xf6, 0x33, 0x18, 0xdb, 0x31, 0xf0, 0x84, 0x1e, 0x33, + 0xca, 0x50, 0x71, 0xa3, 0xa8, 0x3f, 0x96, 0xef, 0x1b, 0x81, 0x0e, 0xf4, 0xbe, 0x99, 0x02, 0xef, + 0x79, 0x72, 0x23, 0xbe, 0x21, 0xf0, 0xf1, 0x34, 0x3d, 0xc4, 0xd2, 0x74, 0x8e, 0x05, 0x51, 0x60, + 0x41, 0x57, 0xfd, 0xa5, 0x82, 0x8e, 0x44, 0x7d, 0x73, 0x9b, 0xb6, 0xaa, 0xd4, 0x11, 0x76, 0x3c, + 0x8b, 0x46, 0x5a, 0x6c, 0x21, 0x37, 0x1e, 0x60, 0xdf, 0x1e, 0x2c, 0x16, 0x0b, 0xa3, 0xe1, 0x78, + 0x18, 0x51, 0xa9, 0xa4, 0x8c, 0x40, 0x0d, 0x6a, 0xa6, 0x09, 0x4e, 0x2e, 0x21, 0x8e, 0xe5, 0x61, + 0xe9, 0x58, 0xc8, 0x1c, 0x38, 0x62, 0xfe, 0x45, 0xad, 0x43, 0xd1, 0x1b, 0x64, 0xab, 0xc8, 0x29, + 0xc9, 0x4a, 0x97, 0x67, 0x10, 0x0e, 0xd3, 0x25, 0xb8, 0x45, 0xdc, 0xbb, 0x61, 0x56, 0xe4, 0x8e, + 0x30, 0xd4, 0x0d, 0xb0, 0x7c, 0x5c, 0xce, 0xde, 0x72, 0xe2, 0x25, 0x38, 0x12, 0x7c, 0x39, 0x56, + 0xae, 0xf3, 0x3d, 0x52, 0xb9, 0xce, 0x17, 0x56, 0x0d, 0x75, 0x0d, 0x62, 0x55, 0x26, 0xdb, 0x1b, + 0x90, 0x1f, 0x28, 0xf0, 0x36, 0xbd, 0x65, 0xd7, 0xb6, 0x56, 0x28, 0x0d, 0x4f, 0xa6, 0x6f, 0xa4, + 0x16, 0x71, 0xba, 0xba, 0xdb, 0x0e, 0x2e, 0x15, 0xa5, 0xc0, 0xa5, 0xe2, 0xd3, 0xac, 0xb7, 0x61, + 0xdd, 0x57, 0xa7, 0xe6, 0x50, 0xe2, 0x51, 0x9d, 0x78, 0xcc, 0xc6, 0xc3, 0x95, 0x51, 0xbe, 0xb0, + 0xe0, 0xe1, 0x13, 0x68, 0xa2, 0x4d, 0xba, 0x4d, 0x9b, 0x18, 0xba, 0x6b, 0xbe, 0xcb, 0x63, 0x69, + 0x7f, 0x65, 0x1c, 0xd6, 0xd6, 0xcd, 0x77, 0xa9, 0xda, 0x44, 0x53, 0x51, 0x78, 0xa0, 0xee, 0x06, + 0x1a, 0x21, 0x2d, 0xff, 0x76, 0x02, 0x4c, 0xd7, 0xfc, 0x47, 0xe8, 0x27, 0x9f, 0x1e, 0x9f, 0x6d, + 0x98, 0xde, 0x83, 0x4e, 0xb5, 0x5c, 0xb3, 0x5b, 0xd0, 0x7a, 0x80, 0x3f, 0x73, 0xae, 0xb1, 0x05, + 0x4f, 0xf5, 0x55, 0xcb, 0xfb, 0xf8, 0xc3, 0x39, 0x04, 0x1a, 0xac, 0x5a, 0x5e, 0x05, 0x78, 0xa9, + 0x37, 0xa4, 0x63, 0x26, 0x3d, 0xe6, 0x0a, 0xbf, 0x60, 0xe5, 0xd8, 0x8f, 0xd0, 0x07, 0xb1, 0x2f, + 0xbf, 0x24, 0x45, 0xbe, 0x4b, 0x49, 0x03, 0xab, 0x96, 0x47, 0x1d, 0x8b, 0x34, 0xa5, 0x72, 0x5b, + 0x7a, 0x4c, 0x5e, 0x87, 0xd8, 0x5f, 0x75, 0xd7, 0x1c, 0xb3, 0x46, 0xdf, 0x7e, 0x40, 0xac, 0x06, + 0x35, 0x0a, 0xa3, 0xfc, 0xf7, 0x41, 0x50, 0x33, 0x4e, 0x0f, 0x28, 0xa7, 0xd1, 0xc1, 0x1a, 0x5f, + 0x62, 0xc4, 0xa3, 0x15, 0xf1, 0x15, 0xbf, 0x83, 0x70, 0xad, 0xe3, 0x38, 0xd4, 0xf2, 0x74, 0x87, + 0x12, 0x43, 0x6f, 0xfb, 0xe4, 0x90, 0x3c, 0x76, 0xe3, 0x81, 0x25, 0x5a, 0x93, 0x3c, 0xb0, 0x44, + 0x6b, 0x95, 0x49, 0xe0, 0x5b, 0xa1, 0xc4, 0x60, 0xa0, 0xf0, 0x0e, 0x3a, 0x22, 0x64, 0x05, 0x91, + 0xe8, 0xd9, 0x0e, 0x05, 0xa1, 0xc3, 0x03, 0x10, 0x3a, 0x0d, 0x02, 0xd6, 0x20, 0x6a, 0x7d, 0xf6, + 0x5c, 0xf8, 0xd7, 0xd0, 0x31, 0x21, 0xdc, 0xa5, 0x35, 0xdb, 0x32, 0xe2, 0xe2, 0xf7, 0x0f, 0x40, + 0x7c, 0x09, 0x44, 0xac, 0x0b, 0x09, 0x12, 0x80, 0x2e, 0x12, 0xbf, 0xea, 0x8f, 0x48, 0xd3, 0x34, + 0xfc, 0x92, 0x47, 0xf7, 0xc8, 0x63, 0xdd, 0x21, 0x1e, 0x9d, 0x3e, 0x30, 0x00, 0xe9, 0xaf, 0x00, + 0xff, 0x4d, 0xc1, 0x7e, 0x83, 0x3c, 0xae, 0x10, 0x8f, 0xe2, 0x2a, 0x3a, 0x64, 0xd1, 0x6d, 0xd9, + 0xc1, 0x23, 0x03, 0x10, 0x37, 0x61, 0xd1, 0xed, 0xd0, 0xb9, 0x2e, 0x7a, 0xc5, 0x97, 0x91, 0xe6, + 0xd8, 0x83, 0x03, 0x10, 0x36, 0x65, 0xd1, 0xed, 0xa4, 0x53, 0xb7, 0xd1, 0xab, 0xbe, 0xd0, 0x74, + 0x87, 0x8e, 0x0e, 0x40, 0xec, 0xcb, 0x16, 0xdd, 0x4e, 0x73, 0xe6, 0x43, 0xe4, 0xff, 0x92, 0xe6, + 0xc8, 0xb1, 0x01, 0x48, 0x7d, 0xd1, 0xa2, 0xdb, 0x71, 0x27, 0x06, 0x99, 0xec, 0x5e, 0xc7, 0xf6, + 0xe8, 0x17, 0xda, 0x06, 0xf1, 0xe8, 0x86, 0xd9, 0xa2, 0x85, 0x73, 0xc4, 0x55, 0xc8, 0x64, 0x09, + 0x7a, 0xc8, 0x11, 0x47, 0xd0, 0x58, 0x87, 0xad, 0xfa, 0x79, 0x7d, 0x84, 0xe7, 0x75, 0xbe, 0xb0, + 0xe0, 0xa9, 0x16, 0x14, 0xc5, 0xd2, 0xe5, 0xed, 0x2e, 0x3f, 0x36, 0x5d, 0x4f, 0x7a, 0x18, 0x06, + 0x17, 0x2f, 0x3c, 0x0c, 0x79, 0xb5, 0x63, 0xe0, 0xf3, 0xe8, 0x20, 0x2f, 0x0c, 0x78, 0x99, 0x94, + 0x75, 0xdb, 0x88, 0x8d, 0xea, 0x07, 0x0a, 0x34, 0x34, 0x53, 0x04, 0x02, 0xde, 0x4d, 0x34, 0x42, + 0xfd, 0x05, 0xf1, 0x46, 0xbe, 0x91, 0x96, 0x75, 0xb3, 0x79, 0x94, 0xd9, 0x37, 0x77, 0xd9, 0xf2, + 0x9c, 0x6e, 0x05, 0xb8, 0x95, 0xe6, 0xd1, 0xb8, 0xb4, 0x8c, 0x27, 0xd1, 0xf0, 0x16, 0xed, 0x82, + 0x4e, 0xfe, 0x47, 0x3c, 0x85, 0x0e, 0x3c, 0x22, 0xcd, 0x0e, 0xcf, 0x92, 0xa3, 0x15, 0xfe, 0xe5, + 0xca, 0xd0, 0x65, 0x45, 0xed, 0xc0, 0x65, 0xce, 0x8b, 0xce, 0x88, 0x7d, 0xf6, 0x50, 0xe4, 0x1f, + 0x17, 0xa4, 0xbe, 0x63, 0xc1, 0x86, 0xb0, 0xc1, 0x77, 0xac, 0xab, 0x5e, 0x81, 0xc8, 0x90, 0xc4, + 0xc6, 0xea, 0x0f, 0xe1, 0x1a, 0x6e, 0xab, 0xb1, 0xca, 0x28, 0xf8, 0xc6, 0x55, 0x7f, 0x2e, 0x9a, + 0x11, 0x11, 0xcc, 0x60, 0xe2, 0xb5, 0x98, 0x89, 0x2f, 0x67, 0x9b, 0xf8, 0x7f, 0x6b, 0xdc, 0x27, + 0x0a, 0x9a, 0x83, 0x1e, 0x77, 0xb7, 0x45, 0x2d, 0x0f, 0xde, 0xb2, 0xfc, 0x3e, 0x5d, 0x69, 0xda, + 0xdb, 0xfe, 0x29, 0xb9, 0x65, 0xb6, 0xcc, 0xc0, 0xe6, 0x0b, 0xe8, 0x70, 0x9b, 0xef, 0xd5, 0x09, + 0xdf, 0x9c, 0x6b, 0xf7, 0x43, 0xed, 0x08, 0x73, 0x7c, 0x35, 0xe8, 0xa3, 0x15, 0xab, 0xaa, 0xe1, + 0x0c, 0x06, 0x8e, 0x93, 0x8f, 0xe4, 0x70, 0xe2, 0x48, 0xfe, 0x5a, 0x41, 0xe5, 0xa2, 0x2a, 0x81, + 0x4b, 0x5e, 0x42, 0x23, 0xa6, 0xab, 0xbb, 0xd4, 0x83, 0x8b, 0xfc, 0x80, 0xe9, 0xae, 0x53, 0x0f, + 0x1b, 0xe8, 0x70, 0xbd, 0x69, 0x6f, 0xb3, 0x14, 0xa4, 0x37, 0x7d, 0x8a, 0xe7, 0xb8, 0xc3, 0x93, + 0x55, 0xd4, 0x0b, 0x75, 0x19, 0xc4, 0xf9, 0xbf, 0xcf, 0xa2, 0x03, 0x0c, 0x2f, 0xee, 0xa1, 0x11, + 0x3e, 0x2b, 0xc0, 0xb3, 0x7d, 0x63, 0x22, 0x32, 0x31, 0x29, 0xbd, 0x99, 0xbb, 0x8f, 0x6b, 0xa8, + 0xaa, 0xef, 0xfd, 0xe3, 0x3f, 0xef, 0x0f, 0x1d, 0xc5, 0x25, 0xad, 0xef, 0x7c, 0x07, 0xff, 0x46, + 0x3c, 0x40, 0x13, 0xf3, 0x0e, 0x7c, 0x2e, 0x47, 0x4e, 0x72, 0xb4, 0x52, 0x3a, 0xbf, 0x1b, 0x12, + 0x40, 0x59, 0x66, 0x28, 0x4f, 0xe2, 0xd9, 0xfe, 0x28, 0xb5, 0x9d, 0x60, 0x3e, 0xd3, 0xc3, 0xdf, + 0x57, 0x10, 0x0a, 0x6b, 0x48, 0x7c, 0xaa, 0xaf, 0xc8, 0xc4, 0x94, 0xa5, 0x74, 0xba, 0xd0, 0x5e, + 0xc0, 0x75, 0x89, 0xe1, 0xd2, 0xf0, 0x5c, 0x1a, 0xae, 0x07, 0x7e, 0x01, 0xc0, 0xe3, 0x4f, 0xdb, + 0x91, 0x42, 0xb3, 0x87, 0x7f, 0xa1, 0xa0, 0x43, 0xd1, 0x21, 0x0d, 0x2e, 0x17, 0x10, 0x2b, 0xa5, + 0x99, 0xdd, 0xc1, 0x9c, 0x67, 0x30, 0x2f, 0xe0, 0x73, 0x39, 0x30, 0xf5, 0xaa, 0xff, 0x6a, 0x0a, + 0xc0, 0x9a, 0x46, 0x0f, 0x7f, 0x57, 0x41, 0x2f, 0x84, 0x1c, 0xef, 0xac, 0x6c, 0xe0, 0xd7, 0xfb, + 0x4a, 0x0e, 0x3b, 0x97, 0xa5, 0xfe, 0x16, 0x4f, 0x34, 0x2c, 0xd5, 0xcf, 0x30, 0x74, 0x67, 0x71, + 0x39, 0x0f, 0x9d, 0x55, 0xf7, 0xb4, 0x1d, 0xd1, 0x10, 0xed, 0xe1, 0x5f, 0x81, 0x93, 0x79, 0xb7, + 0x31, 0xc7, 0xc9, 0x91, 0xb1, 0x4c, 0x8e, 0xf5, 0xa2, 0x43, 0x0a, 0xf5, 0x6d, 0x86, 0xef, 0x3a, + 0xbe, 0xda, 0x17, 0x1f, 0xef, 0x89, 0x45, 0x9d, 0xac, 0xed, 0x48, 0xcd, 0xb3, 0xd0, 0xe5, 0xe1, + 0x7c, 0x29, 0xc7, 0xe5, 0x89, 0x41, 0xd4, 0xee, 0x40, 0xe7, 0xbb, 0x1c, 0xe0, 0x81, 0xcb, 0x83, + 0x11, 0x57, 0x0f, 0xff, 0x49, 0x41, 0x93, 0xf1, 0x89, 0x0d, 0x3e, 0x9b, 0x29, 0x3c, 0x65, 0xf4, + 0x55, 0x3a, 0xb7, 0x0b, 0x0a, 0x00, 0xfd, 0x79, 0x06, 0x7a, 0x09, 0x2f, 0xf6, 0x05, 0xed, 0x32, + 0xb2, 0x22, 0x06, 0x17, 0x81, 0x1b, 0x74, 0xb1, 0xf7, 0x1a, 0xb8, 0x89, 0x76, 0x78, 0x81, 0xc0, + 0x15, 0x88, 0xa2, 0x81, 0xfb, 0x6d, 0x05, 0x8d, 0x4b, 0x63, 0x24, 0xdc, 0xdf, 0xb1, 0xc9, 0x81, + 0x56, 0xe9, 0x4c, 0xb1, 0xcd, 0x00, 0xf1, 0x24, 0x83, 0xa8, 0xe2, 0xd7, 0xd2, 0x20, 0x36, 0x4d, + 0xd7, 0x83, 0xb3, 0xe5, 0xe2, 0x1f, 0x01, 0x28, 0x18, 0x91, 0xe4, 0x80, 0x8a, 0x0e, 0x96, 0x72, + 0x40, 0xc5, 0xa6, 0x2e, 0xd9, 0x76, 0x63, 0xa0, 0xb8, 0xdd, 0xdc, 0x58, 0xda, 0xfc, 0xa3, 0x82, + 0x5e, 0x4a, 0x1d, 0x28, 0xe1, 0x4b, 0x45, 0xe4, 0x27, 0x06, 0x50, 0xbb, 0x84, 0xbd, 0xc0, 0x60, + 0x5f, 0xc5, 0xf3, 0x79, 0xb0, 0xfd, 0x33, 0x15, 0xa4, 0xd0, 0x48, 0x36, 0xfd, 0x8e, 0x82, 0x26, + 0x82, 0xbe, 0x5e, 0xe1, 0x98, 0x7c, 0x2b, 0xbb, 0x10, 0x94, 0x43, 0x32, 0xff, 0x42, 0x82, 0xe2, + 0x36, 0x1a, 0x91, 0x7f, 0x55, 0xa0, 0x5d, 0x1e, 0x9f, 0x5d, 0x64, 0x9c, 0xfb, 0x3e, 0x93, 0x96, + 0x8c, 0x73, 0xdf, 0x6f, 0x30, 0xa2, 0xde, 0x66, 0xa8, 0x6f, 0xe2, 0xe5, 0xd4, 0xeb, 0x9d, 0x77, + 0xf3, 0xea, 0xb6, 0x23, 0xea, 0x4a, 0x6d, 0x47, 0xf4, 0x22, 0x7b, 0xda, 0x4e, 0x62, 0x72, 0xd3, + 0xc3, 0x7f, 0x53, 0xd0, 0x64, 0x7c, 0x9e, 0x90, 0xa1, 0x48, 0x9f, 0xb1, 0x4a, 0x86, 0x22, 0xfd, + 0x86, 0x15, 0xea, 0x06, 0x53, 0xe4, 0x0e, 0xbe, 0x95, 0xa6, 0xc8, 0x23, 0x46, 0xa5, 0x4b, 0xff, + 0x5f, 0xb3, 0x23, 0x86, 0x31, 0xbd, 0x78, 0x2a, 0x93, 0xe6, 0x2a, 0x3d, 0xfc, 0x53, 0x05, 0x8d, + 0x05, 0x51, 0x83, 0xdf, 0xca, 0xcc, 0xab, 0x72, 0x17, 0xb7, 0x74, 0xaa, 0xc8, 0xd6, 0x22, 0xd1, + 0x1d, 0x46, 0x8e, 0xb6, 0x23, 0x3d, 0xac, 0x7a, 0xe2, 0x1b, 0x3f, 0x9f, 0x7e, 0xd5, 0x15, 0x4e, + 0x01, 0x32, 0x2e, 0xe4, 0xc4, 0x20, 0xa3, 0x74, 0xba, 0xd0, 0xde, 0x22, 0x41, 0xce, 0x0e, 0x22, + 0x43, 0xe5, 0x46, 0xb1, 0xe2, 0x9f, 0x28, 0xe8, 0x70, 0xac, 0xa9, 0x8e, 0xb5, 0x7c, 0x0b, 0x45, + 0x26, 0x05, 0xa5, 0xb3, 0xc5, 0x09, 0x00, 0xed, 0x1c, 0x43, 0xfb, 0x26, 0xfe, 0xff, 0x9c, 0x23, + 0x09, 0x83, 0x85, 0x3f, 0x8b, 0x86, 0x72, 0xb4, 0x61, 0x9e, 0x51, 0x2d, 0xa4, 0x76, 0xf0, 0x4b, + 0x5a, 0xe1, 0xfd, 0x80, 0xf3, 0x16, 0xc3, 0xb9, 0x82, 0x97, 0x72, 0x0e, 0x21, 0x84, 0x41, 0xea, + 0x11, 0x14, 0x2f, 0xdf, 0x9e, 0x7f, 0x9d, 0x1c, 0x8e, 0xb5, 0xda, 0x33, 0x02, 0x22, 0xd1, 0xc6, + 0xcf, 0x08, 0x88, 0x64, 0xef, 0x5e, 0xbd, 0xc8, 0xa0, 0x97, 0xf1, 0x99, 0x0c, 0xe8, 0x50, 0xe7, + 0x04, 0xb3, 0x81, 0x1e, 0xfe, 0x86, 0x82, 0x26, 0xe4, 0xde, 0x38, 0xee, 0xff, 0x68, 0x8a, 0x36, + 0xf7, 0x4b, 0x27, 0xf3, 0x37, 0x02, 0xb2, 0x37, 0x18, 0xb2, 0x19, 0x7c, 0x34, 0x35, 0x54, 0xed, + 0xda, 0x96, 0x5e, 0xa7, 0x14, 0xff, 0x16, 0x22, 0x53, 0x6a, 0x79, 0xe7, 0x44, 0x66, 0xb2, 0xb9, + 0x9e, 0x13, 0x99, 0x29, 0xdd, 0x74, 0xf5, 0x2a, 0x03, 0x77, 0x09, 0x5f, 0xc8, 0x2b, 0xbc, 0x59, + 0xe7, 0x3c, 0x76, 0x19, 0xff, 0x4e, 0xc4, 0x69, 0xb4, 0x09, 0x9e, 0x11, 0xa7, 0xa9, 0xdd, 0xf6, + 0x8c, 0x38, 0x4d, 0xef, 0xae, 0xab, 0x57, 0x18, 0xea, 0x8b, 0xf8, 0x7c, 0x1a, 0x6a, 0xd3, 0xe5, + 0xed, 0x48, 0x1d, 0x3a, 0xee, 0x31, 0xd0, 0xbf, 0x57, 0x60, 0x1c, 0x72, 0xaf, 0x63, 0x7b, 0x24, + 0x6c, 0xcb, 0x65, 0x58, 0x3b, 0xbd, 0x01, 0x98, 0x61, 0xed, 0x3e, 0x1d, 0xbf, 0x6c, 0x6b, 0x3f, + 0xf4, 0xf1, 0xe8, 0xd0, 0x11, 0xf4, 0x1f, 0xb2, 0x31, 0xe0, 0x7f, 0x11, 0x4f, 0xf0, 0x44, 0x77, + 0x2d, 0xe3, 0x09, 0xde, 0xaf, 0x7d, 0x98, 0xf1, 0x04, 0xef, 0xdb, 0xbc, 0x53, 0x97, 0x18, 0xfc, + 0x1b, 0xf8, 0x5a, 0x1a, 0x7c, 0x39, 0x83, 0xb9, 0x3a, 0xeb, 0x3e, 0x89, 0xe4, 0x6b, 0x1a, 0x3d, + 0x6d, 0x07, 0x7e, 0xe9, 0xe1, 0x0f, 0x14, 0x34, 0x19, 0x6f, 0x61, 0x65, 0x94, 0x9a, 0xc9, 0xd6, + 0x5e, 0x46, 0xcd, 0x96, 0xd2, 0x15, 0x2b, 0x80, 0x3a, 0x06, 0x37, 0x79, 0xaf, 0xb9, 0x3d, 0xff, + 0x7c, 0x4e, 0xa5, 0xf5, 0xfc, 0x32, 0xc2, 0x26, 0xbd, 0x3b, 0xb8, 0x4b, 0xf4, 0x99, 0xa1, 0x2e, + 0xa3, 0x17, 0xd9, 0x2d, 0xe8, 0x3c, 0xf6, 0xf0, 0xfb, 0x43, 0x68, 0xb6, 0x58, 0xb7, 0x0b, 0x2f, + 0x64, 0x74, 0x64, 0x8a, 0x35, 0xff, 0x4a, 0x8b, 0x7b, 0x61, 0x01, 0xda, 0x56, 0x99, 0xb6, 0x5f, + 0xc6, 0xf7, 0xd3, 0x9b, 0x3c, 0x91, 0xd6, 0xa2, 0xc8, 0x4c, 0xb1, 0x36, 0x9c, 0xb6, 0x13, 0xdb, + 0x17, 0x2b, 0xac, 0x16, 0x57, 0x3f, 0x7a, 0x3a, 0xa3, 0x3c, 0x79, 0x3a, 0xa3, 0xfc, 0xeb, 0xe9, + 0x8c, 0xf2, 0xad, 0x67, 0x33, 0xfb, 0x9e, 0x3c, 0x9b, 0xd9, 0xf7, 0xcf, 0x67, 0x33, 0xfb, 0xee, + 0x6b, 0x52, 0xcb, 0xae, 0x6a, 0x55, 0xe7, 0x6a, 0x0f, 0x88, 0x69, 0xc9, 0x48, 0x1e, 0x47, 0xff, + 0xab, 0xb9, 0x3a, 0xc2, 0xfe, 0x63, 0xf9, 0xc2, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x4c, 0x93, + 0xb9, 0xe9, 0x0f, 0x2e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -2610,6 +2744,8 @@ type QueryClient interface { QueryGroupsExist(ctx context.Context, in *QueryGroupsExistRequest, opts ...grpc.CallOption) (*QueryGroupsExistResponse, error) // Queries whether some groups are exist by id. QueryGroupsExistById(ctx context.Context, in *QueryGroupsExistByIdRequest, opts ...grpc.CallOption) (*QueryGroupsExistResponse, error) + // Queries the flow rate limit of a bucket for a payment account + QueryPaymentAccountBucketFlowRateLimit(ctx context.Context, in *QueryPaymentAccountBucketFlowRateLimitRequest, opts ...grpc.CallOption) (*QueryPaymentAccountBucketFlowRateLimitResponse, error) } type queryClient struct { @@ -2863,6 +2999,15 @@ func (c *queryClient) QueryGroupsExistById(ctx context.Context, in *QueryGroupsE return out, nil } +func (c *queryClient) QueryPaymentAccountBucketFlowRateLimit(ctx context.Context, in *QueryPaymentAccountBucketFlowRateLimitRequest, opts ...grpc.CallOption) (*QueryPaymentAccountBucketFlowRateLimitResponse, error) { + out := new(QueryPaymentAccountBucketFlowRateLimitResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Query/QueryPaymentAccountBucketFlowRateLimit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Parameters queries the parameters of the module. @@ -2919,6 +3064,8 @@ type QueryServer interface { QueryGroupsExist(context.Context, *QueryGroupsExistRequest) (*QueryGroupsExistResponse, error) // Queries whether some groups are exist by id. QueryGroupsExistById(context.Context, *QueryGroupsExistByIdRequest) (*QueryGroupsExistResponse, error) + // Queries the flow rate limit of a bucket for a payment account + QueryPaymentAccountBucketFlowRateLimit(context.Context, *QueryPaymentAccountBucketFlowRateLimitRequest) (*QueryPaymentAccountBucketFlowRateLimitResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -3006,6 +3153,9 @@ func (*UnimplementedQueryServer) QueryGroupsExist(ctx context.Context, req *Quer func (*UnimplementedQueryServer) QueryGroupsExistById(ctx context.Context, req *QueryGroupsExistByIdRequest) (*QueryGroupsExistResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method QueryGroupsExistById not implemented") } +func (*UnimplementedQueryServer) QueryPaymentAccountBucketFlowRateLimit(ctx context.Context, req *QueryPaymentAccountBucketFlowRateLimitRequest) (*QueryPaymentAccountBucketFlowRateLimitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method QueryPaymentAccountBucketFlowRateLimit not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -3497,6 +3647,24 @@ func _Query_QueryGroupsExistById_Handler(srv interface{}, ctx context.Context, d return interceptor(ctx, in, info, handler) } +func _Query_QueryPaymentAccountBucketFlowRateLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryPaymentAccountBucketFlowRateLimitRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).QueryPaymentAccountBucketFlowRateLimit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Query/QueryPaymentAccountBucketFlowRateLimit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).QueryPaymentAccountBucketFlowRateLimit(ctx, req.(*QueryPaymentAccountBucketFlowRateLimitRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "greenfield.storage.Query", HandlerType: (*QueryServer)(nil), @@ -3609,6 +3777,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "QueryGroupsExistById", Handler: _Query_QueryGroupsExistById_Handler, }, + { + MethodName: "QueryPaymentAccountBucketFlowRateLimit", + Handler: _Query_QueryPaymentAccountBucketFlowRateLimit_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "greenfield/storage/query.proto", @@ -3811,6 +3983,18 @@ func (m *QueryHeadBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l + if m.ExtraInfo != nil { + { + size, err := m.ExtraInfo.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } if m.BucketInfo != nil { { size, err := m.BucketInfo.MarshalToSizedBuffer(dAtA[:i]) @@ -5431,6 +5615,93 @@ func (m *QueryGroupsExistResponse) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.BucketName) > 0 { + i -= len(m.BucketName) + copy(dAtA[i:], m.BucketName) + i = encodeVarintQuery(dAtA, i, uint64(len(m.BucketName))) + i-- + dAtA[i] = 0x1a + } + if len(m.BucketOwner) > 0 { + i -= len(m.BucketOwner) + copy(dAtA[i:], m.BucketOwner) + i = encodeVarintQuery(dAtA, i, uint64(len(m.BucketOwner))) + i-- + dAtA[i] = 0x12 + } + if len(m.PaymentAccount) > 0 { + i -= len(m.PaymentAccount) + copy(dAtA[i:], m.PaymentAccount) + i = encodeVarintQuery(dAtA, i, uint64(len(m.PaymentAccount))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.FlowRateLimit.Size() + i -= size + if _, err := m.FlowRateLimit.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if m.IsSet { + i-- + if m.IsSet { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { offset -= sovQuery(v) base := offset @@ -5521,6 +5792,10 @@ func (m *QueryHeadBucketResponse) Size() (n int) { l = m.BucketInfo.Size() n += 1 + l + sovQuery(uint64(l)) } + if m.ExtraInfo != nil { + l = m.ExtraInfo.Size() + n += 1 + l + sovQuery(uint64(l)) + } return n } @@ -6169,6 +6444,41 @@ func (m *QueryGroupsExistResponse) Size() (n int) { return n } +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.PaymentAccount) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.BucketOwner) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.BucketName) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IsSet { + n += 2 + } + l = m.FlowRateLimit.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -6689,6 +6999,42 @@ func (m *QueryHeadBucketResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraInfo", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ExtraInfo == nil { + m.ExtraInfo = &BucketExtraInfo{} + } + if err := m.ExtraInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipQuery(dAtA[iNdEx:]) @@ -11189,6 +11535,256 @@ func (m *QueryGroupsExistResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryPaymentAccountBucketFlowRateLimitRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryPaymentAccountBucketFlowRateLimitRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryPaymentAccountBucketFlowRateLimitRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PaymentAccount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PaymentAccount = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BucketOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BucketName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryPaymentAccountBucketFlowRateLimitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryPaymentAccountBucketFlowRateLimitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryPaymentAccountBucketFlowRateLimitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsSet", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsSet = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FlowRateLimit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.FlowRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/storage/types/query.pb.gw.go b/x/storage/types/query.pb.gw.go index e440477e4..cb68802da 100644 --- a/x/storage/types/query.pb.gw.go +++ b/x/storage/types/query.pb.gw.go @@ -1678,6 +1678,100 @@ func local_request_Query_QueryGroupsExistById_0(ctx context.Context, marshaler r } +var ( + filter_Query_QueryPaymentAccountBucketFlowRateLimit_0 = &utilities.DoubleArray{Encoding: map[string]int{"payment_account": 0, "bucket_name": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}} +) + +func request_Query_QueryPaymentAccountBucketFlowRateLimit_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryPaymentAccountBucketFlowRateLimitRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["payment_account"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "payment_account") + } + + protoReq.PaymentAccount, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "payment_account", err) + } + + val, ok = pathParams["bucket_name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bucket_name") + } + + protoReq.BucketName, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bucket_name", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QueryPaymentAccountBucketFlowRateLimit_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.QueryPaymentAccountBucketFlowRateLimit(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_QueryPaymentAccountBucketFlowRateLimit_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryPaymentAccountBucketFlowRateLimitRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["payment_account"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "payment_account") + } + + protoReq.PaymentAccount, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "payment_account", err) + } + + val, ok = pathParams["bucket_name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "bucket_name") + } + + protoReq.BucketName, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "bucket_name", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_QueryPaymentAccountBucketFlowRateLimit_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.QueryPaymentAccountBucketFlowRateLimit(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -2305,6 +2399,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_QueryPaymentAccountBucketFlowRateLimit_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) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_QueryPaymentAccountBucketFlowRateLimit_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_QueryPaymentAccountBucketFlowRateLimit_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -2886,6 +3003,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_QueryPaymentAccountBucketFlowRateLimit_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) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_QueryPaymentAccountBucketFlowRateLimit_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_QueryPaymentAccountBucketFlowRateLimit_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -2943,6 +3080,8 @@ var ( pattern_Query_QueryGroupsExist_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"greenfield", "storage", "groups_exist", "group_owner", "group_names"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_QueryGroupsExistById_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"greenfield", "storage", "groups_exist_by_id", "group_ids"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_QueryPaymentAccountBucketFlowRateLimit_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"greenfield", "storage", "payment_account_bucket_flow_rate_limit", "payment_account", "bucket_name"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( @@ -2999,4 +3138,6 @@ var ( forward_Query_QueryGroupsExist_0 = runtime.ForwardResponseMessage forward_Query_QueryGroupsExistById_0 = runtime.ForwardResponseMessage + + forward_Query_QueryPaymentAccountBucketFlowRateLimit_0 = runtime.ForwardResponseMessage ) diff --git a/x/storage/types/tx.pb.go b/x/storage/types/tx.pb.go index a0b7c51b3..765abd6df 100644 --- a/x/storage/types/tx.pb.go +++ b/x/storage/types/tx.pb.go @@ -9,6 +9,7 @@ import ( common "github.com/bnb-chain/greenfield/types/common" types "github.com/bnb-chain/greenfield/x/permission/types" _ "github.com/cosmos/cosmos-proto" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/cosmos/gogoproto/gogoproto" grpc1 "github.com/cosmos/gogoproto/grpc" @@ -3925,6 +3926,116 @@ func (m *MsgToggleSPAsDelegatedAgentResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgToggleSPAsDelegatedAgentResponse proto.InternalMessageInfo +type MsgSetBucketFlowRateLimit struct { + // operator defines the account address of the operator, either the object owner or the updater with granted permission. + Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"` + // bucket_name defines the name of the bucket + BucketName string `protobuf:"bytes,2,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` + // bucket_owner defines the account address of the bucket owner + BucketOwner string `protobuf:"bytes,3,opt,name=bucket_owner,json=bucketOwner,proto3" json:"bucket_owner,omitempty"` + // payment_address defines an account address to pay the fee for the bucket. + PaymentAddress string `protobuf:"bytes,4,opt,name=payment_address,json=paymentAddress,proto3" json:"payment_address,omitempty"` + // flow_rate_limit defines the flow rate limit of the bucket + FlowRateLimit github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=flow_rate_limit,json=flowRateLimit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"flow_rate_limit"` +} + +func (m *MsgSetBucketFlowRateLimit) Reset() { *m = MsgSetBucketFlowRateLimit{} } +func (m *MsgSetBucketFlowRateLimit) String() string { return proto.CompactTextString(m) } +func (*MsgSetBucketFlowRateLimit) ProtoMessage() {} +func (*MsgSetBucketFlowRateLimit) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{71} +} +func (m *MsgSetBucketFlowRateLimit) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSetBucketFlowRateLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSetBucketFlowRateLimit.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgSetBucketFlowRateLimit) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSetBucketFlowRateLimit.Merge(m, src) +} +func (m *MsgSetBucketFlowRateLimit) XXX_Size() int { + return m.Size() +} +func (m *MsgSetBucketFlowRateLimit) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSetBucketFlowRateLimit.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSetBucketFlowRateLimit proto.InternalMessageInfo + +func (m *MsgSetBucketFlowRateLimit) GetOperator() string { + if m != nil { + return m.Operator + } + return "" +} + +func (m *MsgSetBucketFlowRateLimit) GetBucketName() string { + if m != nil { + return m.BucketName + } + return "" +} + +func (m *MsgSetBucketFlowRateLimit) GetBucketOwner() string { + if m != nil { + return m.BucketOwner + } + return "" +} + +func (m *MsgSetBucketFlowRateLimit) GetPaymentAddress() string { + if m != nil { + return m.PaymentAddress + } + return "" +} + +type MsgSetBucketFlowRateLimitResponse struct { +} + +func (m *MsgSetBucketFlowRateLimitResponse) Reset() { *m = MsgSetBucketFlowRateLimitResponse{} } +func (m *MsgSetBucketFlowRateLimitResponse) String() string { return proto.CompactTextString(m) } +func (*MsgSetBucketFlowRateLimitResponse) ProtoMessage() {} +func (*MsgSetBucketFlowRateLimitResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{72} +} +func (m *MsgSetBucketFlowRateLimitResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSetBucketFlowRateLimitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSetBucketFlowRateLimitResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgSetBucketFlowRateLimitResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSetBucketFlowRateLimitResponse.Merge(m, src) +} +func (m *MsgSetBucketFlowRateLimitResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgSetBucketFlowRateLimitResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSetBucketFlowRateLimitResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSetBucketFlowRateLimitResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgCreateBucket)(nil), "greenfield.storage.MsgCreateBucket") proto.RegisterType((*MsgCreateBucketResponse)(nil), "greenfield.storage.MsgCreateBucketResponse") @@ -3997,178 +4108,187 @@ func init() { proto.RegisterType((*MsgDelegateUpdateObjectContentResponse)(nil), "greenfield.storage.MsgDelegateUpdateObjectContentResponse") proto.RegisterType((*MsgToggleSPAsDelegatedAgent)(nil), "greenfield.storage.MsgToggleSPAsDelegatedAgent") proto.RegisterType((*MsgToggleSPAsDelegatedAgentResponse)(nil), "greenfield.storage.MsgToggleSPAsDelegatedAgentResponse") + proto.RegisterType((*MsgSetBucketFlowRateLimit)(nil), "greenfield.storage.MsgSetBucketFlowRateLimit") + proto.RegisterType((*MsgSetBucketFlowRateLimitResponse)(nil), "greenfield.storage.MsgSetBucketFlowRateLimitResponse") } func init() { proto.RegisterFile("greenfield/storage/tx.proto", fileDescriptor_ddb71b028305a3cc) } var fileDescriptor_ddb71b028305a3cc = []byte{ - // 2645 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5b, 0x4b, 0x6c, 0x1b, 0xc7, - 0xf9, 0xf7, 0x92, 0x94, 0x64, 0x7e, 0xd4, 0xc3, 0x5e, 0x2b, 0x31, 0x43, 0xfd, 0x4d, 0xd1, 0x74, - 0xe2, 0xc8, 0x2f, 0xd1, 0x61, 0xfc, 0x77, 0x5d, 0xa1, 0x28, 0x2a, 0x29, 0x8d, 0x4b, 0x24, 0x8a, - 0x95, 0x95, 0xac, 0x02, 0x29, 0x0a, 0x66, 0xc9, 0x1d, 0xaf, 0xb7, 0x21, 0x77, 0xb7, 0xbb, 0x4b, - 0xd9, 0x4a, 0x81, 0x1e, 0xda, 0x02, 0x39, 0x05, 0x30, 0x90, 0x1e, 0x7a, 0x28, 0x8a, 0xa2, 0x40, - 0x81, 0x9e, 0x8a, 0xa2, 0xc8, 0xb9, 0xe8, 0x25, 0x80, 0x51, 0xf4, 0x60, 0xe4, 0x50, 0x14, 0x3d, - 0xb8, 0x81, 0x5d, 0xa0, 0xe8, 0xb5, 0x97, 0x5e, 0x8b, 0x79, 0xec, 0xec, 0x70, 0x9f, 0x14, 0x2d, - 0xc5, 0x02, 0x7a, 0x92, 0x76, 0xe6, 0x37, 0x33, 0xdf, 0x7b, 0xbe, 0xf9, 0x66, 0x08, 0x0b, 0xba, - 0x83, 0x90, 0x79, 0xc7, 0x40, 0x3d, 0xad, 0xe1, 0x7a, 0x96, 0xa3, 0xea, 0xa8, 0xe1, 0xdd, 0x5f, - 0xb6, 0x1d, 0xcb, 0xb3, 0x64, 0x39, 0xe8, 0x5c, 0x66, 0x9d, 0x95, 0xd3, 0x5d, 0xcb, 0xed, 0x5b, - 0x6e, 0xa3, 0xef, 0xea, 0x8d, 0xdd, 0xd7, 0xf0, 0x1f, 0x0a, 0xae, 0xbc, 0x44, 0x3b, 0xda, 0xe4, - 0xab, 0x41, 0x3f, 0x58, 0xd7, 0xbc, 0x6e, 0xe9, 0x16, 0x6d, 0xc7, 0xff, 0xb1, 0xd6, 0x45, 0xdd, - 0xb2, 0xf4, 0x1e, 0x6a, 0x90, 0xaf, 0xce, 0xe0, 0x4e, 0xc3, 0x33, 0xfa, 0xc8, 0xf5, 0xd4, 0xbe, - 0xcd, 0x00, 0x35, 0x81, 0xb6, 0xae, 0xd5, 0xef, 0x5b, 0x66, 0x43, 0xb5, 0x6d, 0xc7, 0xda, 0x55, - 0x7b, 0x7c, 0x8a, 0x08, 0xe2, 0x9e, 0xa3, 0xda, 0x36, 0x72, 0x18, 0xa0, 0x2e, 0x00, 0x6c, 0xe4, - 0xf4, 0x0d, 0xd7, 0x35, 0x2c, 0x93, 0x61, 0x63, 0x26, 0xf1, 0x45, 0x90, 0x09, 0xb0, 0x55, 0x47, - 0xed, 0xfb, 0xfc, 0x55, 0xe3, 0x84, 0xb8, 0x67, 0x23, 0xd6, 0x5f, 0xff, 0x43, 0x1e, 0xe6, 0x36, - 0x5c, 0x7d, 0xdd, 0x41, 0xaa, 0x87, 0xd6, 0x06, 0xdd, 0x0f, 0x90, 0x27, 0x37, 0x61, 0xaa, 0x8b, - 0xbf, 0x2d, 0xa7, 0x2c, 0xd5, 0xa4, 0xa5, 0xe2, 0x5a, 0xf9, 0xf3, 0x4f, 0xaf, 0xcc, 0x33, 0xb1, - 0xad, 0x6a, 0x9a, 0x83, 0x5c, 0x77, 0xcb, 0x73, 0x0c, 0x53, 0x57, 0x7c, 0xa0, 0xbc, 0x08, 0xa5, - 0x0e, 0x19, 0xdd, 0x36, 0xd5, 0x3e, 0x2a, 0xe7, 0xf0, 0x38, 0x05, 0x68, 0xd3, 0x3b, 0x6a, 0x1f, - 0xc9, 0x6b, 0x00, 0xbb, 0x86, 0x6b, 0x74, 0x8c, 0x9e, 0xe1, 0xed, 0x95, 0xf3, 0x35, 0x69, 0x69, - 0xb6, 0x59, 0x5f, 0x8e, 0x6a, 0x71, 0x79, 0x87, 0xa3, 0xb6, 0xf7, 0x6c, 0xa4, 0x08, 0xa3, 0xe4, - 0x55, 0x98, 0xb3, 0xd5, 0xbd, 0x3e, 0x32, 0xbd, 0xb6, 0x4a, 0xc9, 0x28, 0x17, 0x32, 0x08, 0x9c, - 0x65, 0x03, 0x58, 0xab, 0xfc, 0x26, 0xc8, 0xb6, 0x63, 0xf4, 0x55, 0x67, 0xaf, 0xed, 0xda, 0x7c, - 0x96, 0x89, 0x8c, 0x59, 0x4e, 0xb0, 0x31, 0x5b, 0xb6, 0x3f, 0xcf, 0x5b, 0x70, 0x4a, 0x9c, 0x87, - 0xe9, 0xbe, 0x3c, 0x59, 0x93, 0x96, 0x4a, 0xcd, 0x05, 0x91, 0x2f, 0xa6, 0xaf, 0x55, 0x06, 0x51, - 0x4e, 0x06, 0x73, 0xb1, 0x26, 0xf9, 0x32, 0xc8, 0xdd, 0xbb, 0xaa, 0xa3, 0x23, 0xad, 0xed, 0x20, - 0x55, 0x6b, 0x7f, 0x7f, 0x60, 0x79, 0x6a, 0x79, 0xaa, 0x26, 0x2d, 0x15, 0x94, 0x13, 0xac, 0x47, - 0x41, 0xaa, 0xf6, 0x2e, 0x6e, 0x5f, 0x99, 0xfe, 0xd1, 0x3f, 0x7f, 0x77, 0xd1, 0x17, 0x7c, 0x7d, - 0x0b, 0x4e, 0x87, 0xf4, 0xa7, 0x20, 0xd7, 0xb6, 0x4c, 0x17, 0xc9, 0x37, 0xa0, 0xc8, 0x74, 0x62, - 0x68, 0x4c, 0x93, 0x0b, 0x0f, 0x1f, 0x2f, 0x1e, 0xfb, 0xdb, 0xe3, 0xc5, 0xc2, 0x6d, 0xc3, 0xf4, - 0x3e, 0xff, 0xf4, 0x4a, 0x89, 0xb1, 0x8b, 0x3f, 0x95, 0xe3, 0x14, 0xdd, 0xd2, 0xea, 0xf7, 0x88, - 0x51, 0xbc, 0x81, 0x7a, 0x88, 0x1b, 0xc5, 0x35, 0x38, 0x6e, 0xd9, 0xc8, 0x19, 0xc9, 0x2a, 0x38, - 0x32, 0xd3, 0x2c, 0x56, 0x66, 0x30, 0x33, 0x1c, 0x5f, 0x7f, 0x89, 0x70, 0x23, 0x2e, 0xec, 0x73, - 0x53, 0xff, 0xa9, 0x04, 0xf3, 0xb8, 0xcf, 0x70, 0xbb, 0x96, 0xe9, 0x19, 0xe6, 0xe0, 0x70, 0x29, - 0x93, 0x5f, 0x84, 0x49, 0x07, 0xa9, 0xae, 0x65, 0x12, 0x63, 0x2d, 0x2a, 0xec, 0x2b, 0x4c, 0x71, - 0x15, 0xfe, 0x2f, 0x8e, 0x2a, 0x4e, 0xf6, 0x3f, 0x44, 0x07, 0xbb, 0xd5, 0xf9, 0x1e, 0xea, 0x1e, - 0x92, 0x83, 0x2d, 0x42, 0xc9, 0x22, 0xd3, 0x53, 0x00, 0x25, 0x1a, 0x68, 0x13, 0x01, 0x9c, 0x85, - 0x69, 0x5b, 0xdd, 0xeb, 0x59, 0xaa, 0xd6, 0x76, 0x8d, 0x0f, 0x11, 0x71, 0x9d, 0x82, 0x52, 0x62, - 0x6d, 0x5b, 0xc6, 0x87, 0x61, 0x27, 0x9d, 0x18, 0xcb, 0x49, 0xcf, 0xc2, 0x34, 0x16, 0x05, 0x76, - 0x52, 0x1c, 0x68, 0x88, 0x4b, 0x14, 0x95, 0x12, 0x6b, 0xc3, 0xf0, 0x24, 0xe7, 0x99, 0x1a, 0xcb, - 0x79, 0x2e, 0xc0, 0x09, 0x74, 0xdf, 0xc6, 0x7c, 0x77, 0xef, 0xa2, 0xee, 0x07, 0xee, 0xa0, 0xef, - 0x96, 0x8f, 0xd7, 0xf2, 0x4b, 0xd3, 0xca, 0x1c, 0x6d, 0x5f, 0xf7, 0x9b, 0xe5, 0xb7, 0x60, 0xce, - 0x41, 0xda, 0xc0, 0xd4, 0x54, 0xb3, 0xbb, 0x47, 0xa9, 0x2b, 0x26, 0xf3, 0xa8, 0x70, 0x28, 0xe1, - 0x71, 0xd6, 0x19, 0xfa, 0x4e, 0x71, 0x43, 0xaa, 0x65, 0xd1, 0x0d, 0x99, 0x62, 0x46, 0x74, 0x43, - 0x8a, 0x6e, 0x69, 0xf5, 0x4f, 0x72, 0x30, 0xb3, 0xe1, 0xea, 0x5b, 0x48, 0xed, 0x31, 0xcb, 0x39, - 0x24, 0x5b, 0xcf, 0xb4, 0x9d, 0xff, 0x87, 0xd3, 0x7a, 0xcf, 0xea, 0xa8, 0xbd, 0xf6, 0xae, 0xe1, - 0x78, 0x03, 0xb5, 0xd7, 0xd6, 0x1d, 0x6b, 0x60, 0x63, 0x8e, 0xb0, 0x19, 0xcd, 0x28, 0xf3, 0xb4, - 0x7b, 0x87, 0xf6, 0xde, 0xc4, 0x9d, 0x2d, 0x4d, 0x7e, 0x03, 0x16, 0x5d, 0xd4, 0xb5, 0x4c, 0x8d, - 0xa9, 0xba, 0xd3, 0x73, 0xdb, 0xaa, 0xae, 0xb7, 0x5d, 0x43, 0x37, 0x55, 0x6f, 0xe0, 0x20, 0x1a, - 0x7a, 0xa7, 0x95, 0x05, 0x0e, 0xdb, 0xb2, 0xd7, 0x7a, 0xee, 0xaa, 0xae, 0x6f, 0x71, 0x48, 0xd8, - 0xe3, 0x4e, 0xc3, 0x0b, 0x43, 0x42, 0xe1, 0xae, 0xf6, 0xc7, 0x1c, 0x71, 0xb5, 0xa0, 0x67, 0xa7, - 0xf9, 0x3f, 0x29, 0xb0, 0x58, 0x97, 0x98, 0x8c, 0x75, 0x89, 0xf8, 0xf8, 0x2b, 0x4a, 0x90, 0x4b, - 0xf7, 0xe7, 0x12, 0x9c, 0xda, 0x70, 0x75, 0x05, 0xe1, 0xf6, 0xe7, 0x6f, 0x92, 0x61, 0xca, 0xcf, - 0xc0, 0x42, 0x0c, 0x75, 0x9c, 0xfa, 0xdf, 0x52, 0x57, 0x5a, 0xb7, 0xec, 0x3d, 0x46, 0x77, 0x25, - 0x4c, 0xb7, 0x40, 0xdd, 0x79, 0x98, 0x73, 0x9d, 0x6e, 0x3b, 0x4a, 0xe1, 0x8c, 0xeb, 0x74, 0xd7, - 0x02, 0x22, 0xcf, 0xc3, 0x9c, 0xe6, 0x7a, 0x43, 0x38, 0x4a, 0xe8, 0x8c, 0xe6, 0x7a, 0xc3, 0x38, - 0x3c, 0x9f, 0xc8, 0x50, 0x81, 0xcf, 0x77, 0x2b, 0xb0, 0x1a, 0x36, 0x9f, 0x88, 0x9b, 0xe0, 0xf3, - 0x09, 0x38, 0x05, 0x4e, 0x63, 0xdc, 0x98, 0x19, 0xc8, 0xbc, 0xe6, 0x7a, 0x9b, 0xe1, 0x38, 0x1a, - 0x96, 0xe7, 0xbb, 0xc4, 0xcb, 0x02, 0x79, 0x1d, 0x40, 0x38, 0xfb, 0x99, 0x24, 0xa4, 0x15, 0x47, - 0xcb, 0x7a, 0xc4, 0xbc, 0x23, 0x64, 0x39, 0x8f, 0x22, 0x79, 0xc7, 0xe1, 0x92, 0xbe, 0x02, 0xc0, - 0xe5, 0xeb, 0x96, 0xf3, 0xb5, 0x7c, 0x96, 0x80, 0x8b, 0xbe, 0x80, 0x5d, 0x21, 0x67, 0x29, 0xec, - 0x2b, 0x67, 0x09, 0xb1, 0xfc, 0x91, 0x04, 0xb3, 0x7c, 0x37, 0x23, 0xa1, 0x69, 0xac, 0x94, 0xe5, - 0x0c, 0x00, 0x0d, 0x7a, 0x02, 0xa7, 0x45, 0xd2, 0x42, 0x18, 0x9d, 0x87, 0x09, 0x74, 0xdf, 0x73, - 0x54, 0xa6, 0x1d, 0xfa, 0x11, 0xda, 0x56, 0x37, 0xe1, 0xc5, 0x61, 0x42, 0xb8, 0x19, 0x5e, 0x87, - 0xe3, 0x3c, 0xa2, 0x8e, 0x60, 0x85, 0x53, 0x3a, 0x8d, 0xb0, 0x75, 0x8f, 0xb0, 0x46, 0x35, 0x4d, - 0x59, 0x1b, 0x4f, 0x8f, 0xe9, 0xcc, 0x85, 0x25, 0x5e, 0x26, 0x7c, 0x08, 0xab, 0x72, 0x59, 0x7f, - 0x96, 0x23, 0xe6, 0x75, 0xdb, 0xd6, 0x7c, 0x16, 0x37, 0x50, 0xbf, 0x83, 0x9c, 0x31, 0xc9, 0xfa, - 0x2a, 0x94, 0x28, 0x59, 0xd6, 0x3d, 0x13, 0x39, 0x94, 0xae, 0x94, 0x81, 0x94, 0x87, 0x5b, 0x18, - 0x1b, 0xe2, 0x28, 0x1f, 0x56, 0xd7, 0xb7, 0x60, 0xb6, 0x4f, 0x28, 0x73, 0xdb, 0x9e, 0x85, 0x4f, - 0x4e, 0xe5, 0x42, 0x2d, 0xbf, 0x54, 0x8a, 0xcf, 0x9d, 0x36, 0x5c, 0x5d, 0xe0, 0x45, 0x99, 0x66, - 0x23, 0xb7, 0xad, 0x55, 0x0d, 0x6f, 0x72, 0x27, 0x85, 0x99, 0x34, 0x22, 0x94, 0xf2, 0x04, 0x31, - 0xf4, 0x64, 0x4a, 0xe7, 0xf8, 0x14, 0x54, 0x8a, 0xf1, 0x36, 0x1d, 0x11, 0x23, 0x97, 0xf3, 0xbf, - 0xfd, 0xed, 0xcb, 0x44, 0xf7, 0x8e, 0xb2, 0x98, 0xbf, 0x06, 0x53, 0x8c, 0xd3, 0x7d, 0xc8, 0xd7, - 0x1f, 0x92, 0xb4, 0x29, 0x0e, 0xf3, 0xcc, 0x65, 0xf2, 0x31, 0xf5, 0x73, 0x51, 0x1c, 0x57, 0x61, - 0x92, 0xce, 0x95, 0x29, 0x0c, 0x86, 0x93, 0x5b, 0x80, 0x93, 0x0a, 0xc3, 0x51, 0x3d, 0xc3, 0x32, - 0xdb, 0x9e, 0xc1, 0xbc, 0xa1, 0xd4, 0xac, 0x2c, 0xd3, 0x2a, 0xca, 0xb2, 0x5f, 0x45, 0x59, 0xde, - 0xf6, 0xab, 0x28, 0x6b, 0x85, 0x07, 0x7f, 0x5f, 0x94, 0x94, 0xd9, 0x60, 0x20, 0xee, 0xaa, 0xff, - 0x89, 0xea, 0x48, 0x50, 0xe2, 0x37, 0x71, 0x4c, 0x38, 0x72, 0x3a, 0xe2, 0x91, 0xab, 0x20, 0x46, - 0xae, 0x58, 0xd9, 0x87, 0x79, 0xe1, 0xb2, 0xff, 0x8d, 0x44, 0x12, 0x92, 0xb7, 0x91, 0xba, 0xcb, - 0xe2, 0xd0, 0xfe, 0x45, 0x7f, 0x68, 0x1c, 0xae, 0x94, 0x30, 0x2f, 0x6c, 0x19, 0x96, 0x70, 0x07, - 0x94, 0x06, 0x5b, 0x63, 0x4e, 0xd0, 0x17, 0x4d, 0x77, 0x5a, 0xe6, 0x1d, 0xeb, 0xb0, 0x76, 0xc6, - 0xb7, 0x63, 0xcb, 0x24, 0x79, 0x62, 0x6c, 0xd5, 0x98, 0x84, 0xe7, 0x76, 0xcb, 0xf4, 0xae, 0x5f, - 0xdb, 0x51, 0x7b, 0x03, 0x14, 0x2d, 0xa3, 0x1c, 0x44, 0x31, 0xe9, 0x00, 0x8e, 0xcb, 0x69, 0x56, - 0x13, 0x48, 0x94, 0x4b, 0xfc, 0x17, 0x12, 0x4d, 0xcb, 0x54, 0xb3, 0x8b, 0x7a, 0x43, 0x35, 0x85, - 0x23, 0x92, 0x48, 0x2d, 0xc2, 0x99, 0x58, 0xfa, 0xc4, 0x43, 0xda, 0xf4, 0x86, 0xab, 0x6f, 0x0e, - 0xbc, 0x4d, 0xab, 0x67, 0x74, 0xf7, 0xc6, 0x24, 0xfc, 0xeb, 0x50, 0xb4, 0x1d, 0xc3, 0xec, 0x1a, - 0xb6, 0xda, 0x63, 0xf1, 0xa6, 0x26, 0x4a, 0x3e, 0xa8, 0xa8, 0x2e, 0x6f, 0xfa, 0x38, 0x25, 0x18, - 0x82, 0xb3, 0x7f, 0x07, 0xb9, 0xd6, 0xc0, 0xe9, 0xfa, 0x4c, 0xf1, 0x6f, 0xf9, 0x1b, 0x00, 0xae, - 0xa7, 0x7a, 0x08, 0xab, 0xda, 0x8f, 0xc2, 0x49, 0x93, 0x6f, 0xf9, 0x40, 0x45, 0x18, 0x23, 0x6f, - 0x44, 0x63, 0xe2, 0x54, 0x66, 0x4c, 0x3c, 0xfe, 0xf0, 0xf1, 0xa2, 0x14, 0x17, 0x17, 0xc3, 0x32, - 0xde, 0x24, 0x19, 0x03, 0x97, 0xa0, 0x98, 0x99, 0xdb, 0xa4, 0xc5, 0x3f, 0x65, 0x66, 0x65, 0xe6, - 0x14, 0xdd, 0xd2, 0xea, 0xbf, 0x17, 0x33, 0xf3, 0xa3, 0xaa, 0x97, 0xb0, 0x18, 0xb6, 0x84, 0x9c, - 0xfd, 0xc0, 0x24, 0xf1, 0x2f, 0x2a, 0x89, 0x0d, 0xc3, 0x71, 0x2c, 0xe7, 0x99, 0x5c, 0xeb, 0x12, - 0xe4, 0x0c, 0x8d, 0xc5, 0xe4, 0xd4, 0xc5, 0x73, 0x86, 0x16, 0xf6, 0xc3, 0x7c, 0x96, 0x1f, 0x16, - 0x22, 0x05, 0x87, 0x3a, 0xcc, 0x68, 0xc8, 0xc5, 0x27, 0x7e, 0xd5, 0x30, 0x31, 0xdb, 0x13, 0xa4, - 0xcc, 0x50, 0xc2, 0x8d, 0xeb, 0xb8, 0xad, 0xa5, 0xc5, 0x1f, 0x7a, 0x44, 0x56, 0xb9, 0x97, 0x3e, - 0x14, 0xc5, 0xf0, 0x4c, 0x75, 0xd6, 0x83, 0x15, 0x43, 0x84, 0xcb, 0x42, 0x26, 0x97, 0x62, 0x44, - 0xa5, 0x5c, 0x0e, 0x45, 0xd4, 0x2f, 0xc4, 0x9c, 0x23, 0xe8, 0x7f, 0x6e, 0x85, 0xa3, 0xe1, 0x3d, - 0xa5, 0x70, 0x10, 0x7b, 0x8a, 0xa8, 0xe7, 0x50, 0x75, 0xfa, 0x33, 0x9a, 0x01, 0xd2, 0xbe, 0x67, - 0x39, 0x0e, 0xed, 0x4b, 0xcd, 0x19, 0xe9, 0xd5, 0x18, 0x4a, 0xa6, 0xe7, 0x2b, 0x81, 0x0d, 0xce, - 0xe1, 0x27, 0xd4, 0x92, 0xa9, 0x7e, 0x37, 0xc9, 0xd5, 0x98, 0x7c, 0x1d, 0x8a, 0xea, 0xc0, 0xbb, - 0x6b, 0x39, 0x58, 0xc4, 0x59, 0x3c, 0x06, 0x50, 0xf9, 0x06, 0x4c, 0xd2, 0xcb, 0xb5, 0x20, 0xc3, - 0x8d, 0xea, 0x85, 0xae, 0xb1, 0x56, 0xc0, 0x42, 0x50, 0x18, 0x7e, 0x65, 0x16, 0x93, 0x1b, 0xcc, - 0xc4, 0x54, 0x22, 0x12, 0xc5, 0x09, 0xfe, 0x8f, 0x04, 0x27, 0x08, 0x2f, 0xba, 0xa3, 0x1e, 0xf2, - 0xed, 0x8b, 0x7c, 0x01, 0x4e, 0x86, 0xea, 0x48, 0x86, 0x46, 0xf4, 0x31, 0xa3, 0xcc, 0x8a, 0x45, - 0xa2, 0x96, 0x96, 0x56, 0x72, 0x2a, 0x1c, 0x50, 0xc9, 0xa9, 0x02, 0xe5, 0x30, 0xe3, 0x41, 0x49, - 0x22, 0x47, 0x3a, 0xd7, 0xad, 0xbe, 0x8d, 0xe3, 0xfd, 0x97, 0x22, 0x9d, 0x35, 0xa8, 0xc6, 0xd6, - 0x70, 0xef, 0xa8, 0x7d, 0xa3, 0xb7, 0x17, 0x88, 0xaa, 0x12, 0x2d, 0xe5, 0xbe, 0x49, 0x20, 0x2d, - 0x4d, 0x5e, 0x85, 0x69, 0x7d, 0x57, 0x6f, 0xf7, 0x55, 0xdb, 0x36, 0x4c, 0xdd, 0xcf, 0x26, 0xaa, - 0x71, 0x86, 0x73, 0x73, 0xe7, 0xe6, 0x06, 0x85, 0x29, 0x25, 0x7d, 0x57, 0x67, 0xff, 0x47, 0xce, - 0x74, 0x75, 0xa8, 0x25, 0x09, 0x82, 0x4b, 0xeb, 0x87, 0xb4, 0x6c, 0x42, 0xb2, 0xb0, 0x2f, 0x43, - 0x54, 0x61, 0x1a, 0x6b, 0x50, 0x8d, 0x5f, 0x3f, 0x44, 0x21, 0x2d, 0xd7, 0x3e, 0x3f, 0x0a, 0x63, - 0xd6, 0xe7, 0x14, 0xfe, 0x4a, 0x82, 0x22, 0xa9, 0x85, 0x7b, 0xdb, 0xaa, 0x3e, 0x26, 0x55, 0x62, - 0x36, 0x93, 0x0b, 0x65, 0x99, 0xd7, 0xa0, 0xe0, 0xa9, 0xba, 0xcb, 0xce, 0x2f, 0xb5, 0xf8, 0x1b, - 0x28, 0x8a, 0xdd, 0x56, 0x75, 0x57, 0x21, 0xe8, 0x30, 0x1b, 0xa7, 0xe0, 0x24, 0xa7, 0x91, 0x53, - 0xfe, 0x20, 0x47, 0x84, 0x2b, 0x6e, 0x69, 0xeb, 0xf4, 0xf6, 0xed, 0xb9, 0xed, 0x6a, 0x23, 0xdc, - 0x3d, 0x86, 0xef, 0x0d, 0x27, 0xa2, 0xf7, 0x86, 0xe3, 0xdf, 0x6b, 0x50, 0x75, 0xc7, 0x48, 0x84, - 0x0b, 0xed, 0xd7, 0x12, 0x29, 0x20, 0x51, 0x9b, 0x3d, 0x42, 0xa2, 0x0b, 0x73, 0x72, 0x1e, 0x5e, - 0x4e, 0x23, 0x93, 0xf3, 0xf3, 0x97, 0x3c, 0x4f, 0x8f, 0x75, 0xd5, 0x43, 0x07, 0x70, 0x56, 0x14, - 0x4a, 0xc0, 0xb9, 0x31, 0x6f, 0xad, 0xc7, 0xc8, 0x6b, 0xc3, 0x96, 0x33, 0x91, 0x6d, 0x39, 0x31, - 0x37, 0xce, 0xc3, 0x59, 0xd5, 0xd4, 0x58, 0x17, 0xdb, 0xcf, 0xeb, 0xa2, 0x39, 0x64, 0x00, 0xdf, - 0x81, 0xc5, 0x04, 0xbd, 0x1e, 0xc0, 0x15, 0xcd, 0x9f, 0x73, 0xc4, 0x51, 0xfc, 0xd9, 0x0f, 0xce, - 0x0f, 0x9a, 0x30, 0x35, 0x20, 0x93, 0x8d, 0x60, 0x3c, 0x0c, 0x78, 0x64, 0x8c, 0x27, 0x4e, 0xf1, - 0x53, 0x23, 0x85, 0x9d, 0x25, 0x38, 0x9f, 0x2e, 0x4d, 0xee, 0xae, 0x3f, 0x96, 0xc8, 0x31, 0x65, - 0xdb, 0xd2, 0xf5, 0x1e, 0xda, 0xda, 0x5c, 0x75, 0xfd, 0x41, 0xda, 0xaa, 0x7e, 0x78, 0xd1, 0x27, - 0x4c, 0xef, 0x2b, 0x70, 0x2e, 0x85, 0x08, 0x9f, 0xd8, 0xe6, 0x2f, 0xcf, 0x40, 0x7e, 0xc3, 0xd5, - 0xe5, 0xf7, 0x61, 0x7a, 0xe8, 0xe1, 0xd8, 0xb9, 0x84, 0x52, 0xb5, 0x08, 0xaa, 0x5c, 0x1a, 0x01, - 0xc4, 0x2d, 0xf9, 0x7d, 0x98, 0x1e, 0x7a, 0x85, 0x94, 0xb4, 0x82, 0x08, 0x4a, 0x5c, 0x21, 0xee, - 0x59, 0x91, 0xdc, 0x83, 0x13, 0x91, 0xfa, 0xe5, 0xab, 0x09, 0x13, 0x84, 0x81, 0x95, 0xc6, 0x88, - 0x40, 0x91, 0x9f, 0xa1, 0x33, 0x75, 0x12, 0x3f, 0x22, 0x28, 0x91, 0x9f, 0xb8, 0x13, 0x9d, 0x6c, - 0xc1, 0xc9, 0xe8, 0x13, 0xa9, 0xa5, 0x24, 0x89, 0x84, 0x91, 0x95, 0xab, 0xa3, 0x22, 0xf9, 0x82, - 0x3f, 0x91, 0xa0, 0x9c, 0x68, 0xb6, 0x49, 0x02, 0x4a, 0x1a, 0x50, 0xf9, 0xca, 0x3e, 0x07, 0x88, - 0x92, 0x1d, 0xda, 0xe3, 0xd2, 0x6d, 0x91, 0x82, 0x32, 0x6c, 0x31, 0x14, 0x55, 0xdf, 0x03, 0x10, - 0x9e, 0x3d, 0x9c, 0x4d, 0x18, 0x1a, 0x40, 0x2a, 0x17, 0x32, 0x21, 0x22, 0xf5, 0x43, 0xcf, 0x56, - 0xce, 0x65, 0x0e, 0xdd, 0x69, 0x26, 0x52, 0x1f, 0xf7, 0x7c, 0x03, 0xdb, 0x79, 0xe4, 0xe9, 0x46, - 0x92, 0x9d, 0x87, 0x81, 0x89, 0x76, 0x9e, 0xf4, 0xdc, 0x02, 0xcb, 0x4a, 0x78, 0x6a, 0x91, 0x24, - 0xab, 0x00, 0x92, 0x28, 0xab, 0x98, 0x07, 0x08, 0x3c, 0x26, 0x64, 0x68, 0x5a, 0x04, 0x65, 0xc4, - 0x84, 0xd0, 0x0a, 0x0e, 0xc8, 0x31, 0x15, 0xf6, 0x44, 0x12, 0x23, 0xd0, 0xca, 0x6b, 0x23, 0x43, - 0xa3, 0x91, 0x21, 0x83, 0x2b, 0x11, 0x94, 0x11, 0x19, 0x42, 0x2b, 0x0c, 0x47, 0x06, 0xb6, 0xcc, - 0x08, 0x91, 0x81, 0xad, 0x75, 0x75, 0x54, 0x64, 0x34, 0xb4, 0x0a, 0x65, 0xb5, 0xf4, 0xd0, 0x1a, - 0x00, 0x33, 0x42, 0x6b, 0xb4, 0x90, 0x27, 0x0f, 0xe0, 0x54, 0x5c, 0xba, 0x72, 0x71, 0x84, 0x79, - 0x18, 0xb6, 0xd2, 0x1c, 0x1d, 0xcb, 0x97, 0xfd, 0x48, 0x82, 0x97, 0x92, 0x0f, 0x0d, 0x57, 0x53, - 0x0d, 0x21, 0x8e, 0x86, 0x1b, 0xfb, 0x1d, 0xc1, 0x29, 0xb9, 0x0f, 0xf3, 0xb1, 0xd9, 0x7e, 0x9a, - 0xe9, 0x87, 0xc1, 0x95, 0xd7, 0xf7, 0x01, 0xe6, 0x2b, 0x7f, 0x2c, 0xc1, 0x42, 0x5a, 0xca, 0xd8, - 0xcc, 0x98, 0x34, 0x4e, 0x0e, 0x2b, 0xfb, 0x1f, 0xc3, 0xe9, 0xf9, 0x2e, 0x94, 0xc4, 0xb7, 0x2b, - 0xf5, 0xd4, 0x28, 0x4f, 0x30, 0x95, 0x8b, 0xd9, 0x18, 0x71, 0x7a, 0xf1, 0xfd, 0x48, 0x3d, 0x35, - 0xb4, 0xa4, 0x4f, 0x1f, 0xf3, 0x22, 0x04, 0xfb, 0x69, 0xf4, 0x35, 0xc8, 0x52, 0xaa, 0x69, 0x0a, - 0xc8, 0x44, 0x3f, 0x4d, 0x7c, 0x1a, 0x11, 0xf8, 0xa9, 0x70, 0xe5, 0xfe, 0x6a, 0xf6, 0x2c, 0x04, - 0x98, 0xe1, 0xa7, 0xd1, 0x8b, 0x6f, 0xbc, 0x35, 0x08, 0x97, 0xde, 0x49, 0x5b, 0x43, 0x00, 0x49, - 0xdc, 0x1a, 0xa2, 0x17, 0xd2, 0x58, 0x33, 0x62, 0x29, 0xbb, 0x9e, 0x1a, 0x1e, 0xd3, 0x35, 0x13, - 0x53, 0x4b, 0xa6, 0x7b, 0x68, 0xe8, 0xfd, 0x48, 0xf2, 0x1e, 0x3a, 0x0c, 0x4c, 0xd9, 0x43, 0xe3, - 0x5f, 0x67, 0xc8, 0xdf, 0x86, 0x62, 0x70, 0x4b, 0x5a, 0x4b, 0x18, 0xcd, 0x11, 0x95, 0xa5, 0x2c, - 0x44, 0x74, 0x03, 0x65, 0x73, 0xa7, 0x6f, 0xa0, 0x6c, 0xfa, 0x4b, 0x23, 0x80, 0xc4, 0x15, 0x86, - 0x0a, 0xee, 0xe7, 0x52, 0x8d, 0x84, 0x82, 0x12, 0x57, 0x88, 0xab, 0x92, 0xcb, 0x5d, 0x98, 0x19, - 0x2e, 0x1b, 0xbe, 0x9c, 0xa8, 0x47, 0x01, 0x55, 0xb9, 0x3c, 0x0a, 0x8a, 0x2f, 0xf2, 0x03, 0x78, - 0x21, 0xbe, 0xe0, 0x7c, 0x39, 0x31, 0x5b, 0x89, 0x41, 0x57, 0xae, 0xed, 0x07, 0x2d, 0xee, 0x67, - 0x71, 0x05, 0xdc, 0x8b, 0xa9, 0xfb, 0xc3, 0xf0, 0xc2, 0xcd, 0xd1, 0xb1, 0xe2, 0xb2, 0x71, 0x55, - 0xd9, 0x8b, 0xa9, 0x19, 0xe0, 0x68, 0xcb, 0xa6, 0x54, 0x5b, 0xe5, 0x77, 0x60, 0x92, 0x55, 0x5a, - 0xcf, 0x24, 0x66, 0xb5, 0xb8, 0xbb, 0xf2, 0x4a, 0x6a, 0xb7, 0x3f, 0xdf, 0x5a, 0xeb, 0xe1, 0x93, - 0xaa, 0xf4, 0xe8, 0x49, 0x55, 0xfa, 0xe2, 0x49, 0x55, 0x7a, 0xf0, 0xb4, 0x7a, 0xec, 0xd1, 0xd3, - 0xea, 0xb1, 0xbf, 0x3e, 0xad, 0x1e, 0x7b, 0xaf, 0xa1, 0x1b, 0xde, 0xdd, 0x41, 0x67, 0xb9, 0x6b, - 0xf5, 0x1b, 0x1d, 0xb3, 0x73, 0x85, 0xdc, 0x32, 0x35, 0x84, 0x9f, 0x49, 0xdd, 0x1f, 0xfe, 0xa1, - 0x54, 0x67, 0x92, 0xdc, 0xd5, 0xbf, 0xfe, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x98, 0xe4, 0x34, - 0xe6, 0x90, 0x36, 0x00, 0x00, + // 2757 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5b, 0x4d, 0x6c, 0x1c, 0x57, + 0x1d, 0xcf, 0xec, 0xae, 0xed, 0xf8, 0xbf, 0xfe, 0x48, 0x26, 0x6e, 0xb2, 0x59, 0x93, 0xf5, 0x66, + 0xd3, 0xa6, 0xce, 0x97, 0x9d, 0xba, 0x69, 0x08, 0xa6, 0x42, 0xd8, 0x2e, 0x09, 0xab, 0xc6, 0x8d, + 0x3b, 0x76, 0x8c, 0x54, 0x84, 0xb6, 0xe3, 0x9d, 0xe7, 0xc9, 0x90, 0xdd, 0x99, 0x61, 0x66, 0xd6, + 0x8e, 0x8b, 0xd4, 0x03, 0x20, 0xf5, 0x54, 0x29, 0x52, 0x39, 0x70, 0x40, 0x08, 0x21, 0x21, 0x71, + 0x42, 0x08, 0xf5, 0x8c, 0xb8, 0x54, 0x8a, 0x10, 0x87, 0xa8, 0x07, 0x84, 0x38, 0x84, 0x2a, 0x41, + 0xaa, 0xb8, 0x72, 0xe1, 0x8a, 0xde, 0xc7, 0xbc, 0x79, 0x3b, 0x9f, 0xeb, 0xcd, 0xba, 0xb1, 0xc4, + 0x29, 0xd9, 0x79, 0xbf, 0xf7, 0x7f, 0xff, 0xef, 0xf7, 0x7f, 0xff, 0xf7, 0x0c, 0xd3, 0xba, 0x83, + 0x90, 0xb9, 0x6d, 0xa0, 0x96, 0x36, 0xef, 0x7a, 0x96, 0xa3, 0xea, 0x68, 0xde, 0x7b, 0x30, 0x67, + 0x3b, 0x96, 0x67, 0xc9, 0x72, 0x30, 0x38, 0xc7, 0x06, 0xcb, 0xa7, 0x9a, 0x96, 0xdb, 0xb6, 0xdc, + 0xf9, 0xb6, 0xab, 0xcf, 0xef, 0xbc, 0x86, 0xff, 0xa1, 0xe0, 0xf2, 0x69, 0x3a, 0xd0, 0x20, 0xbf, + 0xe6, 0xe9, 0x0f, 0x36, 0x34, 0xa5, 0x5b, 0xba, 0x45, 0xbf, 0xe3, 0xff, 0xb1, 0xaf, 0x33, 0xba, + 0x65, 0xe9, 0x2d, 0x34, 0x4f, 0x7e, 0x6d, 0x75, 0xb6, 0xe7, 0x3d, 0xa3, 0x8d, 0x5c, 0x4f, 0x6d, + 0xdb, 0x0c, 0x50, 0x15, 0x78, 0x6b, 0x5a, 0xed, 0xb6, 0x65, 0xce, 0xab, 0xb6, 0xed, 0x58, 0x3b, + 0x6a, 0x8b, 0x93, 0x88, 0x20, 0x76, 0x1d, 0xd5, 0xb6, 0x91, 0xc3, 0x00, 0x35, 0x01, 0x60, 0x23, + 0xa7, 0x6d, 0xb8, 0xae, 0x61, 0x99, 0x0c, 0x1b, 0x43, 0xc4, 0x57, 0x41, 0x26, 0xc0, 0x56, 0x1d, + 0xb5, 0xed, 0xcb, 0x57, 0x89, 0x53, 0xe2, 0x9e, 0x8d, 0xd8, 0x78, 0xed, 0x4f, 0x79, 0x98, 0x5c, + 0x75, 0xf5, 0x15, 0x07, 0xa9, 0x1e, 0x5a, 0xee, 0x34, 0xef, 0x23, 0x4f, 0x5e, 0x80, 0x91, 0x26, + 0xfe, 0x6d, 0x39, 0x25, 0xa9, 0x2a, 0xcd, 0x8e, 0x2e, 0x97, 0x3e, 0xff, 0xf4, 0xca, 0x14, 0x53, + 0xdb, 0x92, 0xa6, 0x39, 0xc8, 0x75, 0xd7, 0x3d, 0xc7, 0x30, 0x75, 0xc5, 0x07, 0xca, 0x33, 0x50, + 0xdc, 0x22, 0xb3, 0x1b, 0xa6, 0xda, 0x46, 0xa5, 0x1c, 0x9e, 0xa7, 0x00, 0xfd, 0xf4, 0x8e, 0xda, + 0x46, 0xf2, 0x32, 0xc0, 0x8e, 0xe1, 0x1a, 0x5b, 0x46, 0xcb, 0xf0, 0xf6, 0x4a, 0xf9, 0xaa, 0x34, + 0x3b, 0xb1, 0x50, 0x9b, 0x8b, 0x5a, 0x71, 0x6e, 0x93, 0xa3, 0x36, 0xf6, 0x6c, 0xa4, 0x08, 0xb3, + 0xe4, 0x25, 0x98, 0xb4, 0xd5, 0xbd, 0x36, 0x32, 0xbd, 0x86, 0x4a, 0xd9, 0x28, 0x15, 0x32, 0x18, + 0x9c, 0x60, 0x13, 0xd8, 0x57, 0xf9, 0x26, 0xc8, 0xb6, 0x63, 0xb4, 0x55, 0x67, 0xaf, 0xe1, 0xda, + 0x9c, 0xca, 0x50, 0x06, 0x95, 0x63, 0x6c, 0xce, 0xba, 0xed, 0xd3, 0x79, 0x1b, 0x4e, 0x88, 0x74, + 0x98, 0xed, 0x4b, 0xc3, 0x55, 0x69, 0xb6, 0xb8, 0x30, 0x2d, 0xca, 0xc5, 0xec, 0xb5, 0xc4, 0x20, + 0xca, 0xf1, 0x80, 0x16, 0xfb, 0x24, 0x5f, 0x06, 0xb9, 0x79, 0x4f, 0x75, 0x74, 0xa4, 0x35, 0x1c, + 0xa4, 0x6a, 0x8d, 0x1f, 0x75, 0x2c, 0x4f, 0x2d, 0x8d, 0x54, 0xa5, 0xd9, 0x82, 0x72, 0x8c, 0x8d, + 0x28, 0x48, 0xd5, 0xde, 0xc5, 0xdf, 0x17, 0xc7, 0x7e, 0xf2, 0xe5, 0x1f, 0x2e, 0xfa, 0x8a, 0xaf, + 0xad, 0xc3, 0xa9, 0x90, 0xfd, 0x14, 0xe4, 0xda, 0x96, 0xe9, 0x22, 0xf9, 0x06, 0x8c, 0x32, 0x9b, + 0x18, 0x1a, 0xb3, 0xe4, 0xf4, 0xa3, 0x27, 0x33, 0x47, 0xfe, 0xf1, 0x64, 0xa6, 0x70, 0xd7, 0x30, + 0xbd, 0xcf, 0x3f, 0xbd, 0x52, 0x64, 0xe2, 0xe2, 0x9f, 0xca, 0x51, 0x8a, 0xae, 0x6b, 0xb5, 0x5d, + 0xe2, 0x14, 0x6f, 0xa1, 0x16, 0xe2, 0x4e, 0x71, 0x0d, 0x8e, 0x5a, 0x36, 0x72, 0x7a, 0xf2, 0x0a, + 0x8e, 0xcc, 0x74, 0x8b, 0xc5, 0x71, 0x2c, 0x0c, 0xc7, 0xd7, 0x4e, 0x13, 0x69, 0xc4, 0x85, 0x7d, + 0x69, 0x6a, 0x3f, 0x97, 0x60, 0x0a, 0x8f, 0x19, 0x6e, 0xd3, 0x32, 0x3d, 0xc3, 0xec, 0x1c, 0x2c, + 0x67, 0xf2, 0x49, 0x18, 0x76, 0x90, 0xea, 0x5a, 0x26, 0x71, 0xd6, 0x51, 0x85, 0xfd, 0x0a, 0x73, + 0x5c, 0x81, 0xaf, 0xc5, 0x71, 0xc5, 0xd9, 0xfe, 0x97, 0x18, 0x60, 0x77, 0xb6, 0x7e, 0x88, 0x9a, + 0x07, 0x14, 0x60, 0x33, 0x50, 0xb4, 0x08, 0x79, 0x0a, 0xa0, 0x4c, 0x03, 0xfd, 0x44, 0x00, 0x67, + 0x61, 0xcc, 0x56, 0xf7, 0x5a, 0x96, 0xaa, 0x35, 0x5c, 0xe3, 0x03, 0x44, 0x42, 0xa7, 0xa0, 0x14, + 0xd9, 0xb7, 0x75, 0xe3, 0x83, 0x70, 0x90, 0x0e, 0xf5, 0x15, 0xa4, 0x67, 0x61, 0x0c, 0xab, 0x02, + 0x07, 0x29, 0x4e, 0x34, 0x24, 0x24, 0x46, 0x95, 0x22, 0xfb, 0x86, 0xe1, 0x49, 0xc1, 0x33, 0xd2, + 0x57, 0xf0, 0x5c, 0x80, 0x63, 0xe8, 0x81, 0x8d, 0xe5, 0x6e, 0xde, 0x43, 0xcd, 0xfb, 0x6e, 0xa7, + 0xed, 0x96, 0x8e, 0x56, 0xf3, 0xb3, 0x63, 0xca, 0x24, 0xfd, 0xbe, 0xe2, 0x7f, 0x96, 0xdf, 0x86, + 0x49, 0x07, 0x69, 0x1d, 0x53, 0x53, 0xcd, 0xe6, 0x1e, 0xe5, 0x6e, 0x34, 0x59, 0x46, 0x85, 0x43, + 0x89, 0x8c, 0x13, 0x4e, 0xd7, 0xef, 0x94, 0x30, 0xa4, 0x56, 0x16, 0xc3, 0x90, 0x19, 0xa6, 0xc7, + 0x30, 0xa4, 0xe8, 0xba, 0x56, 0xfb, 0x24, 0x07, 0xe3, 0xab, 0xae, 0xbe, 0x8e, 0xd4, 0x16, 0xf3, + 0x9c, 0x03, 0xf2, 0xf5, 0x4c, 0xdf, 0x79, 0x03, 0x4e, 0xe9, 0x2d, 0x6b, 0x4b, 0x6d, 0x35, 0x76, + 0x0c, 0xc7, 0xeb, 0xa8, 0xad, 0x86, 0xee, 0x58, 0x1d, 0x1b, 0x4b, 0x84, 0xdd, 0x68, 0x5c, 0x99, + 0xa2, 0xc3, 0x9b, 0x74, 0xf4, 0x16, 0x1e, 0xac, 0x6b, 0xf2, 0x5b, 0x30, 0xe3, 0xa2, 0xa6, 0x65, + 0x6a, 0xcc, 0xd4, 0x5b, 0x2d, 0xb7, 0xa1, 0xea, 0x7a, 0xc3, 0x35, 0x74, 0x53, 0xf5, 0x3a, 0x0e, + 0xa2, 0xa9, 0x77, 0x4c, 0x99, 0xe6, 0xb0, 0x75, 0x7b, 0xb9, 0xe5, 0x2e, 0xe9, 0xfa, 0x3a, 0x87, + 0x84, 0x23, 0xee, 0x14, 0xbc, 0xd4, 0xa5, 0x14, 0x1e, 0x6a, 0x7f, 0xce, 0x91, 0x50, 0x0b, 0x46, + 0x36, 0x17, 0xfe, 0x2f, 0x15, 0x16, 0x1b, 0x12, 0xc3, 0xb1, 0x21, 0x11, 0x9f, 0x7f, 0x45, 0x0d, + 0x72, 0xed, 0xfe, 0x52, 0x82, 0x13, 0xab, 0xae, 0xae, 0x20, 0xfc, 0xfd, 0xc5, 0xbb, 0x64, 0x98, + 0xf3, 0x33, 0x30, 0x1d, 0xc3, 0x1d, 0xe7, 0xfe, 0xf7, 0x34, 0x94, 0x56, 0x2c, 0x7b, 0x8f, 0xf1, + 0x5d, 0x0e, 0xf3, 0x2d, 0x70, 0x77, 0x1e, 0x26, 0x5d, 0xa7, 0xd9, 0x88, 0x72, 0x38, 0xee, 0x3a, + 0xcd, 0xe5, 0x80, 0xc9, 0xf3, 0x30, 0xa9, 0xb9, 0x5e, 0x17, 0x8e, 0x32, 0x3a, 0xae, 0xb9, 0x5e, + 0x37, 0x0e, 0xd3, 0x13, 0x05, 0x2a, 0x70, 0x7a, 0x77, 0x02, 0xaf, 0x61, 0xf4, 0x44, 0xdc, 0x10, + 0xa7, 0x27, 0xe0, 0x14, 0x38, 0x85, 0x71, 0x7d, 0x56, 0x20, 0x53, 0x9a, 0xeb, 0xad, 0x85, 0xf3, + 0x68, 0x58, 0x9f, 0xef, 0x92, 0x28, 0x0b, 0xf4, 0x35, 0x80, 0x74, 0xf6, 0x0b, 0x49, 0x28, 0x2b, + 0x0e, 0x97, 0xf7, 0x88, 0x75, 0x47, 0xc8, 0x73, 0x1e, 0x47, 0xea, 0x8e, 0x83, 0x65, 0x7d, 0x11, + 0x80, 0xeb, 0xd7, 0x2d, 0xe5, 0xab, 0xf9, 0x2c, 0x05, 0x8f, 0xfa, 0x0a, 0x76, 0x85, 0x9a, 0xa5, + 0xb0, 0xaf, 0x9a, 0x25, 0x24, 0xf2, 0x47, 0x12, 0x4c, 0xf0, 0xdd, 0x8c, 0xa4, 0xa6, 0xbe, 0x4a, + 0x96, 0x33, 0x00, 0x34, 0xe9, 0x09, 0x92, 0x8e, 0x92, 0x2f, 0x44, 0xd0, 0x29, 0x18, 0x42, 0x0f, + 0x3c, 0x47, 0x65, 0xd6, 0xa1, 0x3f, 0x42, 0xdb, 0xea, 0x1a, 0x9c, 0xec, 0x66, 0x84, 0xbb, 0xe1, + 0x75, 0x38, 0xca, 0x33, 0x6a, 0x0f, 0x5e, 0x38, 0xa2, 0xd3, 0x0c, 0x5b, 0xf3, 0x88, 0x68, 0xd4, + 0xd2, 0x54, 0xb4, 0xfe, 0xec, 0x98, 0x2e, 0x5c, 0x58, 0xe3, 0x25, 0x22, 0x87, 0xb0, 0x2a, 0xd7, + 0xf5, 0x67, 0x39, 0xe2, 0x5e, 0x77, 0x6d, 0xcd, 0x17, 0x71, 0x15, 0xb5, 0xb7, 0x90, 0xd3, 0x27, + 0x5b, 0xdf, 0x80, 0x22, 0x65, 0xcb, 0xda, 0x35, 0x91, 0x43, 0xf9, 0x4a, 0x99, 0x48, 0x65, 0xb8, + 0x83, 0xb1, 0x21, 0x89, 0xf2, 0x61, 0x73, 0x7d, 0x17, 0x26, 0xda, 0x84, 0x33, 0xb7, 0xe1, 0x59, + 0xf8, 0xe4, 0x54, 0x2a, 0x54, 0xf3, 0xb3, 0xc5, 0xf8, 0xda, 0x69, 0xd5, 0xd5, 0x05, 0x59, 0x94, + 0x31, 0x36, 0x73, 0xc3, 0x5a, 0xd2, 0xf0, 0x26, 0x77, 0x5c, 0xa0, 0xa4, 0x11, 0xa5, 0x94, 0x86, + 0x88, 0xa3, 0x27, 0x73, 0x3a, 0xc9, 0x49, 0x50, 0x2d, 0xc6, 0xfb, 0x74, 0x44, 0x8d, 0x5c, 0xcf, + 0xff, 0xf1, 0xb7, 0x2f, 0x13, 0xed, 0x1e, 0x66, 0x35, 0xbf, 0x09, 0x23, 0x4c, 0xd2, 0x7d, 0xe8, + 0xd7, 0x9f, 0x92, 0xb4, 0x29, 0x76, 0xcb, 0xcc, 0x75, 0xf2, 0x31, 0x8d, 0x73, 0x51, 0x1d, 0x57, + 0x61, 0x98, 0xd2, 0xca, 0x54, 0x06, 0xc3, 0xc9, 0x75, 0xc0, 0x45, 0x85, 0xe1, 0xa8, 0x9e, 0x61, + 0x99, 0x0d, 0xcf, 0x60, 0xd1, 0x50, 0x5c, 0x28, 0xcf, 0xd1, 0x2e, 0xca, 0x9c, 0xdf, 0x45, 0x99, + 0xdb, 0xf0, 0xbb, 0x28, 0xcb, 0x85, 0x87, 0xff, 0x9c, 0x91, 0x94, 0x89, 0x60, 0x22, 0x1e, 0xaa, + 0xfd, 0x85, 0xda, 0x48, 0x30, 0xe2, 0x77, 0x70, 0x4e, 0x38, 0x74, 0x36, 0xe2, 0x99, 0xab, 0x20, + 0x66, 0xae, 0x58, 0xdd, 0x87, 0x65, 0xe1, 0xba, 0xff, 0x9d, 0x44, 0x0a, 0x92, 0xdb, 0x48, 0xdd, + 0x61, 0x79, 0x68, 0xff, 0xaa, 0x3f, 0x30, 0x09, 0x17, 0x8b, 0x58, 0x16, 0xb6, 0x0c, 0x2b, 0xb8, + 0x03, 0x4e, 0x83, 0xad, 0x31, 0x27, 0xd8, 0x8b, 0x96, 0x3b, 0x75, 0x73, 0xdb, 0x3a, 0xa8, 0x9d, + 0xf1, 0x76, 0x6c, 0x9b, 0x24, 0x4f, 0x9c, 0xad, 0x12, 0x53, 0xf0, 0xdc, 0xad, 0x9b, 0xde, 0xf5, + 0x6b, 0x9b, 0x6a, 0xab, 0x83, 0xa2, 0x6d, 0x94, 0x41, 0x34, 0x93, 0x06, 0x70, 0x5c, 0x4e, 0xf3, + 0x9a, 0x40, 0xa3, 0x5c, 0xe3, 0xbf, 0x92, 0x68, 0x59, 0xa6, 0x9a, 0x4d, 0xd4, 0xea, 0xea, 0x29, + 0x1c, 0x92, 0x42, 0x6a, 0x06, 0xce, 0xc4, 0xf2, 0x27, 0x1e, 0xd2, 0xc6, 0x56, 0x5d, 0x7d, 0xad, + 0xe3, 0xad, 0x59, 0x2d, 0xa3, 0xb9, 0xd7, 0x27, 0xe3, 0xdf, 0x82, 0x51, 0xdb, 0x31, 0xcc, 0xa6, + 0x61, 0xab, 0x2d, 0x96, 0x6f, 0xaa, 0xa2, 0xe6, 0x83, 0x8e, 0xea, 0xdc, 0x9a, 0x8f, 0x53, 0x82, + 0x29, 0xb8, 0xfa, 0x77, 0x90, 0x6b, 0x75, 0x9c, 0xa6, 0x2f, 0x14, 0xff, 0x2d, 0x7f, 0x1b, 0xc0, + 0xf5, 0x54, 0x0f, 0x61, 0x53, 0xfb, 0x59, 0x38, 0x89, 0xf8, 0xba, 0x0f, 0x54, 0x84, 0x39, 0xf2, + 0x6a, 0x34, 0x27, 0x8e, 0x64, 0xe6, 0xc4, 0xa3, 0x8f, 0x9e, 0xcc, 0x48, 0x71, 0x79, 0x31, 0xac, + 0xe3, 0x35, 0x52, 0x31, 0x70, 0x0d, 0x8a, 0x95, 0xb9, 0x4d, 0xbe, 0xf8, 0xa7, 0xcc, 0xac, 0xca, + 0x9c, 0xa2, 0xeb, 0x5a, 0xed, 0x8f, 0x62, 0x65, 0x7e, 0x58, 0xed, 0x12, 0x56, 0xc3, 0xba, 0x50, + 0xb3, 0x0f, 0x4c, 0x13, 0xff, 0xa6, 0x9a, 0x58, 0x35, 0x1c, 0xc7, 0x72, 0x9e, 0x2b, 0xb4, 0x2e, + 0x41, 0xce, 0xd0, 0x58, 0x4e, 0x4e, 0x5d, 0x3c, 0x67, 0x68, 0xe1, 0x38, 0xcc, 0x67, 0xc5, 0x61, + 0x21, 0xd2, 0x70, 0xa8, 0xc1, 0xb8, 0x86, 0x5c, 0x7c, 0xe2, 0x57, 0x0d, 0x13, 0x8b, 0x3d, 0x44, + 0xda, 0x0c, 0x45, 0xfc, 0x71, 0x05, 0x7f, 0xab, 0x6b, 0xf1, 0x87, 0x1e, 0x51, 0x54, 0x1e, 0xa5, + 0x8f, 0x44, 0x35, 0x3c, 0x57, 0x9f, 0x75, 0xb0, 0x6a, 0x88, 0x48, 0x59, 0xc8, 0x94, 0x52, 0xcc, + 0xa8, 0x54, 0xca, 0xae, 0x8c, 0xfa, 0x85, 0x58, 0x73, 0x04, 0xe3, 0x2f, 0xac, 0x71, 0xd4, 0xbd, + 0xa7, 0x14, 0x06, 0xb1, 0xa7, 0x88, 0x76, 0x0e, 0x75, 0xa7, 0x3f, 0xa3, 0x15, 0x20, 0x1d, 0x7b, + 0x9e, 0xe3, 0xd0, 0xbe, 0xcc, 0x9c, 0x51, 0x5e, 0xf5, 0x61, 0x64, 0x7a, 0xbe, 0x12, 0xc4, 0xe0, + 0x12, 0x7e, 0x42, 0x3d, 0x99, 0xda, 0x77, 0x8d, 0x5c, 0x8d, 0xc9, 0xd7, 0x61, 0x54, 0xed, 0x78, + 0xf7, 0x2c, 0x07, 0xab, 0x38, 0x4b, 0xc6, 0x00, 0x2a, 0xdf, 0x80, 0x61, 0x7a, 0xb9, 0x16, 0x54, + 0xb8, 0x51, 0xbb, 0xd0, 0x35, 0x96, 0x0b, 0x58, 0x09, 0x0a, 0xc3, 0x2f, 0x4e, 0x60, 0x76, 0x03, + 0x4a, 0xcc, 0x24, 0x22, 0x53, 0x9c, 0xe1, 0xff, 0x4a, 0x70, 0x8c, 0xc8, 0xa2, 0x3b, 0xea, 0x01, + 0xdf, 0xbe, 0xc8, 0x17, 0xe0, 0x78, 0xa8, 0x8f, 0x64, 0x68, 0xc4, 0x1e, 0xe3, 0xca, 0x84, 0xd8, + 0x24, 0xaa, 0x6b, 0x69, 0x2d, 0xa7, 0xc2, 0x80, 0x5a, 0x4e, 0x65, 0x28, 0x85, 0x05, 0x0f, 0x5a, + 0x12, 0x39, 0x32, 0xb8, 0x62, 0xb5, 0x6d, 0x9c, 0xef, 0xbf, 0x12, 0xed, 0x2c, 0x43, 0x25, 0xb6, + 0x87, 0xbb, 0xad, 0xb6, 0x8d, 0xd6, 0x5e, 0xa0, 0xaa, 0x72, 0xb4, 0x95, 0x7b, 0x93, 0x40, 0xea, + 0x9a, 0xbc, 0x04, 0x63, 0xfa, 0x8e, 0xde, 0x68, 0xab, 0xb6, 0x6d, 0x98, 0xba, 0x5f, 0x4d, 0x54, + 0xe2, 0x1c, 0xe7, 0xd6, 0xe6, 0xad, 0x55, 0x0a, 0x53, 0x8a, 0xfa, 0x8e, 0xce, 0xfe, 0x1f, 0x39, + 0xd3, 0xd5, 0xa0, 0x9a, 0xa4, 0x08, 0xae, 0xad, 0x0f, 0x69, 0xdb, 0x84, 0x54, 0x61, 0x5f, 0x85, + 0xaa, 0xc2, 0x3c, 0x56, 0xa1, 0x12, 0xbf, 0x7e, 0x88, 0x43, 0xda, 0xae, 0x7d, 0x71, 0x1c, 0xc6, + 0xac, 0xcf, 0x39, 0xfc, 0x8d, 0x04, 0xa3, 0xa4, 0x17, 0xee, 0x6d, 0xa8, 0x7a, 0x9f, 0x5c, 0x89, + 0xd5, 0x4c, 0x2e, 0x54, 0x65, 0x5e, 0x83, 0x82, 0xa7, 0xea, 0x2e, 0x3b, 0xbf, 0x54, 0xe3, 0x6f, + 0xa0, 0x28, 0x76, 0x43, 0xd5, 0x5d, 0x85, 0xa0, 0xc3, 0x62, 0x9c, 0x80, 0xe3, 0x9c, 0x47, 0xce, + 0xf9, 0xc3, 0x1c, 0x51, 0xae, 0xb8, 0xa5, 0xad, 0xd0, 0xdb, 0xb7, 0x17, 0xb6, 0xab, 0xf5, 0x70, + 0xf7, 0x18, 0xbe, 0x37, 0x1c, 0x8a, 0xde, 0x1b, 0xf6, 0x7f, 0xaf, 0x41, 0xcd, 0x1d, 0xa3, 0x11, + 0xae, 0xb4, 0xdf, 0x4a, 0xa4, 0x81, 0x44, 0x7d, 0xf6, 0x10, 0xa9, 0x2e, 0x2c, 0xc9, 0x79, 0x78, + 0x39, 0x8d, 0x4d, 0x2e, 0xcf, 0xdf, 0xf2, 0xbc, 0x3c, 0xd6, 0x55, 0x0f, 0x0d, 0xe0, 0xac, 0x28, + 0xb4, 0x80, 0x73, 0x7d, 0xde, 0x5a, 0xf7, 0x51, 0xd7, 0x86, 0x3d, 0x67, 0x28, 0xdb, 0x73, 0x62, + 0x6e, 0x9c, 0xbb, 0xab, 0xaa, 0x91, 0xbe, 0x2e, 0xb6, 0x5f, 0xd4, 0x45, 0x73, 0xc8, 0x01, 0xbe, + 0x0f, 0x33, 0x09, 0x76, 0x1d, 0xc0, 0x15, 0xcd, 0x5f, 0x73, 0x24, 0x50, 0x7c, 0xea, 0x83, 0x8b, + 0x83, 0x05, 0x18, 0xe9, 0x10, 0x62, 0x3d, 0x38, 0x0f, 0x03, 0x1e, 0x1a, 0xe7, 0x89, 0x33, 0xfc, + 0x48, 0x4f, 0x69, 0x67, 0x16, 0xce, 0xa7, 0x6b, 0x93, 0x87, 0xeb, 0x4f, 0x25, 0x72, 0x4c, 0xd9, + 0xb0, 0x74, 0xbd, 0x85, 0xd6, 0xd7, 0x96, 0x5c, 0x7f, 0x92, 0xb6, 0xa4, 0x1f, 0x5c, 0xf6, 0x09, + 0xf3, 0xfb, 0x0a, 0x9c, 0x4b, 0x61, 0x82, 0x33, 0xfb, 0x65, 0x0e, 0x4e, 0xd3, 0x6d, 0x87, 0xee, + 0x99, 0x37, 0x5b, 0xd6, 0xae, 0xa2, 0x7a, 0xe8, 0xb6, 0xd1, 0x36, 0x0e, 0x2c, 0x51, 0x7e, 0x13, + 0xc6, 0x18, 0x80, 0x76, 0x3b, 0xf3, 0x19, 0xa4, 0x19, 0x39, 0xda, 0xee, 0x1c, 0x40, 0xb3, 0x4f, + 0x83, 0xc9, 0xed, 0x96, 0xb5, 0xdb, 0xc0, 0xa5, 0x42, 0xa3, 0x85, 0x25, 0x65, 0xcf, 0xc6, 0xde, + 0x64, 0xa1, 0x75, 0x5e, 0x37, 0xbc, 0x7b, 0x9d, 0x2d, 0x5c, 0xfb, 0xb2, 0x37, 0x86, 0xec, 0x9f, + 0x2b, 0xae, 0x76, 0x9f, 0x3d, 0xba, 0xab, 0x93, 0xe0, 0x03, 0xb6, 0x60, 0xdd, 0xf4, 0x94, 0xf1, + 0x6d, 0x51, 0x79, 0x61, 0x83, 0x9c, 0x83, 0xb3, 0x89, 0x8a, 0xf6, 0xcd, 0xb1, 0xf0, 0xeb, 0x0a, + 0xe4, 0x57, 0x5d, 0x5d, 0x7e, 0x1f, 0xc6, 0xba, 0xde, 0xf1, 0x9d, 0x4b, 0xb8, 0x39, 0x10, 0x41, + 0xe5, 0x4b, 0x3d, 0x80, 0x78, 0x62, 0x79, 0x1f, 0xc6, 0xba, 0x1e, 0x85, 0x25, 0xad, 0x20, 0x82, + 0x12, 0x57, 0x88, 0x7b, 0xe5, 0x25, 0xb7, 0xe0, 0x58, 0xa4, 0x9d, 0xfc, 0x6a, 0x02, 0x81, 0x30, + 0xb0, 0x3c, 0xdf, 0x23, 0x50, 0x94, 0xa7, 0xab, 0xc5, 0x91, 0x24, 0x8f, 0x08, 0x4a, 0x94, 0x27, + 0xee, 0x80, 0x2d, 0x5b, 0x70, 0x3c, 0xfa, 0x62, 0x6d, 0x36, 0x49, 0x23, 0x61, 0x64, 0xf9, 0x6a, + 0xaf, 0x48, 0xbe, 0xe0, 0xcf, 0x24, 0x28, 0x25, 0x66, 0x91, 0x24, 0x05, 0x25, 0x4d, 0x28, 0x7f, + 0x7d, 0x9f, 0x13, 0x44, 0xcd, 0x76, 0x95, 0x1c, 0xe9, 0xbe, 0x48, 0x41, 0x19, 0xbe, 0x18, 0xda, + 0xe4, 0xde, 0x03, 0x10, 0x5e, 0xa1, 0x9c, 0x4d, 0x98, 0x1a, 0x40, 0xca, 0x17, 0x32, 0x21, 0x22, + 0xf7, 0x5d, 0xaf, 0x88, 0xce, 0x65, 0x4e, 0xdd, 0x5c, 0x48, 0xe4, 0x3e, 0xee, 0x35, 0x0d, 0xf6, + 0xf3, 0xc8, 0x4b, 0x9a, 0x24, 0x3f, 0x0f, 0x03, 0x13, 0xfd, 0x3c, 0xe9, 0xf5, 0x0b, 0xd6, 0x95, + 0xf0, 0xf2, 0x25, 0x49, 0x57, 0x01, 0x24, 0x51, 0x57, 0x31, 0xef, 0x41, 0x78, 0x4e, 0xc8, 0xb0, + 0xb4, 0x08, 0xca, 0xc8, 0x09, 0xa1, 0x15, 0x1c, 0x90, 0x63, 0x2e, 0x3c, 0x12, 0x59, 0x8c, 0x40, + 0xcb, 0xaf, 0xf5, 0x0c, 0x8d, 0x66, 0x86, 0x0c, 0xa9, 0x44, 0x50, 0x46, 0x66, 0x08, 0xad, 0xd0, + 0x9d, 0x19, 0xd8, 0x32, 0x3d, 0x64, 0x06, 0xb6, 0xd6, 0xd5, 0x5e, 0x91, 0xd1, 0xd4, 0x2a, 0x74, + 0x39, 0xd3, 0x53, 0x6b, 0x00, 0xcc, 0x48, 0xad, 0xd1, 0xbe, 0xaa, 0xdc, 0x81, 0x13, 0x71, 0xd5, + 0xe3, 0xc5, 0x1e, 0xe8, 0x30, 0x6c, 0x79, 0xa1, 0x77, 0x2c, 0x5f, 0xf6, 0x23, 0x09, 0x4e, 0x27, + 0x9f, 0xe1, 0xae, 0xa6, 0x3a, 0x42, 0x1c, 0x0f, 0x37, 0xf6, 0x3b, 0x83, 0x73, 0xf2, 0x00, 0xa6, + 0x62, 0x0f, 0x5f, 0x69, 0xae, 0x1f, 0x06, 0x97, 0x5f, 0xdf, 0x07, 0x98, 0xaf, 0xfc, 0xb1, 0x04, + 0xd3, 0x69, 0x15, 0xfc, 0x42, 0x06, 0xd1, 0x38, 0x3d, 0x2c, 0xee, 0x7f, 0x0e, 0xe7, 0xe7, 0x07, + 0x50, 0x14, 0x9f, 0x12, 0xd5, 0x52, 0xb3, 0x3c, 0xc1, 0x94, 0x2f, 0x66, 0x63, 0x44, 0xf2, 0xe2, + 0x73, 0x9e, 0x5a, 0x6a, 0x6a, 0x49, 0x27, 0x1f, 0xf3, 0x40, 0x07, 0xc7, 0x69, 0xf4, 0x71, 0xce, + 0x6c, 0xaa, 0x6b, 0x0a, 0xc8, 0xc4, 0x38, 0x4d, 0x7c, 0xa9, 0x12, 0xc4, 0xa9, 0xf0, 0x02, 0xe2, + 0xd5, 0x6c, 0x2a, 0x04, 0x98, 0x11, 0xa7, 0xd1, 0x77, 0x08, 0x78, 0x6b, 0x10, 0xde, 0x20, 0x24, + 0x6d, 0x0d, 0x01, 0x24, 0x71, 0x6b, 0x88, 0xbe, 0x0f, 0xc0, 0x96, 0x11, 0x6f, 0x16, 0x6a, 0xa9, + 0xe9, 0x31, 0xdd, 0x32, 0x31, 0xad, 0x7d, 0xba, 0x87, 0x86, 0x9e, 0xf3, 0x24, 0xef, 0xa1, 0xdd, + 0xc0, 0x94, 0x3d, 0x34, 0xfe, 0xb1, 0x8c, 0xfc, 0x3d, 0x18, 0x0d, 0x2e, 0xad, 0xab, 0x09, 0xb3, + 0x39, 0xa2, 0x3c, 0x9b, 0x85, 0x88, 0x6e, 0xa0, 0x8c, 0x76, 0xfa, 0x06, 0xca, 0xc8, 0x5f, 0xea, + 0x01, 0x24, 0xae, 0xd0, 0x75, 0xff, 0x71, 0x2e, 0xd5, 0x49, 0x28, 0x28, 0x71, 0x85, 0xb8, 0x4b, + 0x0b, 0xb9, 0x09, 0xe3, 0xdd, 0x5d, 0xdc, 0x97, 0x13, 0xed, 0x28, 0xa0, 0xca, 0x97, 0x7b, 0x41, + 0xf1, 0x45, 0x7e, 0x0c, 0x2f, 0xc5, 0xf7, 0xff, 0x2f, 0x27, 0x56, 0x2b, 0x31, 0xe8, 0xf2, 0xb5, + 0xfd, 0xa0, 0xc5, 0xfd, 0x2c, 0xae, 0x9f, 0x7e, 0x31, 0x75, 0x7f, 0xe8, 0x5e, 0x78, 0xa1, 0x77, + 0xac, 0xb8, 0x6c, 0x5c, 0x93, 0xfc, 0x62, 0x6a, 0x05, 0xd8, 0xdb, 0xb2, 0x29, 0xcd, 0x6f, 0xf9, + 0x1d, 0x18, 0x66, 0x8d, 0xef, 0x33, 0x89, 0x55, 0x2d, 0x1e, 0x2e, 0xbf, 0x92, 0x3a, 0xcc, 0xe9, + 0x7d, 0x08, 0x27, 0x13, 0xba, 0x05, 0x57, 0x92, 0x09, 0xc4, 0xc0, 0xcb, 0x6f, 0xec, 0x0b, 0xee, + 0xaf, 0xbf, 0x5c, 0x7f, 0xf4, 0xb4, 0x22, 0x3d, 0x7e, 0x5a, 0x91, 0xbe, 0x78, 0x5a, 0x91, 0x1e, + 0x3e, 0xab, 0x1c, 0x79, 0xfc, 0xac, 0x72, 0xe4, 0xef, 0xcf, 0x2a, 0x47, 0xde, 0x9b, 0x17, 0x4e, + 0xed, 0x5b, 0xe6, 0xd6, 0x15, 0x72, 0xe9, 0x38, 0x2f, 0xfc, 0xd5, 0xdc, 0x83, 0xee, 0xbf, 0x9b, + 0xdb, 0x1a, 0x26, 0x4f, 0x37, 0x5e, 0xff, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x80, 0x48, 0xd6, + 0x34, 0x9f, 0x38, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -4224,6 +4344,7 @@ type MsgClient interface { RejectMigrateBucket(ctx context.Context, in *MsgRejectMigrateBucket, opts ...grpc.CallOption) (*MsgRejectMigrateBucketResponse, error) // Since: Manchurian upgrade SetTag(ctx context.Context, in *MsgSetTag, opts ...grpc.CallOption) (*MsgSetTagResponse, error) + SetBucketFlowRateLimit(ctx context.Context, in *MsgSetBucketFlowRateLimit, opts ...grpc.CallOption) (*MsgSetBucketFlowRateLimitResponse, error) } type msgClient struct { @@ -4549,6 +4670,15 @@ func (c *msgClient) SetTag(ctx context.Context, in *MsgSetTag, opts ...grpc.Call return out, nil } +func (c *msgClient) SetBucketFlowRateLimit(ctx context.Context, in *MsgSetBucketFlowRateLimit, opts ...grpc.CallOption) (*MsgSetBucketFlowRateLimitResponse, error) { + out := new(MsgSetBucketFlowRateLimitResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/SetBucketFlowRateLimit", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { // basic operation of bucket @@ -4592,6 +4722,7 @@ type MsgServer interface { RejectMigrateBucket(context.Context, *MsgRejectMigrateBucket) (*MsgRejectMigrateBucketResponse, error) // Since: Manchurian upgrade SetTag(context.Context, *MsgSetTag) (*MsgSetTagResponse, error) + SetBucketFlowRateLimit(context.Context, *MsgSetBucketFlowRateLimit) (*MsgSetBucketFlowRateLimitResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -4703,6 +4834,9 @@ func (*UnimplementedMsgServer) RejectMigrateBucket(ctx context.Context, req *Msg func (*UnimplementedMsgServer) SetTag(ctx context.Context, req *MsgSetTag) (*MsgSetTagResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SetTag not implemented") } +func (*UnimplementedMsgServer) SetBucketFlowRateLimit(ctx context.Context, req *MsgSetBucketFlowRateLimit) (*MsgSetBucketFlowRateLimitResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetBucketFlowRateLimit not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -5338,6 +5472,24 @@ func _Msg_SetTag_Handler(srv interface{}, ctx context.Context, dec func(interfac return interceptor(ctx, in, info, handler) } +func _Msg_SetBucketFlowRateLimit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSetBucketFlowRateLimit) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).SetBucketFlowRateLimit(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/SetBucketFlowRateLimit", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).SetBucketFlowRateLimit(ctx, req.(*MsgSetBucketFlowRateLimit)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "greenfield.storage.Msg", HandlerType: (*MsgServer)(nil), @@ -5482,6 +5634,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "SetTag", Handler: _Msg_SetTag_Handler, }, + { + MethodName: "SetBucketFlowRateLimit", + Handler: _Msg_SetBucketFlowRateLimit_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "greenfield/storage/tx.proto", @@ -8293,6 +8449,90 @@ func (m *MsgToggleSPAsDelegatedAgentResponse) MarshalToSizedBuffer(dAtA []byte) return len(dAtA) - i, nil } +func (m *MsgSetBucketFlowRateLimit) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgSetBucketFlowRateLimit) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSetBucketFlowRateLimit) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.FlowRateLimit.Size() + i -= size + if _, err := m.FlowRateLimit.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if len(m.PaymentAddress) > 0 { + i -= len(m.PaymentAddress) + copy(dAtA[i:], m.PaymentAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.PaymentAddress))) + i-- + dAtA[i] = 0x22 + } + if len(m.BucketOwner) > 0 { + i -= len(m.BucketOwner) + copy(dAtA[i:], m.BucketOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.BucketOwner))) + i-- + dAtA[i] = 0x1a + } + if len(m.BucketName) > 0 { + i -= len(m.BucketName) + copy(dAtA[i:], m.BucketName) + i = encodeVarintTx(dAtA, i, uint64(len(m.BucketName))) + i-- + dAtA[i] = 0x12 + } + if len(m.Operator) > 0 { + i -= len(m.Operator) + copy(dAtA[i:], m.Operator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Operator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgSetBucketFlowRateLimitResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgSetBucketFlowRateLimitResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSetBucketFlowRateLimitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -9544,6 +9784,42 @@ func (m *MsgToggleSPAsDelegatedAgentResponse) Size() (n int) { return n } +func (m *MsgSetBucketFlowRateLimit) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Operator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.BucketName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.BucketOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.PaymentAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.FlowRateLimit.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgSetBucketFlowRateLimitResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -17890,6 +18166,268 @@ func (m *MsgToggleSPAsDelegatedAgentResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgSetBucketFlowRateLimit) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgSetBucketFlowRateLimit: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSetBucketFlowRateLimit: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Operator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BucketName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BucketOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PaymentAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PaymentAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FlowRateLimit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.FlowRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgSetBucketFlowRateLimitResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgSetBucketFlowRateLimitResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSetBucketFlowRateLimitResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/storage/types/types.pb.go b/x/storage/types/types.pb.go index 743b79003..2dd0e2aff 100644 --- a/x/storage/types/types.pb.go +++ b/x/storage/types/types.pb.go @@ -8,6 +8,7 @@ import ( _ "github.com/bnb-chain/greenfield/x/payment/types" _ "github.com/cosmos/cosmos-proto" _ "github.com/cosmos/cosmos-sdk/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" io "io" @@ -1165,6 +1166,52 @@ func (m *ShadowObjectInfo) GetVersion() int64 { return 0 } +type BucketExtraInfo struct { + IsRateLimited bool `protobuf:"varint,1,opt,name=is_rate_limited,json=isRateLimited,proto3" json:"is_rate_limited,omitempty"` + FlowRateLimit github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=flow_rate_limit,json=flowRateLimit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"flow_rate_limit"` + CurrentFlowRate github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=current_flow_rate,json=currentFlowRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"current_flow_rate"` +} + +func (m *BucketExtraInfo) Reset() { *m = BucketExtraInfo{} } +func (m *BucketExtraInfo) String() string { return proto.CompactTextString(m) } +func (*BucketExtraInfo) ProtoMessage() {} +func (*BucketExtraInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_bf95fa2efdc74d97, []int{13} +} +func (m *BucketExtraInfo) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BucketExtraInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BucketExtraInfo.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *BucketExtraInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_BucketExtraInfo.Merge(m, src) +} +func (m *BucketExtraInfo) XXX_Size() int { + return m.Size() +} +func (m *BucketExtraInfo) XXX_DiscardUnknown() { + xxx_messageInfo_BucketExtraInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_BucketExtraInfo proto.InternalMessageInfo + +func (m *BucketExtraInfo) GetIsRateLimited() bool { + if m != nil { + return m.IsRateLimited + } + return false +} + func init() { proto.RegisterType((*BucketInfo)(nil), "greenfield.storage.BucketInfo") proto.RegisterType((*InternalBucketInfo)(nil), "greenfield.storage.InternalBucketInfo") @@ -1180,101 +1227,108 @@ func init() { proto.RegisterType((*ResourceTags)(nil), "greenfield.storage.ResourceTags") proto.RegisterType((*ResourceTags_Tag)(nil), "greenfield.storage.ResourceTags.Tag") proto.RegisterType((*ShadowObjectInfo)(nil), "greenfield.storage.ShadowObjectInfo") + proto.RegisterType((*BucketExtraInfo)(nil), "greenfield.storage.BucketExtraInfo") } func init() { proto.RegisterFile("greenfield/storage/types.proto", fileDescriptor_bf95fa2efdc74d97) } var fileDescriptor_bf95fa2efdc74d97 = []byte{ - // 1411 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xdf, 0x6e, 0x1b, 0xc5, - 0x17, 0xce, 0x7a, 0xed, 0x24, 0x3e, 0x9b, 0x7f, 0x9d, 0x46, 0xbf, 0x6e, 0x53, 0xd5, 0x71, 0xad, - 0x1f, 0xc8, 0x02, 0x12, 0xab, 0x69, 0x55, 0x10, 0xaa, 0xa8, 0x62, 0x5a, 0x2a, 0x0b, 0x0a, 0x62, - 0x93, 0x16, 0x89, 0x9b, 0xd5, 0xec, 0xee, 0x64, 0x33, 0x74, 0x77, 0xc7, 0xcc, 0xcc, 0xa6, 0x71, - 0x25, 0x5e, 0x80, 0x2b, 0x2e, 0x78, 0x02, 0x24, 0x5e, 0x00, 0xf5, 0x21, 0x2a, 0x24, 0xa4, 0xaa, - 0x57, 0x88, 0x8b, 0x0a, 0xb5, 0x6f, 0xc0, 0x05, 0xd7, 0x68, 0x67, 0xc6, 0xe9, 0xc6, 0x76, 0x9a, - 0xa4, 0x6a, 0xef, 0x3c, 0x67, 0xbe, 0xb3, 0x33, 0xe7, 0xcf, 0xf7, 0x9d, 0x31, 0x34, 0x62, 0x4e, - 0x48, 0xb6, 0x43, 0x49, 0x12, 0x75, 0x84, 0x64, 0x1c, 0xc7, 0xa4, 0x23, 0x07, 0x7d, 0x22, 0xd6, - 0xfb, 0x9c, 0x49, 0x86, 0xd0, 0xcb, 0xfd, 0x75, 0xb3, 0xbf, 0xd2, 0x08, 0x99, 0x48, 0x99, 0xe8, - 0x04, 0x58, 0x90, 0xce, 0xde, 0xe5, 0x80, 0x48, 0x7c, 0xb9, 0x13, 0x32, 0x9a, 0x69, 0x9f, 0x95, - 0xf3, 0x7a, 0xdf, 0x57, 0xab, 0x8e, 0x5e, 0x98, 0xad, 0xe5, 0x98, 0xc5, 0x4c, 0xdb, 0x8b, 0x5f, - 0xc6, 0x7a, 0xa9, 0x74, 0x89, 0x3e, 0x1e, 0xa4, 0x24, 0x93, 0x1d, 0x96, 0x4b, 0x7f, 0x27, 0x61, - 0x0f, 0x0c, 0xe4, 0xdd, 0x09, 0x10, 0x21, 0x39, 0xc1, 0xa9, 0xcf, 0x49, 0xc8, 0x78, 0x64, 0x70, - 0xab, 0x13, 0xe2, 0x09, 0x59, 0x9a, 0x32, 0x73, 0xb9, 0xd6, 0x2f, 0x35, 0x80, 0x6e, 0x1e, 0xde, - 0x27, 0xb2, 0x97, 0xed, 0x30, 0xb4, 0x0e, 0x35, 0xf6, 0x20, 0x23, 0xdc, 0xb5, 0x9a, 0x56, 0xbb, - 0xde, 0x75, 0x9f, 0x3e, 0x5a, 0x5b, 0x36, 0x37, 0xde, 0x8c, 0x22, 0x4e, 0x84, 0xd8, 0x92, 0x9c, - 0x66, 0xb1, 0xa7, 0x61, 0x68, 0x15, 0x9c, 0x40, 0x79, 0xfb, 0x19, 0x4e, 0x89, 0x5b, 0x29, 0xbc, - 0x3c, 0xd0, 0xa6, 0x2f, 0x71, 0x4a, 0x50, 0x17, 0x60, 0x8f, 0x0a, 0x1a, 0xd0, 0x84, 0xca, 0x81, - 0x6b, 0x37, 0xad, 0xf6, 0xc2, 0x46, 0x6b, 0x7d, 0x3c, 0x8b, 0xeb, 0xf7, 0x0e, 0x50, 0xdb, 0x83, - 0x3e, 0xf1, 0x4a, 0x5e, 0xe8, 0x7d, 0xa8, 0xd0, 0xc8, 0xad, 0xaa, 0x1b, 0x5d, 0x78, 0xfc, 0x6c, - 0x75, 0xea, 0xaf, 0x67, 0xab, 0xd5, 0xbb, 0x34, 0x93, 0x4f, 0x1f, 0xad, 0x39, 0xe6, 0x76, 0xc5, - 0xd2, 0xab, 0xd0, 0x08, 0xdd, 0x00, 0x47, 0xb0, 0x9c, 0x87, 0xc4, 0x2f, 0xea, 0xe6, 0xd6, 0xd4, - 0x89, 0x8d, 0x49, 0x27, 0x6e, 0x29, 0x98, 0x3e, 0x4d, 0x1c, 0xfc, 0x46, 0x17, 0xa0, 0x1e, 0x72, - 0x82, 0x25, 0xf1, 0xb1, 0x74, 0xa7, 0x9b, 0x56, 0xdb, 0xf6, 0x66, 0xb5, 0x61, 0x53, 0xa2, 0x4d, - 0x58, 0x34, 0xe9, 0xf6, 0xb1, 0xce, 0x87, 0x3b, 0x73, 0x4c, 0xa6, 0x16, 0x8c, 0x83, 0xb1, 0xa2, - 0x2e, 0x34, 0xe2, 0x84, 0x05, 0x38, 0xf1, 0xf7, 0x28, 0x97, 0x39, 0x4e, 0xfc, 0x98, 0xb3, 0xbc, - 0xef, 0xef, 0xe0, 0x94, 0x26, 0x03, 0x9f, 0x46, 0xee, 0x6c, 0xd3, 0x6a, 0xcf, 0x7b, 0x2b, 0x1a, - 0x75, 0x4f, 0x83, 0x6e, 0x17, 0x98, 0xcf, 0x14, 0xa4, 0x17, 0xa1, 0x0f, 0x00, 0x85, 0xbb, 0x98, - 0xc7, 0x24, 0xf2, 0x39, 0xc1, 0x91, 0xff, 0x7d, 0xce, 0x24, 0x76, 0xeb, 0x4d, 0xab, 0x5d, 0xf5, - 0x96, 0xcc, 0x8e, 0x47, 0x70, 0xf4, 0x75, 0x61, 0x47, 0xb7, 0x60, 0xde, 0x14, 0x49, 0x48, 0x2c, - 0x73, 0xe1, 0x82, 0x4a, 0x4a, 0x73, 0x52, 0x52, 0x74, 0x2f, 0x6c, 0x29, 0x9c, 0x37, 0x17, 0x94, - 0x56, 0xe8, 0x2a, 0x54, 0x25, 0x8e, 0x85, 0xeb, 0x34, 0xad, 0xb6, 0x33, 0xd9, 0xdb, 0x23, 0x26, - 0x91, 0x38, 0x16, 0x9e, 0x42, 0x17, 0xe1, 0x8a, 0xbe, 0x8f, 0x85, 0x1f, 0x91, 0x84, 0xc4, 0x58, - 0x92, 0xc8, 0xc7, 0x71, 0x91, 0xbf, 0x88, 0x0a, 0x1c, 0x24, 0x24, 0x72, 0xe7, 0x9a, 0x56, 0x7b, - 0xd6, 0x5b, 0x11, 0xfd, 0x4d, 0x71, 0x73, 0x88, 0xd9, 0x2c, 0x20, 0x37, 0x0d, 0xa2, 0xf5, 0xaf, - 0x05, 0xa8, 0x97, 0x49, 0xc2, 0x33, 0x9c, 0x94, 0x9a, 0xf5, 0x22, 0x40, 0x9f, 0xd3, 0xa2, 0xd2, - 0x34, 0x25, 0xaa, 0x63, 0x6d, 0xaf, 0xae, 0x2c, 0xdb, 0x34, 0x25, 0xe8, 0x3d, 0x38, 0x23, 0x99, - 0xc4, 0x89, 0xaf, 0x13, 0xe2, 0x0b, 0xfa, 0x50, 0x77, 0x68, 0xd5, 0x5b, 0x54, 0x1b, 0x9f, 0x2a, - 0xfb, 0x16, 0x7d, 0x48, 0xd0, 0x37, 0xb0, 0x9c, 0xb0, 0x70, 0xb4, 0x26, 0xc2, 0xb5, 0x9b, 0x76, - 0xdb, 0xd9, 0x78, 0x67, 0x52, 0xac, 0x5f, 0x14, 0xf8, 0x72, 0x75, 0x3c, 0x94, 0x8c, 0x9a, 0x04, - 0xba, 0x0e, 0x17, 0x32, 0xb2, 0x2f, 0xfd, 0x09, 0x5f, 0xf7, 0x4d, 0x53, 0xcf, 0x7b, 0xe7, 0x0a, - 0xc8, 0xd8, 0xf7, 0x7a, 0x51, 0xeb, 0xc7, 0x19, 0x80, 0xaf, 0x82, 0xef, 0x48, 0xf8, 0x7a, 0xec, - 0xdc, 0x80, 0x19, 0xd5, 0xb9, 0x8c, 0x6b, 0x66, 0xbe, 0xc2, 0x63, 0x08, 0x1c, 0x65, 0xb4, 0x3d, - 0xc6, 0xe8, 0x55, 0x70, 0x98, 0xba, 0x92, 0x06, 0x54, 0x35, 0x40, 0x9b, 0x14, 0x40, 0xd3, 0xb5, - 0x76, 0x32, 0xba, 0x5e, 0x81, 0xff, 0x1d, 0x91, 0x9a, 0x69, 0x95, 0x9a, 0xb3, 0xc9, 0x78, 0x5a, - 0xd0, 0x25, 0x98, 0xeb, 0xe3, 0x41, 0xc2, 0x70, 0xa4, 0x8b, 0x3a, 0xa3, 0x8a, 0xea, 0x18, 0x9b, - 0x2a, 0xe8, 0x61, 0xdd, 0x99, 0x7d, 0x2d, 0xdd, 0xb9, 0x04, 0x73, 0x21, 0xcb, 0x64, 0xd1, 0xac, - 0x4a, 0x4b, 0xea, 0x2a, 0x54, 0xc7, 0xd8, 0xc6, 0xc5, 0x02, 0x46, 0xc4, 0xe2, 0x16, 0xcc, 0x9b, - 0x4c, 0x19, 0xde, 0x39, 0x47, 0xf3, 0x4e, 0x57, 0x79, 0xc8, 0x3b, 0x56, 0x5a, 0xa1, 0xcf, 0x61, - 0x91, 0x93, 0x28, 0xcf, 0x22, 0x9c, 0x85, 0x03, 0x7d, 0x93, 0xb9, 0xa3, 0xe3, 0xf1, 0x0e, 0xa0, - 0x2a, 0x9e, 0x05, 0x7e, 0x68, 0x3d, 0x2a, 0x8f, 0xf3, 0xa7, 0x96, 0xc7, 0x0e, 0xd4, 0xc3, 0x5d, - 0x12, 0xde, 0x17, 0x79, 0x2a, 0xdc, 0x85, 0xa6, 0xdd, 0x9e, 0xeb, 0x9e, 0xf9, 0xe7, 0xd9, 0xea, - 0xbc, 0xe4, 0x98, 0x4a, 0xf1, 0x71, 0x8b, 0xa5, 0x54, 0xb6, 0xbc, 0x97, 0x98, 0x03, 0xd9, 0x58, - 0x3c, 0x95, 0x6c, 0xac, 0x82, 0x43, 0x85, 0x9f, 0xf7, 0x23, 0x2c, 0x69, 0x16, 0xbb, 0x4b, 0x4a, - 0x23, 0x80, 0x8a, 0xbb, 0xc6, 0x52, 0x90, 0x5f, 0xed, 0x16, 0x7a, 0x22, 0xdd, 0x33, 0x9a, 0xfc, - 0xc6, 0xb2, 0x29, 0xd1, 0x87, 0x2f, 0xb7, 0x83, 0x81, 0x8b, 0x8e, 0xe9, 0xfe, 0xa1, 0x63, 0x77, - 0x80, 0x5c, 0x98, 0xd9, 0x23, 0x5c, 0x50, 0x96, 0xb9, 0x67, 0xd5, 0x47, 0x87, 0xcb, 0xd6, 0xcf, - 0x15, 0xa8, 0xeb, 0x0e, 0x7c, 0x1d, 0x2e, 0x5e, 0x04, 0xd0, 0xad, 0x5d, 0x1a, 0x94, 0x75, 0x65, - 0x51, 0xa4, 0x19, 0xa9, 0x8b, 0x7d, 0xea, 0xba, 0x9c, 0x6a, 0x48, 0x2e, 0x43, 0x8d, 0xec, 0x4b, - 0x8e, 0x35, 0x4b, 0x3d, 0xbd, 0x38, 0xa8, 0xd4, 0xf4, 0x69, 0x2a, 0xd5, 0xba, 0x0e, 0xb5, 0xed, - 0xa2, 0xf6, 0x45, 0x84, 0xaa, 0x09, 0x74, 0x04, 0x96, 0x8e, 0x50, 0x59, 0xd4, 0x05, 0x97, 0xa1, - 0xb6, 0x87, 0x93, 0x7c, 0x18, 0xbb, 0x5e, 0xb4, 0xfe, 0xb0, 0x60, 0x41, 0x4b, 0xfa, 0x1d, 0x22, - 0xf1, 0x4d, 0x2c, 0x31, 0x6a, 0x82, 0x13, 0x11, 0x11, 0x72, 0xda, 0x97, 0x45, 0x15, 0xf4, 0x87, - 0xca, 0xa6, 0x82, 0x98, 0x64, 0x5f, 0x8f, 0x03, 0x3f, 0xe7, 0x89, 0xf9, 0xa2, 0x33, 0xb4, 0xdd, - 0xe5, 0xc9, 0xf1, 0x32, 0xb6, 0x0c, 0x35, 0x9a, 0xe2, 0x78, 0x28, 0x60, 0x7a, 0x81, 0x6e, 0x00, - 0x60, 0x29, 0x39, 0x0d, 0x72, 0x49, 0x84, 0x5b, 0x53, 0xea, 0x7f, 0x7e, 0x52, 0x22, 0x54, 0xc8, - 0xdd, 0x6a, 0x91, 0x68, 0xaf, 0xe4, 0xa2, 0xe2, 0xd1, 0x5c, 0x7e, 0xe3, 0xf1, 0x94, 0x55, 0xd7, - 0x1e, 0x53, 0xdd, 0xb7, 0x14, 0xcf, 0xef, 0x16, 0xcc, 0xab, 0xa6, 0x7f, 0xb3, 0xe1, 0x1c, 0x66, - 0x83, 0x3d, 0xca, 0x86, 0xb7, 0x14, 0xcc, 0x06, 0xd8, 0xbd, 0x48, 0x18, 0xaa, 0x58, 0x4d, 0xfb, - 0x04, 0x54, 0x69, 0xfd, 0x66, 0x01, 0x14, 0xcf, 0x12, 0x49, 0x14, 0xed, 0xaf, 0x81, 0x69, 0x22, - 0x9f, 0x46, 0x42, 0x05, 0xef, 0x6c, 0x9c, 0x9b, 0x74, 0x87, 0x5e, 0x24, 0xbc, 0xba, 0x86, 0x16, - 0x67, 0x5e, 0x03, 0x53, 0x2c, 0xe5, 0x57, 0x39, 0xc6, 0x4f, 0x43, 0x0b, 0xbf, 0xab, 0x50, 0x1f, - 0x4e, 0x44, 0xa1, 0xf2, 0xf4, 0x0a, 0xb7, 0xd9, 0x58, 0xcf, 0x47, 0xd1, 0x7a, 0x6a, 0xc1, 0xd9, - 0x3b, 0x34, 0xe6, 0xb8, 0xa8, 0x47, 0xe9, 0xc5, 0xb4, 0x02, 0x75, 0xc1, 0x43, 0x5f, 0xa8, 0x01, - 0x6b, 0xa9, 0x01, 0x3b, 0x23, 0x78, 0xb8, 0x55, 0x0c, 0xd5, 0x1e, 0xb4, 0x8a, 0xbd, 0x63, 0xde, - 0xa6, 0x15, 0xe5, 0x74, 0x51, 0xf0, 0xf0, 0xf6, 0xd1, 0xcf, 0xd3, 0x15, 0xa8, 0x47, 0x42, 0x9a, - 0x63, 0x6c, 0x7d, 0x4c, 0x24, 0xa4, 0x3a, 0xe6, 0x23, 0xa8, 0x1f, 0x24, 0xf0, 0x24, 0x72, 0x35, - 0x3b, 0xcc, 0x61, 0xeb, 0x07, 0x98, 0x2b, 0xcb, 0x0f, 0xfa, 0xc4, 0xc8, 0x95, 0xa5, 0x1a, 0xe1, - 0xff, 0xc7, 0xc9, 0xd5, 0xfa, 0x36, 0x8e, 0x4d, 0x4f, 0x28, 0xbf, 0x95, 0x35, 0xb0, 0xb7, 0x71, - 0x8c, 0x96, 0xc0, 0xbe, 0x4f, 0x06, 0xa6, 0x8f, 0x8b, 0x9f, 0x47, 0x28, 0xd5, 0xaf, 0x15, 0x58, - 0xda, 0xda, 0xc5, 0x11, 0x7b, 0x50, 0x7a, 0x91, 0x5d, 0x85, 0x59, 0xd6, 0x27, 0x5c, 0x3d, 0xb1, - 0x8e, 0x1b, 0x04, 0x07, 0x48, 0xd3, 0x80, 0x95, 0x93, 0x69, 0xf5, 0xe8, 0x2b, 0xc4, 0x1e, 0x7f, - 0x85, 0x8c, 0xbe, 0x87, 0xaa, 0xe3, 0xef, 0xa1, 0x43, 0x63, 0xbb, 0x76, 0x82, 0xb1, 0x7d, 0x78, - 0xbe, 0x4e, 0x8f, 0xce, 0xd7, 0xd2, 0x98, 0x9c, 0x39, 0x34, 0x26, 0xbb, 0xbd, 0xc7, 0xcf, 0x1b, - 0xd6, 0x93, 0xe7, 0x0d, 0xeb, 0xef, 0xe7, 0x0d, 0xeb, 0xa7, 0x17, 0x8d, 0xa9, 0x27, 0x2f, 0x1a, - 0x53, 0x7f, 0xbe, 0x68, 0x4c, 0x7d, 0xdb, 0x89, 0xa9, 0xdc, 0xcd, 0x83, 0xf5, 0x90, 0xa5, 0x9d, - 0x20, 0x0b, 0xd6, 0xc2, 0x5d, 0x4c, 0xb3, 0x4e, 0xe9, 0x1f, 0xea, 0xfe, 0xe1, 0xff, 0xdc, 0xc1, - 0xb4, 0xfa, 0x8f, 0x7a, 0xe5, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc7, 0xda, 0xa4, 0x75, 0x96, - 0x0f, 0x00, 0x00, + // 1507 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xdf, 0x6e, 0x1b, 0x45, + 0x17, 0xcf, 0x7a, 0xed, 0xc4, 0x3e, 0x8e, 0xe3, 0x64, 0x1b, 0x7d, 0xdd, 0xa6, 0xaa, 0xe3, 0x5a, + 0xdf, 0x57, 0x59, 0x1f, 0x24, 0x56, 0xd3, 0xaa, 0x20, 0x54, 0x51, 0xc5, 0xf4, 0x8f, 0x2c, 0x5a, + 0x10, 0x9b, 0xb4, 0x48, 0xdc, 0xac, 0xc6, 0xbb, 0x93, 0xcd, 0x90, 0xf5, 0x8e, 0x99, 0x99, 0x4d, + 0xe3, 0x4a, 0x3c, 0x00, 0x5c, 0x71, 0xc1, 0x13, 0x20, 0xf1, 0x02, 0xa8, 0x0f, 0x51, 0x21, 0x21, + 0x55, 0xbd, 0x42, 0x5c, 0x54, 0xa8, 0x7d, 0x03, 0x2e, 0xb8, 0x46, 0xf3, 0xc7, 0xee, 0xc6, 0x76, + 0x9a, 0xa4, 0xb4, 0x57, 0xf1, 0x9c, 0xf9, 0x9d, 0x39, 0x73, 0x7e, 0xe7, 0xdf, 0x6c, 0xa0, 0x16, + 0x31, 0x8c, 0x93, 0x1d, 0x82, 0xe3, 0xb0, 0xc5, 0x05, 0x65, 0x28, 0xc2, 0x2d, 0x31, 0xe8, 0x63, + 0xbe, 0xde, 0x67, 0x54, 0x50, 0xc7, 0x79, 0xb5, 0xbf, 0x6e, 0xf6, 0x57, 0x6a, 0x01, 0xe5, 0x3d, + 0xca, 0x5b, 0x5d, 0xc4, 0x71, 0x6b, 0xff, 0x72, 0x17, 0x0b, 0x74, 0xb9, 0x15, 0x50, 0x92, 0x68, + 0x9d, 0x95, 0x73, 0x7a, 0xdf, 0x57, 0xab, 0x96, 0x5e, 0x98, 0xad, 0xe5, 0x88, 0x46, 0x54, 0xcb, + 0xe5, 0x2f, 0x23, 0xbd, 0x98, 0xb9, 0x44, 0x1f, 0x0d, 0x7a, 0x38, 0x11, 0x2d, 0x9a, 0x0a, 0x7f, + 0x27, 0xa6, 0x0f, 0x0d, 0xe4, 0xd2, 0x14, 0x08, 0x17, 0x0c, 0xa3, 0x9e, 0xcf, 0x70, 0x40, 0x59, + 0x68, 0x70, 0xab, 0x53, 0xfc, 0x09, 0x68, 0xaf, 0x47, 0xcd, 0xe5, 0x1a, 0x3f, 0x15, 0x00, 0xda, + 0x69, 0xb0, 0x87, 0x45, 0x27, 0xd9, 0xa1, 0xce, 0x3a, 0x14, 0xe8, 0xc3, 0x04, 0x33, 0xd7, 0xaa, + 0x5b, 0xcd, 0x52, 0xdb, 0x7d, 0xf6, 0x78, 0x6d, 0xd9, 0xdc, 0x78, 0x33, 0x0c, 0x19, 0xe6, 0x7c, + 0x4b, 0x30, 0x92, 0x44, 0x9e, 0x86, 0x39, 0xab, 0x50, 0xee, 0x2a, 0x6d, 0x3f, 0x41, 0x3d, 0xec, + 0xe6, 0xa4, 0x96, 0x07, 0x5a, 0xf4, 0x19, 0xea, 0x61, 0xa7, 0x0d, 0xb0, 0x4f, 0x38, 0xe9, 0x92, + 0x98, 0x88, 0x81, 0x6b, 0xd7, 0xad, 0xe6, 0xc2, 0x46, 0x63, 0x7d, 0x92, 0xc5, 0xf5, 0x07, 0x23, + 0xd4, 0xf6, 0xa0, 0x8f, 0xbd, 0x8c, 0x96, 0xf3, 0x1e, 0xe4, 0x48, 0xe8, 0xe6, 0xd5, 0x8d, 0xce, + 0x3f, 0x79, 0xbe, 0x3a, 0xf3, 0xc7, 0xf3, 0xd5, 0xfc, 0x7d, 0x92, 0x88, 0x67, 0x8f, 0xd7, 0xca, + 0xe6, 0x76, 0x72, 0xe9, 0xe5, 0x48, 0xe8, 0xdc, 0x80, 0x32, 0xa7, 0x29, 0x0b, 0xb0, 0x2f, 0xe3, + 0xe6, 0x16, 0x94, 0xc5, 0xda, 0x34, 0x8b, 0x5b, 0x0a, 0xa6, 0xad, 0xf1, 0xd1, 0x6f, 0xe7, 0x3c, + 0x94, 0x02, 0x86, 0x91, 0xc0, 0x3e, 0x12, 0xee, 0x6c, 0xdd, 0x6a, 0xda, 0x5e, 0x51, 0x0b, 0x36, + 0x85, 0xb3, 0x09, 0x55, 0x43, 0xb7, 0x8f, 0x34, 0x1f, 0xee, 0xdc, 0x31, 0x4c, 0x2d, 0x18, 0x05, + 0x23, 0x75, 0xda, 0x50, 0x8b, 0x62, 0xda, 0x45, 0xb1, 0xbf, 0x4f, 0x98, 0x48, 0x51, 0xec, 0x47, + 0x8c, 0xa6, 0x7d, 0x7f, 0x07, 0xf5, 0x48, 0x3c, 0xf0, 0x49, 0xe8, 0x16, 0xeb, 0x56, 0xb3, 0xe2, + 0xad, 0x68, 0xd4, 0x03, 0x0d, 0xba, 0x23, 0x31, 0xb7, 0x15, 0xa4, 0x13, 0x3a, 0xef, 0x83, 0x13, + 0xec, 0x22, 0x16, 0xe1, 0xd0, 0x67, 0x18, 0x85, 0xfe, 0x37, 0x29, 0x15, 0xc8, 0x2d, 0xd5, 0xad, + 0x66, 0xde, 0x5b, 0x34, 0x3b, 0x1e, 0x46, 0xe1, 0x17, 0x52, 0xee, 0xdc, 0x82, 0x8a, 0x09, 0x12, + 0x17, 0x48, 0xa4, 0xdc, 0x05, 0x45, 0x4a, 0x7d, 0x1a, 0x29, 0x3a, 0x17, 0xb6, 0x14, 0xce, 0x9b, + 0xef, 0x66, 0x56, 0xce, 0x55, 0xc8, 0x0b, 0x14, 0x71, 0xb7, 0x5c, 0xb7, 0x9a, 0xe5, 0xe9, 0xda, + 0x1e, 0x36, 0x44, 0xa2, 0x88, 0x7b, 0x0a, 0x2d, 0xdd, 0xe5, 0x7d, 0x1f, 0x71, 0x3f, 0xc4, 0x31, + 0x8e, 0x90, 0xc0, 0xa1, 0x8f, 0x22, 0xc9, 0x5f, 0x48, 0x38, 0xea, 0xc6, 0x38, 0x74, 0xe7, 0xeb, + 0x56, 0xb3, 0xe8, 0xad, 0xf0, 0xfe, 0x26, 0xbf, 0x39, 0xc4, 0x6c, 0x4a, 0xc8, 0x4d, 0x83, 0x68, + 0xfc, 0x6d, 0x81, 0xd3, 0x49, 0x04, 0x66, 0x09, 0x8a, 0x33, 0xc9, 0x7a, 0x01, 0xa0, 0xcf, 0x88, + 0x8c, 0x34, 0xe9, 0x61, 0x95, 0xb1, 0xb6, 0x57, 0x52, 0x92, 0x6d, 0xd2, 0xc3, 0xce, 0xff, 0x61, + 0x49, 0x50, 0x81, 0x62, 0x5f, 0x13, 0xe2, 0x73, 0xf2, 0x48, 0x67, 0x68, 0xde, 0xab, 0xaa, 0x8d, + 0x4f, 0x94, 0x7c, 0x8b, 0x3c, 0xc2, 0xce, 0x97, 0xb0, 0x1c, 0xd3, 0x60, 0x3c, 0x26, 0xdc, 0xb5, + 0xeb, 0x76, 0xb3, 0xbc, 0xf1, 0xbf, 0x69, 0xbe, 0xde, 0x95, 0xf8, 0x6c, 0x74, 0x3c, 0x27, 0x1e, + 0x17, 0x71, 0xe7, 0x3a, 0x9c, 0x4f, 0xf0, 0x81, 0xf0, 0xa7, 0x9c, 0xee, 0x9b, 0xa4, 0xae, 0x78, + 0x67, 0x25, 0x64, 0xe2, 0xbc, 0x4e, 0xd8, 0xf8, 0x7e, 0x0e, 0xe0, 0xf3, 0xee, 0xd7, 0x38, 0x78, + 0xb3, 0xea, 0xdc, 0x80, 0x39, 0x95, 0xb9, 0x94, 0xe9, 0xca, 0x7c, 0x8d, 0xc6, 0x10, 0x38, 0x5e, + 0xd1, 0xf6, 0x44, 0x45, 0xaf, 0x42, 0x99, 0xaa, 0x2b, 0x69, 0x40, 0x5e, 0x03, 0xb4, 0x48, 0x01, + 0x74, 0xb9, 0x16, 0x4e, 0x56, 0xae, 0x57, 0xe0, 0x3f, 0x47, 0x50, 0x33, 0xab, 0xa8, 0x39, 0x13, + 0x4f, 0xd2, 0xe2, 0x5c, 0x84, 0xf9, 0x3e, 0x1a, 0xc4, 0x14, 0x85, 0x3a, 0xa8, 0x73, 0x2a, 0xa8, + 0x65, 0x23, 0x53, 0x01, 0x3d, 0xdc, 0x77, 0x8a, 0x6f, 0xd4, 0x77, 0x2e, 0xc2, 0x7c, 0x40, 0x13, + 0x21, 0x93, 0x55, 0xf5, 0x92, 0x92, 0x72, 0xb5, 0x6c, 0x64, 0x93, 0xcd, 0x02, 0xc6, 0x9a, 0xc5, + 0x2d, 0xa8, 0x18, 0xa6, 0x4c, 0xdd, 0x95, 0x8f, 0xae, 0x3b, 0x1d, 0xe5, 0x61, 0xdd, 0xd1, 0xcc, + 0xca, 0xf9, 0x14, 0xaa, 0x0c, 0x87, 0x69, 0x12, 0xa2, 0x24, 0x18, 0xe8, 0x9b, 0xcc, 0x1f, 0xed, + 0x8f, 0x37, 0x82, 0x2a, 0x7f, 0x16, 0xd8, 0xa1, 0xf5, 0x78, 0x7b, 0xac, 0x9c, 0xba, 0x3d, 0xb6, + 0xa0, 0x14, 0xec, 0xe2, 0x60, 0x8f, 0xa7, 0x3d, 0xee, 0x2e, 0xd4, 0xed, 0xe6, 0x7c, 0x7b, 0xe9, + 0xaf, 0xe7, 0xab, 0x15, 0xc1, 0x10, 0x11, 0xfc, 0xa3, 0x06, 0xed, 0x11, 0xd1, 0xf0, 0x5e, 0x61, + 0x46, 0x6d, 0xa3, 0x7a, 0xaa, 0xb6, 0xb1, 0x0a, 0x65, 0xc2, 0xfd, 0xb4, 0x1f, 0x22, 0x41, 0x92, + 0xc8, 0x5d, 0x54, 0x3d, 0x02, 0x08, 0xbf, 0x6f, 0x24, 0xb2, 0xf8, 0xd5, 0xae, 0xec, 0x27, 0xc2, + 0x5d, 0xd2, 0xc5, 0x6f, 0x24, 0x9b, 0xc2, 0xf9, 0xe0, 0xd5, 0x76, 0x77, 0xe0, 0x3a, 0xc7, 0x64, + 0xff, 0x50, 0xb1, 0x3d, 0x70, 0x5c, 0x98, 0xdb, 0xc7, 0x8c, 0x13, 0x9a, 0xb8, 0x67, 0xd4, 0xa1, + 0xc3, 0x65, 0xe3, 0xc7, 0x1c, 0x94, 0x74, 0x06, 0xbe, 0x49, 0x2d, 0x5e, 0x00, 0xd0, 0xa9, 0x9d, + 0x19, 0x94, 0x25, 0x25, 0x51, 0x45, 0x33, 0x16, 0x17, 0xfb, 0xd4, 0x71, 0x39, 0xd5, 0x90, 0x5c, + 0x86, 0x02, 0x3e, 0x10, 0x0c, 0xe9, 0x2a, 0xf5, 0xf4, 0x62, 0x14, 0xa9, 0xd9, 0xd3, 0x44, 0xaa, + 0x71, 0x1d, 0x0a, 0xdb, 0x32, 0xf6, 0xd2, 0x43, 0x95, 0x04, 0xda, 0x03, 0x4b, 0x7b, 0xa8, 0x24, + 0xea, 0x82, 0xcb, 0x50, 0xd8, 0x47, 0x71, 0x3a, 0xf4, 0x5d, 0x2f, 0x1a, 0xbf, 0x59, 0xb0, 0xa0, + 0x5b, 0xfa, 0x3d, 0x2c, 0xd0, 0x4d, 0x24, 0x90, 0x53, 0x87, 0x72, 0x88, 0x79, 0xc0, 0x48, 0x5f, + 0xc8, 0x28, 0xe8, 0x83, 0xb2, 0x22, 0x59, 0x98, 0xf8, 0x40, 0x8f, 0x03, 0x3f, 0x65, 0xb1, 0x39, + 0xb1, 0x3c, 0x94, 0xdd, 0x67, 0xf1, 0xf1, 0x6d, 0x6c, 0x19, 0x0a, 0xa4, 0x87, 0xa2, 0x61, 0x03, + 0xd3, 0x0b, 0xe7, 0x06, 0x00, 0x12, 0x82, 0x91, 0x6e, 0x2a, 0x30, 0x77, 0x0b, 0xaa, 0xfb, 0x9f, + 0x9b, 0x46, 0x84, 0x72, 0xb9, 0x9d, 0x97, 0x44, 0x7b, 0x19, 0x15, 0xe5, 0x8f, 0xae, 0xe5, 0xb7, + 0xee, 0x4f, 0xb6, 0xeb, 0xda, 0x13, 0x5d, 0xf7, 0x1d, 0xf9, 0xf3, 0xab, 0x05, 0x15, 0x95, 0xf4, + 0x6f, 0xd7, 0x9d, 0xc3, 0xd5, 0x60, 0x8f, 0x57, 0xc3, 0x3b, 0x72, 0x66, 0x03, 0xec, 0x4e, 0xc8, + 0x4d, 0xa9, 0x58, 0x75, 0xfb, 0x04, 0xa5, 0xd2, 0xf8, 0xc5, 0x02, 0x90, 0xcf, 0x12, 0x81, 0x55, + 0xd9, 0x5f, 0x03, 0x93, 0x44, 0x3e, 0x09, 0xb9, 0x72, 0xbe, 0xbc, 0x71, 0x76, 0xda, 0x1d, 0x3a, + 0x21, 0xf7, 0x4a, 0x1a, 0x2a, 0x6d, 0x5e, 0x03, 0x13, 0x2c, 0xa5, 0x97, 0x3b, 0x46, 0x4f, 0x43, + 0xa5, 0xde, 0x55, 0x28, 0x0d, 0x27, 0x22, 0x57, 0x3c, 0xbd, 0x46, 0xad, 0x18, 0xe9, 0xf9, 0xc8, + 0x1b, 0xcf, 0x2c, 0x38, 0x73, 0x8f, 0x44, 0x0c, 0xc9, 0x78, 0x64, 0x5e, 0x4c, 0x2b, 0x50, 0xe2, + 0x2c, 0xf0, 0xb9, 0x1a, 0xb0, 0x96, 0x1a, 0xb0, 0x73, 0x9c, 0x05, 0x5b, 0x72, 0xa8, 0x76, 0xa0, + 0x21, 0xf7, 0x8e, 0x79, 0x9b, 0xe6, 0x94, 0xd2, 0x05, 0xce, 0x82, 0x3b, 0x47, 0x3f, 0x4f, 0x57, + 0xa0, 0x14, 0x72, 0x61, 0xcc, 0xd8, 0xda, 0x4c, 0xc8, 0x85, 0x32, 0xf3, 0x21, 0x94, 0x46, 0x04, + 0x9e, 0xa4, 0x5d, 0x15, 0x87, 0x1c, 0x36, 0xbe, 0x85, 0xf9, 0x6c, 0xfb, 0x71, 0x3e, 0x36, 0xed, + 0xca, 0x52, 0x89, 0xf0, 0xdf, 0xe3, 0xda, 0xd5, 0xfa, 0x36, 0x8a, 0x4c, 0x4e, 0x28, 0xbd, 0x95, + 0x35, 0xb0, 0xb7, 0x51, 0xe4, 0x2c, 0x82, 0xbd, 0x87, 0x07, 0x26, 0x8f, 0xe5, 0xcf, 0x23, 0x3a, + 0xd5, 0xcf, 0x39, 0x58, 0xdc, 0xda, 0x45, 0x21, 0x7d, 0x98, 0x79, 0x91, 0x5d, 0x85, 0x22, 0xed, + 0x63, 0xa6, 0x9e, 0x58, 0xc7, 0x0d, 0x82, 0x11, 0xd2, 0x24, 0x60, 0xee, 0x64, 0xbd, 0x7a, 0xfc, + 0x15, 0x62, 0x4f, 0xbe, 0x42, 0xc6, 0xdf, 0x43, 0xf9, 0xc9, 0xf7, 0xd0, 0xa1, 0xb1, 0x5d, 0x38, + 0xc1, 0xd8, 0x3e, 0x3c, 0x5f, 0x67, 0xc7, 0xe7, 0x6b, 0x66, 0x4c, 0xce, 0x1d, 0x1e, 0x93, 0xdf, + 0xe5, 0xa0, 0xaa, 0x53, 0xee, 0x96, 0x9c, 0x2a, 0x8a, 0xa6, 0x4b, 0x50, 0x25, 0xdc, 0x67, 0xf2, + 0x9d, 0x14, 0x93, 0x1e, 0x11, 0x58, 0x67, 0x5f, 0xd1, 0xab, 0x10, 0xee, 0x21, 0x81, 0xef, 0x6a, + 0xa1, 0x13, 0x42, 0x55, 0x7e, 0xe4, 0x66, 0x90, 0x86, 0xa5, 0xeb, 0x86, 0xa5, 0x4b, 0x11, 0x11, + 0xbb, 0x69, 0x77, 0x3d, 0xa0, 0x3d, 0xf3, 0x25, 0x6d, 0xfe, 0xac, 0xf1, 0x70, 0xcf, 0x7c, 0xa9, + 0x77, 0x14, 0x8f, 0x60, 0x78, 0xec, 0x24, 0xc2, 0xab, 0xc8, 0x43, 0x47, 0x76, 0x9c, 0x5d, 0x58, + 0x0a, 0x52, 0xc6, 0x24, 0xa3, 0x23, 0x6b, 0x9a, 0xd6, 0x7f, 0x69, 0xa7, 0x6a, 0x8e, 0xbd, 0x6d, + 0xcc, 0xb5, 0x3b, 0x4f, 0x5e, 0xd4, 0xac, 0xa7, 0x2f, 0x6a, 0xd6, 0x9f, 0x2f, 0x6a, 0xd6, 0x0f, + 0x2f, 0x6b, 0x33, 0x4f, 0x5f, 0xd6, 0x66, 0x7e, 0x7f, 0x59, 0x9b, 0xf9, 0xaa, 0x95, 0x31, 0xd0, + 0x4d, 0xba, 0x6b, 0xc1, 0x2e, 0x22, 0x49, 0x2b, 0xf3, 0xb5, 0x7e, 0x70, 0xf8, 0xff, 0x0f, 0xdd, + 0x59, 0xf5, 0xbd, 0x7e, 0xe5, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xaa, 0x6e, 0xef, 0x57, 0xa2, + 0x10, 0x00, 0x00, } func (m *BucketInfo) Marshal() (dAtA []byte, err error) { @@ -2186,6 +2240,59 @@ func (m *ShadowObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *BucketExtraInfo) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BucketExtraInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BucketExtraInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.CurrentFlowRate.Size() + i -= size + if _, err := m.CurrentFlowRate.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size := m.FlowRateLimit.Size() + i -= size + if _, err := m.FlowRateLimit.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTypes(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if m.IsRateLimited { + i-- + if m.IsRateLimited { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { offset -= sovTypes(v) base := offset @@ -2606,6 +2713,22 @@ func (m *ShadowObjectInfo) Size() (n int) { return n } +func (m *BucketExtraInfo) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IsRateLimited { + n += 2 + } + l = m.FlowRateLimit.Size() + n += 1 + l + sovTypes(uint64(l)) + l = m.CurrentFlowRate.Size() + n += 1 + l + sovTypes(uint64(l)) + return n +} + func sovTypes(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -5443,6 +5566,144 @@ func (m *ShadowObjectInfo) Unmarshal(dAtA []byte) error { } return nil } +func (m *BucketExtraInfo) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BucketExtraInfo: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BucketExtraInfo: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsRateLimited", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsRateLimited = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FlowRateLimit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.FlowRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentFlowRate", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CurrentFlowRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTypes(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTypes + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTypes(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0