diff --git a/app/upgrade.go b/app/upgrade.go index 92c104c5f..cc1dc0bf2 100644 --- a/app/upgrade.go +++ b/app/upgrade.go @@ -223,6 +223,10 @@ func (app *App) registerSerengetiUpgradeHandler() { func(ctx sdk.Context, plan upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) { app.Logger().Info("upgrade to ", plan.Name) app.VirtualgroupKeeper.MigrateGlobalVirtualGroupFamiliesForSP(ctx) + app.GashubKeeper.SetMsgGasParams(ctx, *gashubtypes.NewMsgGasParamsWithFixedGas(sdk.MsgTypeURL(&storagemoduletypes.MsgToggleSPAsDelegatedAgent{}), 1.2e3)) + 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)) return app.mm.RunMigrations(ctx, app.configurator, fromVM) }) diff --git a/e2e/tests/permission_test.go b/e2e/tests/permission_test.go index 4f2a3f7d2..e6b6f5a07 100644 --- a/e2e/tests/permission_test.go +++ b/e2e/tests/permission_test.go @@ -1115,7 +1115,8 @@ func (s *StorageTestSuite) TestStalePermissionForAccountGC() { // bucket and object dont exist after deletion headObjectReq := storagetypes.QueryHeadObjectRequest{ - BucketName: objectName, + BucketName: bucketName, + ObjectName: objectName, } _, err = s.Client.HeadObject(ctx, &headObjectReq) s.Require().Error(err) @@ -1331,7 +1332,8 @@ func (s *StorageTestSuite) TestStalePermissionForGroupGC() { // bucket and object dont exist after deletion headObjectReq := storagetypes.QueryHeadObjectRequest{ - BucketName: objectName, + BucketName: bucketName, + ObjectName: objectName, } _, err = s.Client.HeadObject(ctx, &headObjectReq) s.Require().Error(err) diff --git a/e2e/tests/storage_test.go b/e2e/tests/storage_test.go index 02dff6ec9..46d6c6e9d 100644 --- a/e2e/tests/storage_test.go +++ b/e2e/tests/storage_test.go @@ -2407,3 +2407,158 @@ func (s *StorageTestSuite) TestDeleteCreateObject_InCreatedStatus() { _, err = s.Client.HeadObject(ctx, &queryHeadObjectRequest) s.Require().EqualError(err, "rpc error: code = Unknown desc = No such object: unknown request") } + +func (s *StorageTestSuite) TestToggleBucketSpAsDelegatedAgents() { + var err error + // CreateBucket + sp := s.BaseSuite.PickStorageProvider() + gvg, found := sp.GetFirstGlobalVirtualGroup() + s.Require().True(found) + user := s.GenAndChargeAccounts(1, 1000000)[0] + bucketName := storageutils.GenRandomBucketName() + msgCreateBucket := storagetypes.NewMsgCreateBucket( + user.GetAddr(), bucketName, storagetypes.VISIBILITY_TYPE_PRIVATE, sp.OperatorKey.GetAddr(), + nil, 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) + + queryHeadBucketRequest := storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + ctx := context.Background() + queryHeadBucketResponse, err := s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + s.Require().Equal(false, queryHeadBucketResponse.BucketInfo.SpAsDelegatedAgentDisabled) + + MsgToggleSPAsDelegatedAgent := storagetypes.NewMsgToggleSPAsDelegatedAgent( + user.GetAddr(), + bucketName) + s.SendTxBlock(user, MsgToggleSPAsDelegatedAgent) + + // HeadBucket + queryHeadBucketResponse, err = s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + s.Require().Equal(true, queryHeadBucketResponse.BucketInfo.SpAsDelegatedAgentDisabled) +} + +func (s *StorageTestSuite) TestCreateObjectByDelegatedAgents() { + var err error + ctx := context.Background() + + // CreateBucket + sp := s.BaseSuite.PickStorageProvider() + gvg, found := sp.GetFirstGlobalVirtualGroup() + s.Require().True(found) + + bucketOwner := s.GenAndChargeAccounts(1, 1000000)[0] + bucketName := storageutils.GenRandomBucketName() + objectName := storageutils.GenRandomObjectName() + + msgCreateBucket := storagetypes.NewMsgCreateBucket( + bucketOwner.GetAddr(), bucketName, storagetypes.VISIBILITY_TYPE_PRIVATE, sp.OperatorKey.GetAddr(), + nil, math.MaxUint, nil, 0) + msgCreateBucket.PrimarySpApproval.GlobalVirtualGroupFamilyId = gvg.FamilyId + msgCreateBucket.PrimarySpApproval.Sig, err = sp.ApprovalKey.Sign(msgCreateBucket.GetApprovalBytes()) + s.Require().NoError(err) + + s.SendTxBlock(bucketOwner, msgCreateBucket) + + // HeadBucket + queryHeadBucketRequest := storagetypes.QueryHeadBucketRequest{ + BucketName: bucketName, + } + queryHeadBucketResponse, err := s.Client.HeadBucket(ctx, &queryHeadBucketRequest) + s.Require().NoError(err) + s.Require().Equal(false, queryHeadBucketResponse.BucketInfo.SpAsDelegatedAgentDisabled) + + // DelegateCreate for user2, who does not have permission + 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() + contextType := "text/event-stream" + msgDelegateCreateObject := storagetypes.NewMsgDelegateCreateObject( + sp.OperatorKey.GetAddr(), + bucketOwner.GetAddr(), + bucketName, + objectName, + uint64(payloadSize), + storagetypes.VISIBILITY_TYPE_PRIVATE, + nil, + contextType, + storagetypes.REDUNDANCY_EC_TYPE) + s.SendTxBlock(sp.OperatorKey, msgDelegateCreateObject) + + headObjectReq := storagetypes.QueryHeadObjectRequest{ + BucketName: bucketName, + ObjectName: objectName, + } + headObjectResp, err := s.Client.HeadObject(ctx, &headObjectReq) + s.Require().NoError(err) + s.Require().Equal(objectName, headObjectResp.ObjectInfo.ObjectName) + s.Require().Equal(bucketOwner.GetAddr().String(), headObjectResp.ObjectInfo.Owner) + s.Require().Equal(0, len(headObjectResp.ObjectInfo.Checksums)) + + // SP seal object, and update the object checksum + checksum := sdk.Keccak256(buffer.Bytes()) + expectChecksum := [][]byte{checksum, checksum, checksum, checksum, checksum, checksum, checksum} + + gvgId := gvg.Id + msgSealObject := storagetypes.NewMsgSealObjectV2(sp.SealKey.GetAddr(), bucketName, objectName, gvg.Id, nil, expectChecksum) + secondarySigs := make([][]byte, 0) + secondarySPBlsPubKeys := make([]bls.PublicKey, 0) + blsSignHash := storagetypes.NewSecondarySpSealObjectSignDoc(s.GetChainID(), gvgId, headObjectResp.ObjectInfo.Id, storagetypes.GenerateHash(expectChecksum[:])).GetBlsSignHash() + // every secondary sp signs the checksums + for _, spID := range gvg.SecondarySpIds { + sig, err := core.BlsSignAndVerify(s.StorageProviders[spID], blsSignHash) + s.Require().NoError(err) + secondarySigs = append(secondarySigs, sig) + pk, err := bls.PublicKeyFromBytes(s.StorageProviders[spID].BlsKey.PubKey().Bytes()) + s.Require().NoError(err) + secondarySPBlsPubKeys = append(secondarySPBlsPubKeys, pk) + } + aggBlsSig, err := core.BlsAggregateAndVerify(secondarySPBlsPubKeys, blsSignHash, secondarySigs) + s.Require().NoError(err) + msgSealObject.SecondarySpBlsAggSignatures = aggBlsSig + s.T().Logf("msg %s", msgSealObject.String()) + s.SendTxBlock(sp.SealKey, msgSealObject) + + headObjectResp, err = s.Client.HeadObject(ctx, &headObjectReq) + s.Require().NoError(err) + s.Require().Equal(objectName, headObjectResp.ObjectInfo.ObjectName) + s.Require().Equal(bucketOwner.GetAddr().String(), headObjectResp.ObjectInfo.Owner) + s.Require().Equal(expectChecksum, headObjectResp.ObjectInfo.Checksums) + + // delegate update + var newBuffer bytes.Buffer + for i := 0; i < 2048; i++ { + newBuffer.WriteString(fmt.Sprintf("[%05d] %s\n", i, line)) + } + newPayloadSize := uint64(newBuffer.Len()) + newChecksum := sdk.Keccak256(newBuffer.Bytes()) + newExpectChecksum := [][]byte{newChecksum, newChecksum, newChecksum, newChecksum, newChecksum, newChecksum, newChecksum} + + msgUpdateObject := storagetypes.NewMsgDelegateUpdateObjectContent(sp.OperatorKey.GetAddr(), + bucketOwner.GetAddr(), bucketName, objectName, newPayloadSize, nil) + s.SendTxBlock(sp.OperatorKey, msgUpdateObject) + s.T().Logf("msgUpdateObject %s", msgUpdateObject.String()) + + // every secondary sp signs the checksums + newSecondarySigs := make([][]byte, 0) + newBlsSignHash := storagetypes.NewSecondarySpSealObjectSignDoc(s.GetChainID(), gvgId, headObjectResp.ObjectInfo.Id, storagetypes.GenerateHash(newExpectChecksum[:])).GetBlsSignHash() + for _, spID := range gvg.SecondarySpIds { + sig, err := core.BlsSignAndVerify(s.StorageProviders[spID], newBlsSignHash) + s.Require().NoError(err) + newSecondarySigs = append(newSecondarySigs, sig) + } + aggBlsSig, err = core.BlsAggregateAndVerify(secondarySPBlsPubKeys, newBlsSignHash, newSecondarySigs) + s.Require().NoError(err) + msgSealObject = storagetypes.NewMsgSealObjectV2(sp.SealKey.GetAddr(), bucketName, objectName, gvg.Id, nil, newExpectChecksum) + msgSealObject.SecondarySpBlsAggSignatures = aggBlsSig + s.T().Logf("msgSealObject %s", msgSealObject.String()) + s.SendTxBlock(sp.SealKey, msgSealObject) +} diff --git a/e2e/tests/virtualgroup_test.go b/e2e/tests/virtualgroup_test.go index ef99e0508..7ef9340ea 100644 --- a/e2e/tests/virtualgroup_test.go +++ b/e2e/tests/virtualgroup_test.go @@ -133,7 +133,7 @@ func (s *VirtualGroupTestSuite) TestBasic() { availableGvgFamilyIds := s.queryAvailableGlobalVirtualGroupFamilies([]uint32{gvg.FamilyId}) s.Require().Equal(availableGvgFamilyIds[0], gvg.FamilyId) spAvailableGvgFamilyIds := s.querySpAvailableGlobalVirtualGroupFamilies(primarySP.Info.Id) - s.Require().Equal(spAvailableGvgFamilyIds[0], gvg.FamilyId) + s.Require().Contains(spAvailableGvgFamilyIds, gvg.FamilyId) spOptimalGvgFamilyId := s.querySpOptimalGlobalVirtualGroupFamily(primarySP.Info.Id, virtualgroupmoduletypes.Strategy_Maximize_Free_Store_Size) s.Require().Equal(spOptimalGvgFamilyId, gvg.FamilyId) diff --git a/proto/greenfield/storage/events.proto b/proto/greenfield/storage/events.proto index 306744127..58e8b1562 100644 --- a/proto/greenfield/storage/events.proto +++ b/proto/greenfield/storage/events.proto @@ -178,6 +178,10 @@ message EventSealObject { uint32 global_virtual_group_id = 7; // local_virtual_group_id defines the unique id of lvg which the object stored uint32 local_virtual_group_id = 8; + // checksums define the total checksums of the object which generated by redundancy + // SP might set the checksum of object if it was delegated created by SP, which checksum + // will not be available until sealing object. + repeated bytes checksums = 9; } // EventCopyObject is emitted on MsgCopyObject diff --git a/proto/greenfield/storage/tx.proto b/proto/greenfield/storage/tx.proto index ade3e22c6..7c27c9a72 100644 --- a/proto/greenfield/storage/tx.proto +++ b/proto/greenfield/storage/tx.proto @@ -23,10 +23,12 @@ service Msg { rpc UpdateBucketInfo(MsgUpdateBucketInfo) returns (MsgUpdateBucketInfoResponse); rpc MirrorBucket(MsgMirrorBucket) returns (MsgMirrorBucketResponse); rpc DiscontinueBucket(MsgDiscontinueBucket) returns (MsgDiscontinueBucketResponse); + rpc ToggleSPAsDelegatedAgent(MsgToggleSPAsDelegatedAgent) returns (MsgToggleSPAsDelegatedAgentResponse); // basic operation of object rpc CreateObject(MsgCreateObject) returns (MsgCreateObjectResponse); rpc SealObject(MsgSealObject) returns (MsgSealObjectResponse); + rpc SealObjectV2(MsgSealObjectV2) returns (MsgSealObjectV2Response); rpc RejectSealObject(MsgRejectSealObject) returns (MsgRejectSealObjectResponse); rpc CopyObject(MsgCopyObject) returns (MsgCopyObjectResponse); rpc DeleteObject(MsgDeleteObject) returns (MsgDeleteObjectResponse); @@ -36,6 +38,8 @@ service Msg { rpc UpdateObjectInfo(MsgUpdateObjectInfo) returns (MsgUpdateObjectInfoResponse); rpc UpdateObjectContent(MsgUpdateObjectContent) returns (MsgUpdateObjectContentResponse); rpc CancelUpdateObjectContent(MsgCancelUpdateObjectContent) returns (MsgCancelUpdateObjectContentResponse); + rpc DelegateCreateObject(MsgDelegateCreateObject) returns (MsgDelegateCreateObjectResponse); + rpc DelegateUpdateObjectContent(MsgDelegateUpdateObjectContent) returns (MsgDelegateUpdateObjectContentResponse); // basic operation of group rpc CreateGroup(MsgCreateGroup) returns (MsgCreateGroupResponse); @@ -190,6 +194,33 @@ message MsgSealObject { message MsgSealObjectResponse {} +message MsgSealObjectV2 { + option (cosmos.msg.v1.signer) = "operator"; + + // operator defines the account address of primary SP + string operator = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // bucket_name defines the name of the bucket where the object is stored. + string bucket_name = 2; + + // object_name defines the name of object to be sealed. + string object_name = 3; + + // global_virtual_group_id defines the id of global virtual group + uint32 global_virtual_group_id = 4; + + // secondary_sp_bls_agg_signatures defines the aggregate bls signature of the secondary sp that can + // acknowledge that the payload data has received and stored. + bytes secondary_sp_bls_agg_signatures = 5; + + // (optional) checksums define the total checksums of the object which generated by redundancy + // SP might set the checksum of object if it was delegated created by SP, which checksum + // will not be available until sealing object. + repeated bytes expect_checksums = 6; +} + +message MsgSealObjectV2Response {} + message MsgRejectSealObject { option (cosmos.msg.v1.signer) = "operator"; @@ -679,3 +710,65 @@ message MsgCancelUpdateObjectContent { } message MsgCancelUpdateObjectContentResponse {} + +message MsgDelegateCreateObject { + option (cosmos.msg.v1.signer) = "operator"; + // operator defines the account address of the operator, it is the delegated agent that allows to creat object under bucket. + string operator = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // creator defines the account address of the object creator. + string creator = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // bucket_name defines the name of the bucket where the object is stored. + string bucket_name = 3; + // object_name defines the name of object + string object_name = 4; + // payload_size defines size of the object's payload + uint64 payload_size = 5; + // content_type define the format of the object which should be a standard MIME type. + string content_type = 6; + // visibility means the object is private or public. if private, only object owner or grantee can access it, + // otherwise every greenfield user can access it. + VisibilityType visibility = 7; + // expect_checksums defines a list of hashes which was generate by redundancy algorithm. + repeated bytes expect_checksums = 8; + // redundancy_type can be ec or replica + RedundancyType redundancy_type = 9; +} + +message MsgDelegateCreateObjectResponse { + string object_id = 1 [ + (cosmos_proto.scalar) = "cosmos.Uint", + (gogoproto.customtype) = "Uint", + (gogoproto.nullable) = false + ]; +} + +message MsgDelegateUpdateObjectContent { + option (cosmos.msg.v1.signer) = "operator"; + // operator defines the account address of the operator, it is the delegated agent that allows to creat object under bucket. + string operator = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // updater defines the account address of the object updater. + string updater = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // bucket_name defines the name of the bucket where the object is stored. + string bucket_name = 3; + // object_name defines the name of object + string object_name = 4; + // payload_size defines size of the object's payload + uint64 payload_size = 5; + // content_type define the format of the object which should be a standard MIME type. + string content_type = 6; + // expect_checksums defines a list of hashes which was generate by redundancy algorithm. + repeated bytes expect_checksums = 7; +} + +message MsgDelegateUpdateObjectContentResponse {} + +message MsgToggleSPAsDelegatedAgent { + option (cosmos.msg.v1.signer) = "operator"; + + // operator defines the account address of the operator, only the bucket owner can send the tx. + string operator = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + // bucket_name defines the name of the bucket. + string bucket_name = 2; +} + +message MsgToggleSPAsDelegatedAgentResponse {} diff --git a/proto/greenfield/storage/types.proto b/proto/greenfield/storage/types.proto index 17b248a80..ecd89b8ef 100644 --- a/proto/greenfield/storage/types.proto +++ b/proto/greenfield/storage/types.proto @@ -39,6 +39,9 @@ message BucketInfo { BucketStatus bucket_status = 10; // tags defines a list of tags the bucket has ResourceTags tags = 11; + // sp_as_delegated_agent_disabled indicates that whether bucket owner disable SP as the upload agent. + // when a bucket is created, by default, this is false, means SP is allowed to create object for delegator + bool sp_as_delegated_agent_disabled = 12; } message InternalBucketInfo { diff --git a/swagger/static/swagger.yaml b/swagger/static/swagger.yaml index b0870d8cf..84a8065d7 100644 --- a/swagger/static/swagger.yaml +++ b/swagger/static/swagger.yaml @@ -2624,6 +2624,14 @@ paths: value: type: string title: tags defines a list of tags the resource has + sp_as_delegated_agent_disabled: + type: boolean + title: >- + sp_as_delegated_agent_disabled indicates that whether + bucket owner disable SP as the upload agent. + + when a bucket is created, by default, this is false, means + SP is allowed to create object for delegator default: description: An unexpected error response. schema: @@ -2748,6 +2756,14 @@ paths: value: type: string title: tags defines a list of tags the resource has + sp_as_delegated_agent_disabled: + type: boolean + title: >- + sp_as_delegated_agent_disabled indicates that whether + bucket owner disable SP as the upload agent. + + when a bucket is created, by default, this is false, means + SP is allowed to create object for delegator default: description: An unexpected error response. schema: @@ -3894,6 +3910,14 @@ paths: value: type: string title: tags defines a list of tags the resource has + sp_as_delegated_agent_disabled: + type: boolean + title: >- + sp_as_delegated_agent_disabled indicates that whether + bucket owner disable SP as the upload agent. + + when a bucket is created, by default, this is false, + means SP is allowed to create object for delegator pagination: type: object properties: @@ -34869,6 +34893,14 @@ definitions: value: type: string title: tags defines a list of tags the resource has + sp_as_delegated_agent_disabled: + type: boolean + title: >- + sp_as_delegated_agent_disabled indicates that whether bucket owner + disable SP as the upload agent. + + when a bucket is created, by default, this is false, means SP is + allowed to create object for delegator greenfield.storage.BucketMetaData: type: object properties: @@ -35565,6 +35597,14 @@ definitions: value: type: string title: tags defines a list of tags the resource has + sp_as_delegated_agent_disabled: + type: boolean + title: >- + sp_as_delegated_agent_disabled indicates that whether bucket owner + disable SP as the upload agent. + + when a bucket is created, by default, this is false, means SP is + allowed to create object for delegator greenfield.storage.QueryHeadGroupMemberResponse: type: object properties: @@ -35942,6 +35982,14 @@ definitions: value: type: string title: tags defines a list of tags the resource has + sp_as_delegated_agent_disabled: + type: boolean + title: >- + sp_as_delegated_agent_disabled indicates that whether bucket + owner disable SP as the upload agent. + + when a bucket is created, by default, this is false, means SP is + allowed to create object for delegator pagination: type: object properties: diff --git a/x/storage/keeper/keeper.go b/x/storage/keeper/keeper.go index fc8bfde4a..ecf19e647 100644 --- a/x/storage/keeper/keeper.go +++ b/x/storage/keeper/keeper.go @@ -576,20 +576,30 @@ func (k Keeper) CreateObject( // primary sp sp := k.MustGetPrimarySPForBucket(ctx, bucketInfo) + creator := operator + if opts.Delegated { + creator = opts.Creator + if bucketInfo.SpAsDelegatedAgentDisabled { + return sdkmath.ZeroUint(), types.ErrAccessDenied.Wrap("the SP is not allowed to create object for delegator, disabled by the bucket owner previously") + } + if operator.String() != sp.OperatorAddress { + return sdkmath.ZeroUint(), types.ErrAccessDenied.Wrap("only the primary SP is allowed to create object for delegator") + } + } // verify permission verifyOpts := &permtypes.VerifyOptions{ WantedSize: &payloadSize, } - effect := k.VerifyBucketPermission(ctx, bucketInfo, operator, permtypes.ACTION_CREATE_OBJECT, verifyOpts) + effect := k.VerifyBucketPermission(ctx, bucketInfo, creator, permtypes.ACTION_CREATE_OBJECT, verifyOpts) if effect != permtypes.EFFECT_ALLOW { - return sdkmath.ZeroUint(), types.ErrAccessDenied.Wrapf("The operator(%s) has no CreateObject permission of the bucket(%s)", + return sdkmath.ZeroUint(), types.ErrAccessDenied.Wrapf("The creator(%s) has no CreateObject permission of the bucket(%s)", operator.String(), bucketName) } - var creator sdk.AccAddress - if !operator.Equals(sdk.MustAccAddressFromHex(bucketInfo.Owner)) { - creator = operator + objectInfoCreator := creator + if objectInfoCreator.Equals(sdk.MustAccAddressFromHex(bucketInfo.Owner)) { + objectInfoCreator = sdk.AccAddress{} } if !ctx.IsUpgraded(upgradetypes.Serengeti) { @@ -624,7 +634,7 @@ func (k Keeper) CreateObject( // construct objectInfo objectInfo := types.ObjectInfo{ Owner: bucketInfo.Owner, - Creator: creator.String(), + Creator: objectInfoCreator.String(), BucketName: bucketName, ObjectName: objectName, PayloadSize: payloadSize, @@ -659,7 +669,7 @@ func (k Keeper) CreateObject( store.Set(types.GetObjectByIDKey(objectInfo.Id), obz) if err = ctx.EventManager().EmitTypedEvents(&types.EventCreateObject{ - Creator: operator.String(), + Creator: creator.String(), Owner: objectInfo.Owner, BucketName: bucketInfo.BucketName, ObjectName: objectInfo.ObjectName, @@ -766,6 +776,7 @@ func (k Keeper) MustGetShadowObjectInfo(ctx sdk.Context, bucketName, objectName type SealObjectOptions struct { GlobalVirtualGroupId uint32 SecondarySpBlsSignatures []byte + Checksums [][]byte } func (k Keeper) SealObject( @@ -792,6 +803,13 @@ func (k Keeper) SealObject( if !found { return types.ErrNoSuchObject } + + if objectInfo.Checksums == nil { + if opts.Checksums == nil { + return types.ErrObjectChecksumsMissing + } + objectInfo.Checksums = opts.Checksums + } store := ctx.KVStore(k.storeKey) prevPayloadSize := objectInfo.PayloadSize @@ -813,6 +831,12 @@ func (k Keeper) SealObject( shadowObjectInfo := k.MustGetShadowObjectInfo(ctx, bucketName, objectName) objectInfo.UpdatedAt = shadowObjectInfo.UpdatedAt // the updated_at in objetInfo will not be visible until the object is sealed. objectInfo.Version = shadowObjectInfo.Version + if shadowObjectInfo.Checksums == nil { + if opts.Checksums == nil { + return types.ErrObjectChecksumsMissing + } + shadowObjectInfo.Checksums = opts.Checksums + } objectInfo.Checksums = shadowObjectInfo.Checksums objectInfo.PayloadSize = shadowObjectInfo.PayloadSize objectInfo.UpdatedBy = shadowObjectInfo.Operator @@ -882,6 +906,7 @@ func (k Keeper) SealObject( Status: objectInfo.ObjectStatus, GlobalVirtualGroupId: opts.GlobalVirtualGroupId, LocalVirtualGroupId: objectInfo.LocalVirtualGroupId, + Checksums: objectInfo.Checksums, }); err != nil { return err } @@ -2455,11 +2480,17 @@ func (k Keeper) UpdateObjectContent( return types.ErrObjectIsUpdating.Wrapf("The object is already being updated") } // check permission - effect := k.VerifyObjectPermission(ctx, bucketInfo, objectInfo, operator, permtypes.ACTION_UPDATE_OBJECT_CONTENT) + var updater sdk.AccAddress + if opts.Delegated { + updater = opts.Updater + } else { + updater = operator + } + effect := k.VerifyObjectPermission(ctx, bucketInfo, objectInfo, updater, permtypes.ACTION_UPDATE_OBJECT_CONTENT) if effect != permtypes.EFFECT_ALLOW { return types.ErrAccessDenied.Wrapf( - "The operator(%s) has no updateObjectContent permission of the bucket(%s), object(%s)", - operator.String(), bucketName, objectName) + "The updater(%s) has no updateObjectContent permission of the bucket(%s), object(%s)", + updater.String(), bucketName, objectName) } // check payload size @@ -2473,7 +2504,14 @@ func (k Keeper) UpdateObjectContent( if sp.Status != sptypes.STATUS_IN_SERVICE && !k.fromSpMaintenanceAcct(sp, operator) { return errors.Wrap(types.ErrNoSuchStorageProvider, "the storage provider is not in service") } - + if opts.Delegated { + if bucketInfo.SpAsDelegatedAgentDisabled { + return types.ErrAccessDenied.Wrap("the SP is not allowed to create object for delegator, disabled by the bucket owner previously") + } + if operator.String() != sp.OperatorAddress { + return types.ErrAccessDenied.Wrap("only the primary SP is allowed to create object for delegator") + } + } nextVersion := objectInfo.Version + 1 if payloadSize == 0 { @@ -2487,12 +2525,11 @@ func (k Keeper) UpdateObjectContent( if err != nil { return err } - objectInfo.UpdatedAt = ctx.BlockTime().Unix() objectInfo.Version = nextVersion objectInfo.PayloadSize = 0 objectInfo.Checksums = opts.Checksums - objectInfo.UpdatedBy = operator.String() + objectInfo.UpdatedBy = updater.String() objectInfo.ContentType = opts.ContentType _, err = k.SealEmptyObjectOnVirtualGroup(ctx, bucketInfo, objectInfo) @@ -2502,7 +2539,7 @@ func (k Keeper) UpdateObjectContent( } else { objectInfo.IsUpdating = true shadowObjectInfo := &types.ShadowObjectInfo{ - Operator: operator.String(), + Operator: updater.String(), Id: objectInfo.Id, PayloadSize: payloadSize, Checksums: opts.Checksums, @@ -2522,7 +2559,7 @@ func (k Keeper) UpdateObjectContent( store.Set(types.GetObjectByIDKey(objectInfo.Id), obz) if err = ctx.EventManager().EmitTypedEvents(&types.EventUpdateObjectContent{ - Operator: operator.String(), + Operator: updater.String(), ObjectId: objectInfo.Id, PayloadSize: payloadSize, Checksums: opts.Checksums, diff --git a/x/storage/keeper/msg_server.go b/x/storage/keeper/msg_server.go index 2ddcfa17f..c9c39808c 100644 --- a/x/storage/keeper/msg_server.go +++ b/x/storage/keeper/msg_server.go @@ -102,6 +102,21 @@ func (k msgServer) DiscontinueBucket(goCtx context.Context, msg *storagetypes.Ms return &types.MsgDiscontinueBucketResponse{}, nil } +func (k msgServer) ToggleSPAsDelegatedAgent(goCtx context.Context, msg *storagetypes.MsgToggleSPAsDelegatedAgent) (*storagetypes.MsgToggleSPAsDelegatedAgentResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + bucketInfo, found := k.GetBucketInfo(ctx, msg.BucketName) + if !found { + return nil, types.ErrNoSuchBucket + } + if msg.Operator != bucketInfo.Owner { + return nil, types.ErrAccessDenied.Wrapf("Only the bucket owner(%s) can toggle", bucketInfo.Owner) + } + bucketInfo.SpAsDelegatedAgentDisabled = !bucketInfo.SpAsDelegatedAgentDisabled + k.SetBucketInfo(ctx, bucketInfo) + return &types.MsgToggleSPAsDelegatedAgentResponse{}, nil + +} + func (k msgServer) CreateObject(goCtx context.Context, msg *types.MsgCreateObject) (*types.MsgCreateObjectResponse, error) { ctx := sdk.UnwrapSDKContext(goCtx) @@ -739,6 +754,59 @@ func (k msgServer) CancelUpdateObjectContent(goCtx context.Context, msg *storage return &types.MsgCancelUpdateObjectContentResponse{}, nil } +func (k msgServer) DelegateCreateObject(goCtx context.Context, msg *storagetypes.MsgDelegateCreateObject) (*storagetypes.MsgDelegateCreateObjectResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + operatorAddr := sdk.MustAccAddressFromHex(msg.Operator) + creatorAddr := sdk.MustAccAddressFromHex(msg.Creator) + id, err := k.Keeper.CreateObject(ctx, operatorAddr, msg.BucketName, msg.ObjectName, msg.PayloadSize, storagetypes.CreateObjectOptions{ + SourceType: types.SOURCE_TYPE_ORIGIN, + Visibility: msg.Visibility, + ContentType: msg.ContentType, + RedundancyType: msg.RedundancyType, + Checksums: msg.ExpectChecksums, + Delegated: true, + Creator: creatorAddr, + }) + if err != nil { + return nil, err + } + return &types.MsgDelegateCreateObjectResponse{ + ObjectId: id, + }, nil +} + +func (k msgServer) DelegateUpdateObjectContent(goCtx context.Context, msg *storagetypes.MsgDelegateUpdateObjectContent) (*storagetypes.MsgDelegateUpdateObjectContentResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + operatorAddr := sdk.MustAccAddressFromHex(msg.Operator) + updaterAddr := sdk.MustAccAddressFromHex(msg.Updater) + err := k.Keeper.UpdateObjectContent(ctx, operatorAddr, msg.BucketName, msg.ObjectName, msg.PayloadSize, storagetypes.UpdateObjectOptions{ + ContentType: msg.ContentType, + Checksums: msg.ExpectChecksums, + Delegated: true, + Updater: updaterAddr, + }) + if err != nil { + return nil, err + } + return &types.MsgDelegateUpdateObjectContentResponse{}, nil +} + +func (k msgServer) SealObjectV2(goCtx context.Context, msg *storagetypes.MsgSealObjectV2) (*storagetypes.MsgSealObjectV2Response, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + spSealAcc := sdk.MustAccAddressFromHex(msg.Operator) + + err := k.Keeper.SealObject(ctx, spSealAcc, msg.BucketName, msg.ObjectName, SealObjectOptions{ + GlobalVirtualGroupId: msg.GlobalVirtualGroupId, + SecondarySpBlsSignatures: msg.SecondarySpBlsAggSignatures, + Checksums: msg.ExpectChecksums, + }) + if err != nil { + return nil, err + } + return &types.MsgSealObjectV2Response{}, nil +} + func (k Keeper) verifyGVGSignatures(ctx sdk.Context, bucketID math.Uint, dstSP *sptypes.StorageProvider, gvgMappings []*storagetypes.GVGMapping) error { // verify secondary sp signature for _, newLvg2gvg := range gvgMappings { diff --git a/x/storage/types/codec.go b/x/storage/types/codec.go index 0e96ca58e..b08c39bda 100644 --- a/x/storage/types/codec.go +++ b/x/storage/types/codec.go @@ -121,7 +121,18 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { registry.RegisterImplementations((*sdk.Msg)(nil), &MsgCancelUpdateObjectContent{}, ) - + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgDelegateCreateObject{}, + ) + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgToggleSPAsDelegatedAgent{}, + ) + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgSealObjectV2{}, + ) + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgDelegateUpdateObjectContent{}, + ) msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) } diff --git a/x/storage/types/errors.go b/x/storage/types/errors.go index 32509e1c7..e490b89f8 100644 --- a/x/storage/types/errors.go +++ b/x/storage/types/errors.go @@ -34,6 +34,7 @@ var ( ErrUpdateObjectNotAllowed = errors.Register(ModuleName, 1126, "Object is not allowed to update") ErrObjectIsUpdating = errors.Register(ModuleName, 1127, "Object is being updated") ErrObjectIsNotUpdating = errors.Register(ModuleName, 1128, "Object is not being updated") + ErrObjectChecksumsMissing = errors.Register(ModuleName, 1129, "Object checksums is missing") ErrInvalidCrossChainPackage = errors.Register(ModuleName, 3000, "invalid cross chain package") ErrAlreadyMirrored = errors.Register(ModuleName, 3001, "resource is already mirrored") diff --git a/x/storage/types/events.pb.go b/x/storage/types/events.pb.go index faddbb2b3..42d16a15a 100644 --- a/x/storage/types/events.pb.go +++ b/x/storage/types/events.pb.go @@ -650,6 +650,10 @@ type EventSealObject struct { GlobalVirtualGroupId uint32 `protobuf:"varint,7,opt,name=global_virtual_group_id,json=globalVirtualGroupId,proto3" json:"global_virtual_group_id,omitempty"` // local_virtual_group_id defines the unique id of lvg which the object stored LocalVirtualGroupId uint32 `protobuf:"varint,8,opt,name=local_virtual_group_id,json=localVirtualGroupId,proto3" json:"local_virtual_group_id,omitempty"` + // checksums define the total checksums of the object which generated by redundancy + // SP might set the checksum of object if it was delegated created by SP, which checksum + // will not be available until sealing object. + Checksums [][]byte `protobuf:"bytes,9,rep,name=checksums,proto3" json:"checksums,omitempty"` } func (m *EventSealObject) Reset() { *m = EventSealObject{} } @@ -727,6 +731,13 @@ func (m *EventSealObject) GetLocalVirtualGroupId() uint32 { return 0 } +func (m *EventSealObject) GetChecksums() [][]byte { + if m != nil { + return m.Checksums + } + return nil +} + // EventCopyObject is emitted on MsgCopyObject type EventCopyObject struct { // operator define the account address of operator who copy the object @@ -2706,126 +2717,126 @@ func init() { func init() { proto.RegisterFile("greenfield/storage/events.proto", fileDescriptor_946dcba4f763ddc4) } var fileDescriptor_946dcba4f763ddc4 = []byte{ - // 1891 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x5a, 0xcb, 0x8f, 0xdb, 0xc6, - 0x19, 0x37, 0xf5, 0x5a, 0xe9, 0xd3, 0x4a, 0xf2, 0xb2, 0x5b, 0x47, 0xdd, 0x24, 0x5a, 0x85, 0x45, - 0xd3, 0x4d, 0x50, 0x4b, 0x85, 0x93, 0x16, 0xbe, 0x19, 0xbb, 0xeb, 0xb4, 0x10, 0xda, 0x24, 0x2e, - 0xe5, 0xe4, 0xd0, 0x0b, 0x31, 0x22, 0x67, 0x65, 0xd6, 0x14, 0x87, 0x9d, 0x19, 0xed, 0x5a, 0xf9, - 0x07, 0x7a, 0x2a, 0x10, 0xa0, 0x28, 0xd0, 0x5e, 0x72, 0x6d, 0x81, 0xa2, 0x40, 0x0f, 0xb9, 0xf6, - 0xee, 0x63, 0xe2, 0x5e, 0xfa, 0x00, 0xd2, 0xc2, 0xbe, 0x34, 0x05, 0x8a, 0xf6, 0xdc, 0x53, 0xc1, - 0x99, 0x21, 0x45, 0x8a, 0x5a, 0x6b, 0x29, 0xc7, 0xde, 0x75, 0x6e, 0xe2, 0xe8, 0xc7, 0xd1, 0xf7, - 0xf8, 0x7d, 0x8f, 0xf9, 0x46, 0xb0, 0x3b, 0xa6, 0x18, 0xfb, 0x47, 0x2e, 0xf6, 0x9c, 0x3e, 0xe3, - 0x84, 0xa2, 0x31, 0xee, 0xe3, 0x63, 0xec, 0x73, 0xd6, 0x0b, 0x28, 0xe1, 0x44, 0xd7, 0xe7, 0x80, - 0x9e, 0x02, 0xec, 0x7c, 0xcd, 0x26, 0x6c, 0x42, 0x98, 0x25, 0x10, 0x7d, 0xf9, 0x20, 0xe1, 0x3b, - 0xdb, 0x63, 0x32, 0x26, 0x72, 0x3d, 0xfc, 0xa4, 0x56, 0x77, 0xc7, 0x84, 0x8c, 0x3d, 0xdc, 0x17, - 0x4f, 0xa3, 0xe9, 0x51, 0x9f, 0xbb, 0x13, 0xcc, 0x38, 0x9a, 0x04, 0x31, 0x60, 0x2e, 0x06, 0xc5, - 0x8c, 0x4c, 0xa9, 0x8d, 0xfb, 0x7c, 0x16, 0x60, 0xb6, 0x04, 0x10, 0xc9, 0x69, 0x93, 0xc9, 0x84, - 0xf8, 0x0a, 0xd0, 0x59, 0x02, 0x48, 0x6c, 0x60, 0xfc, 0xa9, 0x04, 0x5b, 0x6f, 0x85, 0x8a, 0x1d, - 0x52, 0x8c, 0x38, 0x3e, 0x98, 0xda, 0x77, 0x31, 0xd7, 0x7b, 0x50, 0x26, 0x27, 0x3e, 0xa6, 0x6d, - 0xad, 0xab, 0xed, 0xd5, 0x0e, 0xda, 0x0f, 0x3e, 0xbe, 0xba, 0xad, 0xf4, 0xd9, 0x77, 0x1c, 0x8a, - 0x19, 0x1b, 0x72, 0xea, 0xfa, 0x63, 0x53, 0xc2, 0xf4, 0x5d, 0xa8, 0x8f, 0xc4, 0x9b, 0x96, 0x8f, - 0x26, 0xb8, 0x5d, 0x08, 0xdf, 0x32, 0x41, 0x2e, 0xbd, 0x83, 0x26, 0x58, 0x3f, 0x00, 0x38, 0x76, - 0x99, 0x3b, 0x72, 0x3d, 0x97, 0xcf, 0xda, 0xc5, 0xae, 0xb6, 0xd7, 0xbc, 0x66, 0xf4, 0xb2, 0x36, - 0xec, 0xbd, 0x1f, 0xa3, 0x6e, 0xcf, 0x02, 0x6c, 0x26, 0xde, 0xd2, 0x5f, 0x84, 0x9a, 0x2d, 0x84, - 0xb4, 0x10, 0x6f, 0x97, 0xba, 0xda, 0x5e, 0xd1, 0xac, 0xca, 0x85, 0x7d, 0xae, 0x5f, 0x87, 0x9a, - 0x92, 0xc0, 0x75, 0xda, 0x65, 0x21, 0xf5, 0x8b, 0xf7, 0x3f, 0xdb, 0xbd, 0xf4, 0xd7, 0xcf, 0x76, - 0x4b, 0xef, 0xb9, 0x3e, 0x7f, 0xf0, 0xf1, 0xd5, 0xba, 0xd2, 0x20, 0x7c, 0x34, 0xab, 0x12, 0x3d, - 0x70, 0xf4, 0x1b, 0x50, 0x97, 0x86, 0xb5, 0x42, 0xbb, 0xb4, 0x2b, 0x42, 0xb6, 0xce, 0x32, 0xd9, - 0x86, 0x02, 0x26, 0xe5, 0x62, 0xf1, 0x67, 0xfd, 0x5b, 0xa0, 0xdb, 0x77, 0x10, 0x1d, 0x63, 0xc7, - 0xa2, 0x18, 0x39, 0xd6, 0x4f, 0xa7, 0x84, 0xa3, 0xf6, 0x46, 0x57, 0xdb, 0x2b, 0x99, 0x97, 0xd5, - 0x37, 0x26, 0x46, 0xce, 0x8f, 0xc2, 0x75, 0x7d, 0x1f, 0x5a, 0x01, 0x9a, 0x4d, 0xb0, 0xcf, 0x2d, - 0x24, 0x4d, 0xd9, 0xae, 0xae, 0x30, 0x72, 0x53, 0xbd, 0xa0, 0x56, 0x75, 0x03, 0x1a, 0x01, 0x75, - 0x27, 0x88, 0xce, 0x2c, 0x16, 0x84, 0xfa, 0xd6, 0xba, 0xda, 0x5e, 0xc3, 0xac, 0xab, 0xc5, 0x61, - 0x30, 0x70, 0xf4, 0x03, 0xe8, 0x8c, 0x3d, 0x32, 0x42, 0x9e, 0x75, 0xec, 0x52, 0x3e, 0x45, 0x9e, - 0x35, 0xa6, 0x64, 0x1a, 0x58, 0x47, 0x68, 0xe2, 0x7a, 0xb3, 0xf0, 0x25, 0x10, 0x2f, 0xed, 0x48, - 0xd4, 0xfb, 0x12, 0xf4, 0xfd, 0x10, 0xf3, 0x3d, 0x01, 0x19, 0x38, 0xfa, 0x75, 0xa8, 0x30, 0x8e, - 0xf8, 0x94, 0xb5, 0xeb, 0xc2, 0x28, 0xdd, 0x65, 0x46, 0x91, 0x8c, 0x19, 0x0a, 0x9c, 0xa9, 0xf0, - 0xc6, 0xaf, 0x0a, 0x8a, 0x55, 0x37, 0xb1, 0x87, 0x63, 0x56, 0xbd, 0x09, 0x55, 0x12, 0x60, 0x8a, - 0x38, 0x59, 0x4d, 0xac, 0x18, 0x39, 0xe7, 0x62, 0x61, 0x2d, 0x2e, 0x16, 0x33, 0x5c, 0x4c, 0x51, - 0xa5, 0x94, 0x87, 0x2a, 0xab, 0x8d, 0x5a, 0x5e, 0x65, 0x54, 0xe3, 0x67, 0x45, 0xf8, 0xaa, 0x30, - 0xcd, 0x7b, 0x81, 0x13, 0x07, 0xdc, 0xc0, 0x3f, 0x22, 0x6b, 0x9a, 0x67, 0x65, 0xe8, 0xa5, 0xd4, - 0x2d, 0xe6, 0x51, 0x77, 0x39, 0xb1, 0x4b, 0xa7, 0x10, 0xfb, 0x9b, 0x59, 0x62, 0x8b, 0x38, 0xcc, - 0xd0, 0x37, 0x9d, 0x0b, 0x2a, 0x6b, 0xe5, 0x82, 0xd5, 0x9e, 0xd8, 0x58, 0xe9, 0x89, 0xdf, 0x6a, - 0x70, 0x45, 0x92, 0xd4, 0x65, 0x36, 0xf1, 0xb9, 0xeb, 0x4f, 0x23, 0xa6, 0xa6, 0x6c, 0xa6, 0xe5, - 0xb1, 0xd9, 0x4a, 0x77, 0x5c, 0x81, 0x0a, 0xc5, 0x88, 0x11, 0x5f, 0x31, 0x53, 0x3d, 0x85, 0xd9, - 0xcd, 0x11, 0xc1, 0x92, 0xc8, 0x6e, 0x72, 0x61, 0x9f, 0x1b, 0xbf, 0xa8, 0xa4, 0xb2, 0xf4, 0xbb, - 0xa3, 0x9f, 0x60, 0x9b, 0xeb, 0xd7, 0x60, 0x43, 0xe4, 0xbf, 0x33, 0xf0, 0x25, 0x02, 0x7e, 0xf1, - 0xd1, 0xb4, 0x0b, 0x75, 0x22, 0xc4, 0x91, 0x80, 0x92, 0x04, 0xc8, 0xa5, 0x2c, 0xff, 0x2a, 0x79, - 0x6c, 0x79, 0x1d, 0x6a, 0x6a, 0x6b, 0xe5, 0xcf, 0x55, 0x6f, 0x4a, 0xf4, 0xc0, 0xc9, 0x66, 0xc8, - 0x6a, 0x36, 0x43, 0xbe, 0x02, 0x9b, 0x01, 0x9a, 0x79, 0x04, 0x39, 0x16, 0x73, 0x3f, 0xc0, 0x22, - 0x89, 0x96, 0xcc, 0xba, 0x5a, 0x1b, 0xba, 0x1f, 0x2c, 0x56, 0x2d, 0x58, 0x8b, 0xa9, 0xaf, 0xc0, - 0x66, 0x48, 0xae, 0x30, 0x2c, 0x44, 0x7d, 0xa9, 0x0b, 0x03, 0xd5, 0xd5, 0x9a, 0x28, 0x20, 0xa9, - 0xc2, 0xb6, 0x99, 0x29, 0x6c, 0x51, 0x12, 0x6e, 0x9c, 0x9e, 0x84, 0x25, 0x21, 0xd2, 0x49, 0x58, - 0xff, 0x01, 0xb4, 0x28, 0x76, 0xa6, 0xbe, 0x83, 0x7c, 0x7b, 0x26, 0x7f, 0xbc, 0x79, 0xba, 0x0a, - 0x66, 0x0c, 0x15, 0x2a, 0x34, 0x69, 0xea, 0x79, 0xb1, 0x4a, 0xb6, 0x72, 0x57, 0xc9, 0x97, 0xa0, - 0x66, 0xdf, 0xc1, 0xf6, 0x5d, 0x36, 0x9d, 0xb0, 0xf6, 0xe5, 0x6e, 0x71, 0x6f, 0xd3, 0x9c, 0x2f, - 0xe8, 0x6f, 0xc0, 0x15, 0x8f, 0xd8, 0x99, 0x70, 0x76, 0x9d, 0xf6, 0x96, 0xf0, 0xdc, 0x57, 0xc4, - 0xb7, 0xc9, 0x30, 0x1e, 0x38, 0xc6, 0x7f, 0x34, 0x78, 0x41, 0x46, 0x05, 0xf2, 0x6d, 0xec, 0xa5, - 0x62, 0xe3, 0x29, 0x25, 0xd3, 0x05, 0xb6, 0x17, 0x33, 0x6c, 0xcf, 0x30, 0xaf, 0x94, 0x65, 0x5e, - 0x8a, 0xd7, 0x95, 0x1c, 0xbc, 0x36, 0x3e, 0x2f, 0x40, 0x4b, 0x68, 0x3c, 0xc4, 0xc8, 0x3b, 0x67, - 0x4d, 0x53, 0x5a, 0x94, 0xf3, 0x44, 0xe7, 0x9c, 0xd2, 0x95, 0x9c, 0x94, 0xfe, 0x0e, 0xbc, 0xb0, - 0x34, 0xed, 0xc7, 0xf9, 0x7e, 0x3b, 0x9b, 0xef, 0x07, 0xce, 0x63, 0xd8, 0x55, 0x3d, 0x9d, 0x5d, - 0x1f, 0x15, 0x95, 0xad, 0x0f, 0x49, 0x30, 0x7b, 0x22, 0x5b, 0xbf, 0x0a, 0x2d, 0x46, 0x6d, 0x2b, - 0x6b, 0xef, 0x06, 0xa3, 0xf6, 0xc1, 0xdc, 0xe4, 0x0a, 0x97, 0x35, 0x7b, 0x88, 0x7b, 0x77, 0x6e, - 0xf9, 0x57, 0xa1, 0xe5, 0x30, 0x9e, 0xda, 0x4f, 0xa6, 0xdd, 0x86, 0xc3, 0x78, 0x7a, 0xbf, 0x10, - 0x97, 0xdc, 0xaf, 0x1c, 0xe3, 0x12, 0xfb, 0xdd, 0x80, 0x46, 0xe2, 0x77, 0xcf, 0xc6, 0xc9, 0x7a, - 0x2c, 0x92, 0x68, 0xa1, 0x1b, 0x89, 0x1f, 0x3a, 0x5b, 0xb2, 0xae, 0xc7, 0x32, 0xac, 0xeb, 0xa0, - 0xff, 0x69, 0xa9, 0x26, 0xf3, 0x22, 0x85, 0x43, 0x29, 0x4f, 0x38, 0x9c, 0xae, 0x7c, 0xf9, 0x74, - 0xe5, 0xff, 0xa9, 0xa9, 0x36, 0xd2, 0xc4, 0x22, 0x4e, 0x2e, 0x58, 0x3e, 0xc8, 0x65, 0x80, 0x97, - 0x01, 0x8e, 0x08, 0xb5, 0xa6, 0xa2, 0x21, 0x16, 0x4a, 0x57, 0xcd, 0xda, 0x11, 0xa1, 0xb2, 0x43, - 0x5e, 0xda, 0xa7, 0x29, 0x5d, 0x17, 0xa4, 0xd6, 0x96, 0x35, 0xbf, 0x73, 0xa1, 0x0a, 0x79, 0x84, - 0x5a, 0xab, 0x4f, 0xfb, 0x79, 0x21, 0xd5, 0xdc, 0x2b, 0x7e, 0x3f, 0xc5, 0xe6, 0xfe, 0x29, 0x7a, - 0x25, 0xdd, 0xfc, 0x94, 0xd7, 0x69, 0x7e, 0x8c, 0xff, 0x6a, 0x70, 0x39, 0xd1, 0xb7, 0x0a, 0xf2, - 0xe6, 0x1e, 0x2e, 0xbc, 0x0c, 0x20, 0x23, 0x22, 0x61, 0x83, 0x9a, 0x58, 0x11, 0x1a, 0x7e, 0x17, - 0xaa, 0x71, 0xc0, 0x9c, 0xe1, 0x78, 0xb3, 0x31, 0x56, 0x45, 0x61, 0xa1, 0xa3, 0x29, 0xe5, 0xee, - 0x68, 0xb6, 0xa1, 0x8c, 0xef, 0x71, 0x8a, 0x54, 0x52, 0x95, 0x0f, 0xc6, 0xaf, 0x23, 0x95, 0x65, - 0x56, 0x5a, 0x50, 0xb9, 0xb0, 0x8e, 0xca, 0xc5, 0xc7, 0xa9, 0x5c, 0x3a, 0xbb, 0xca, 0xc6, 0x5f, - 0x34, 0x55, 0xd2, 0x7e, 0x88, 0xd1, 0xb1, 0x12, 0xed, 0x06, 0x34, 0x27, 0x78, 0x32, 0xc2, 0x34, - 0x3e, 0xb5, 0xad, 0x72, 0x4b, 0x43, 0xe2, 0xa3, 0xe3, 0xdc, 0x05, 0xd1, 0xed, 0xdf, 0x05, 0x95, - 0x25, 0x64, 0xe8, 0x09, 0xe5, 0xde, 0x16, 0x82, 0x3e, 0xa3, 0xb9, 0xc3, 0xd3, 0xd1, 0x4b, 0xbf, - 0x15, 0xf9, 0x87, 0x59, 0x9c, 0x84, 0x3e, 0x6a, 0x97, 0xbb, 0xc5, 0xbd, 0xfa, 0xb5, 0xd7, 0x97, - 0x31, 0x55, 0x18, 0x20, 0xa1, 0xfa, 0x4d, 0xcc, 0x91, 0xeb, 0x99, 0x9b, 0x6a, 0x87, 0xdb, 0x64, - 0xdf, 0x71, 0xf4, 0x9b, 0xb0, 0x95, 0xd8, 0x51, 0xe6, 0xae, 0x76, 0xa5, 0x5b, 0x7c, 0xac, 0x92, - 0xad, 0x78, 0x0b, 0xc9, 0x6b, 0xe3, 0x6f, 0x85, 0xb8, 0x00, 0xf9, 0xf8, 0xe4, 0x4b, 0x63, 0xee, - 0x85, 0xac, 0x50, 0xce, 0x9d, 0x15, 0x6e, 0xc2, 0x86, 0x32, 0x95, 0xb0, 0x69, 0x3e, 0x47, 0x45, - 0xaf, 0x1a, 0xbf, 0x8c, 0x6a, 0x5e, 0x06, 0xa3, 0x7f, 0x1b, 0x2a, 0x12, 0xb5, 0xd2, 0xb8, 0x0a, - 0xa7, 0x0f, 0xa0, 0x85, 0xef, 0x05, 0x2e, 0x45, 0xdc, 0x25, 0xbe, 0xc5, 0x5d, 0x95, 0x45, 0xeb, - 0xd7, 0x76, 0x7a, 0x72, 0x00, 0xdd, 0x8b, 0x06, 0xd0, 0xbd, 0xdb, 0xd1, 0x00, 0xfa, 0xa0, 0xf4, - 0xe1, 0xdf, 0x77, 0x35, 0xb3, 0x39, 0x7f, 0x31, 0xfc, 0xca, 0xf8, 0x97, 0x96, 0x2a, 0x70, 0x42, - 0xba, 0xb7, 0xc2, 0xbc, 0xf7, 0x7c, 0x7b, 0x7d, 0x79, 0x2a, 0xbf, 0x1f, 0x35, 0x98, 0x6f, 0xbb, - 0x94, 0x12, 0xfa, 0x44, 0x53, 0xcc, 0x7c, 0x63, 0xba, 0x5c, 0x53, 0x49, 0x03, 0x1a, 0x0e, 0x66, - 0xdc, 0xb2, 0xef, 0x20, 0xd7, 0x9f, 0xb7, 0x8d, 0xf5, 0x70, 0xf1, 0x30, 0x5c, 0x1b, 0x38, 0xc6, - 0x1f, 0xa2, 0xa3, 0x72, 0x52, 0x15, 0x13, 0xb3, 0xa9, 0xc7, 0xc3, 0x4e, 0x47, 0x1d, 0xc7, 0x34, - 0xf1, 0x62, 0x74, 0xd8, 0x3a, 0x67, 0x91, 0x3f, 0x4f, 0x5b, 0xff, 0xb9, 0xed, 0x6e, 0xcf, 0xa2, - 0xeb, 0xa7, 0x69, 0xf7, 0x48, 0x5d, 0x9f, 0xd4, 0x3d, 0xe7, 0xac, 0xd3, 0x1f, 0xa3, 0x46, 0x48, - 0xea, 0x74, 0xa1, 0x7a, 0xbf, 0x8c, 0xfc, 0xa5, 0xac, 0xfc, 0xbf, 0x8b, 0x52, 0x70, 0x42, 0xfe, - 0x15, 0x2e, 0x39, 0x47, 0x69, 0x8f, 0x15, 0x81, 0x86, 0x1c, 0x79, 0xf8, 0x16, 0xf1, 0x5c, 0x7b, - 0x76, 0xe8, 0x61, 0xe4, 0x4f, 0x03, 0x7d, 0x07, 0xaa, 0x23, 0x8f, 0xd8, 0x77, 0xdf, 0x99, 0x4e, - 0x84, 0xbc, 0x45, 0x33, 0x7e, 0x0e, 0xcb, 0x9d, 0x3a, 0xcd, 0xb8, 0xfe, 0x11, 0x51, 0x65, 0x61, - 0x69, 0xb9, 0x93, 0x65, 0x3f, 0x3c, 0xcb, 0x98, 0xe0, 0xc4, 0x9f, 0x8d, 0x07, 0x1a, 0x6c, 0x2b, - 0x2b, 0x8d, 0x65, 0x9d, 0x78, 0x86, 0x69, 0x32, 0xd7, 0x6d, 0xc6, 0x6b, 0xb0, 0xe5, 0x30, 0x6e, - 0x2d, 0x9b, 0xce, 0x35, 0x1d, 0xc6, 0x6f, 0xcd, 0x07, 0x74, 0xc6, 0xef, 0x35, 0xd8, 0x49, 0x0c, - 0x16, 0x2f, 0xba, 0x6a, 0x21, 0x55, 0xdb, 0x89, 0x61, 0x80, 0x94, 0x17, 0x5f, 0x54, 0x69, 0x3f, - 0x2a, 0xc0, 0x4b, 0x6a, 0xb0, 0x36, 0x09, 0x42, 0x22, 0x5d, 0x78, 0xea, 0xac, 0xbe, 0x6d, 0x2a, - 0xad, 0xbc, 0x4c, 0x7d, 0x0d, 0xb6, 0x18, 0xb5, 0x17, 0xe8, 0x27, 0xd3, 0x66, 0x93, 0x51, 0x3b, - 0x49, 0x3f, 0x0b, 0xea, 0x6a, 0xc8, 0xcb, 0x6f, 0xa3, 0x71, 0x18, 0xbf, 0xd1, 0xdd, 0xbf, 0x9a, - 0x70, 0xc4, 0xcf, 0xfa, 0x9b, 0x50, 0xe2, 0x68, 0xcc, 0x54, 0xe0, 0x76, 0x97, 0x0f, 0xf6, 0x55, - 0x77, 0x8a, 0xc6, 0xcc, 0x14, 0x68, 0xe3, 0x37, 0x05, 0xc5, 0x97, 0xe4, 0x98, 0xe2, 0x50, 0xde, - 0x48, 0xac, 0x69, 0xfd, 0xf5, 0x07, 0x2d, 0x4f, 0x7e, 0xc3, 0xb4, 0x78, 0x93, 0x53, 0xce, 0xde, - 0xe4, 0xa4, 0x6e, 0x1f, 0x2a, 0x8b, 0xb7, 0x0f, 0x6d, 0xd8, 0x38, 0xc6, 0x94, 0xb9, 0xc4, 0x17, - 0x93, 0xcb, 0xa2, 0x19, 0x3d, 0x1a, 0x9f, 0x16, 0x61, 0xf7, 0x34, 0x4b, 0x0d, 0xa7, 0xb6, 0x1d, - 0x1e, 0x80, 0x9f, 0x4b, 0x83, 0xa5, 0xee, 0xa4, 0xca, 0xd9, 0x3b, 0xa9, 0xd7, 0x61, 0x2b, 0xa0, - 0xf8, 0xd8, 0x4a, 0x19, 0xb6, 0x22, 0x0c, 0xdb, 0x0a, 0xbf, 0xb8, 0x95, 0x30, 0xee, 0x1e, 0x5c, - 0xf6, 0xf1, 0x49, 0x1a, 0x2a, 0xff, 0xfe, 0xd0, 0xf4, 0xf1, 0x49, 0x12, 0xf9, 0x0d, 0x68, 0x8a, - 0x5d, 0xe7, 0xbe, 0xa8, 0x0a, 0x5f, 0x34, 0xc2, 0xd5, 0xc3, 0xd8, 0x1f, 0x5f, 0x87, 0x46, 0xb8, - 0xe1, 0x1c, 0x55, 0x13, 0xa8, 0x4d, 0x1f, 0x9f, 0x1c, 0x2e, 0x73, 0x1a, 0xa4, 0x9c, 0x16, 0x96, - 0x61, 0x39, 0x4b, 0x74, 0x2c, 0xc4, 0xc5, 0x85, 0x5b, 0xd1, 0xac, 0xa9, 0x95, 0x7d, 0x1e, 0x96, - 0xac, 0x4e, 0x22, 0xbb, 0x7f, 0x71, 0x31, 0x70, 0x8e, 0x1d, 0xd9, 0xc1, 0xe0, 0xfe, 0xc3, 0x8e, - 0xf6, 0xc9, 0xc3, 0x8e, 0xf6, 0x8f, 0x87, 0x1d, 0xed, 0xc3, 0x47, 0x9d, 0x4b, 0x9f, 0x3c, 0xea, - 0x5c, 0xfa, 0xf3, 0xa3, 0xce, 0xa5, 0x1f, 0xf7, 0xc7, 0x2e, 0xbf, 0x33, 0x1d, 0xf5, 0x6c, 0x32, - 0xe9, 0x8f, 0xfc, 0xd1, 0x55, 0xd1, 0x45, 0xf4, 0x13, 0x7f, 0x0b, 0xba, 0x97, 0xfe, 0x63, 0xd0, - 0xa8, 0x22, 0x4e, 0x83, 0x6f, 0xfc, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x4f, 0x67, 0x5e, 0xc0, 0x04, - 0x25, 0x00, 0x00, + // 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, } func (m *EventCreateBucket) Marshal() (dAtA []byte, err error) { @@ -3307,6 +3318,15 @@ func (m *EventSealObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.Checksums) > 0 { + for iNdEx := len(m.Checksums) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Checksums[iNdEx]) + copy(dAtA[i:], m.Checksums[iNdEx]) + i = encodeVarintEvents(dAtA, i, uint64(len(m.Checksums[iNdEx]))) + i-- + dAtA[i] = 0x4a + } + } if m.LocalVirtualGroupId != 0 { i = encodeVarintEvents(dAtA, i, uint64(m.LocalVirtualGroupId)) i-- @@ -5168,6 +5188,12 @@ func (m *EventSealObject) Size() (n int) { if m.LocalVirtualGroupId != 0 { n += 1 + sovEvents(uint64(m.LocalVirtualGroupId)) } + if len(m.Checksums) > 0 { + for _, b := range m.Checksums { + l = len(b) + n += 1 + l + sovEvents(uint64(l)) + } + } return n } @@ -7649,6 +7675,38 @@ func (m *EventSealObject) Unmarshal(dAtA []byte) error { break } } + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Checksums", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvents + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvents + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvents + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Checksums = append(m.Checksums, make([]byte, postIndex-iNdEx)) + copy(m.Checksums[len(m.Checksums)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipEvents(dAtA[iNdEx:]) diff --git a/x/storage/types/message.go b/x/storage/types/message.go index ab6957e85..13e288da8 100644 --- a/x/storage/types/message.go +++ b/x/storage/types/message.go @@ -21,24 +21,29 @@ import ( const ( // For bucket - TypeMsgCreateBucket = "create_bucket" - TypeMsgDeleteBucket = "delete_bucket" - TypeMsgUpdateBucketInfo = "update_bucket_info" - TypeMsgMirrorBucket = "mirror_bucket" + TypeMsgCreateBucket = "create_bucket" + TypeMsgDeleteBucket = "delete_bucket" + TypeMsgUpdateBucketInfo = "update_bucket_info" + TypeMsgMirrorBucket = "mirror_bucket" + TypeMsgToggleSPAsDelegatedAgent = "toggle_sp_as_delegated_agent" // For object - TypeMsgCopyObject = "copy_object" - TypeMsgCreateObject = "create_object" - TypeMsgDeleteObject = "delete_object" - TypeMsgSealObject = "seal_object" - TypeMsgRejectSealObject = "reject_seal_object" - TypeMsgCancelCreateObject = "cancel_create_object" - TypeMsgMirrorObject = "mirror_object" - TypeMsgDiscontinueObject = "discontinue_object" - TypeMsgDiscontinueBucket = "discontinue_bucket" - TypeMsgUpdateObjectInfo = "update_object_info" - TypeMsgUpdateObjectContent = "update_object_content" - TypeMsgCancelUpdateObjectContent = "cancel_update_object_content" + TypeMsgCopyObject = "copy_object" + TypeMsgCreateObject = "create_object" + TypeMsgDeleteObject = "delete_object" + TypeMsgSealObject = "seal_object" + TypeMsgSealObjectV2 = "seal_object_v2" + + TypeMsgRejectSealObject = "reject_seal_object" + TypeMsgCancelCreateObject = "cancel_create_object" + TypeMsgMirrorObject = "mirror_object" + TypeMsgDiscontinueObject = "discontinue_object" + TypeMsgDiscontinueBucket = "discontinue_bucket" + TypeMsgUpdateObjectInfo = "update_object_info" + TypeMsgUpdateObjectContent = "update_object_content" + TypeMsgCancelUpdateObjectContent = "cancel_update_object_content" + TypeMsgDelegateCreateObject = "delegate_create_object" + TypeMsgDelegateUpdateObjectContent = "delegate_update_object_content" // For group TypeMsgCreateGroup = "create_group" @@ -295,6 +300,54 @@ func (msg *MsgUpdateBucketInfo) ValidateBasic() error { return nil } +func NewMsgToggleSPAsDelegatedAgent( + operator sdk.AccAddress, bucketName string, +) *MsgToggleSPAsDelegatedAgent { + return &MsgToggleSPAsDelegatedAgent{ + Operator: operator.String(), + BucketName: bucketName, + } +} + +// Route implements the sdk.Msg interface. +func (msg *MsgToggleSPAsDelegatedAgent) Route() string { + return RouterKey +} + +// Type implements the sdk.Msg interface. +func (msg *MsgToggleSPAsDelegatedAgent) Type() string { + return TypeMsgToggleSPAsDelegatedAgent +} + +// GetSigners implements the sdk.Msg interface. +func (msg *MsgToggleSPAsDelegatedAgent) GetSigners() []sdk.AccAddress { + operator, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{operator} +} + +// GetSignBytes returns the message bytes to sign over. +func (msg *MsgToggleSPAsDelegatedAgent) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +// ValidateBasic implements the sdk.Msg interface. +func (msg *MsgToggleSPAsDelegatedAgent) ValidateBasic() error { + _, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid operator address (%s)", err) + } + + err = s3util.CheckValidBucketName(msg.BucketName) + if err != nil { + return err + } + return nil +} + // NewMsgCreateObject creates a new MsgCreateObject instance. func NewMsgCreateObject( creator sdk.AccAddress, bucketName, objectName string, payloadSize uint64, Visibility VisibilityType, @@ -545,6 +598,76 @@ func (msg *MsgSealObject) ValidateBasic() error { return nil } +func NewMsgSealObjectV2( + operator sdk.AccAddress, bucketName, objectName string, globalVirtualGroupID uint32, + secondarySpBlsSignatures []byte, checksums [][]byte, +) *MsgSealObjectV2 { + return &MsgSealObjectV2{ + Operator: operator.String(), + BucketName: bucketName, + ObjectName: objectName, + GlobalVirtualGroupId: globalVirtualGroupID, + SecondarySpBlsAggSignatures: secondarySpBlsSignatures, + ExpectChecksums: checksums, + } +} + +// Route implements the sdk.Msg interface. +func (msg *MsgSealObjectV2) Route() string { + return RouterKey +} + +// Type implements the sdk.Msg interface. +func (msg *MsgSealObjectV2) Type() string { + return TypeMsgSealObjectV2 +} + +// GetSigners implements the sdk.Msg interface. +func (msg *MsgSealObjectV2) GetSigners() []sdk.AccAddress { + operator, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{operator} +} + +// GetSignBytes returns the message bytes to sign over. +func (msg *MsgSealObjectV2) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +// ValidateBasic implements the sdk.Msg interface. +func (msg *MsgSealObjectV2) ValidateBasic() error { + _, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + + err = s3util.CheckValidBucketName(msg.BucketName) + if err != nil { + return err + } + + err = s3util.CheckValidObjectName(msg.ObjectName) + if err != nil { + return err + } + + if len(msg.GetSecondarySpBlsAggSignatures()) != sdk.BLSSignatureLength { + return errors.Wrap(gnfderrors.ErrInvalidBlsSignature, + fmt.Sprintf("length of signature should be %d", sdk.BLSSignatureLength), + ) + } + + if msg.ExpectChecksums != nil { + if err = s3util.CheckValidExpectChecksums(msg.ExpectChecksums); err != nil { + return err + } + } + return nil +} + func NewMsgCopyObject( operator sdk.AccAddress, srcBucketName, dstBucketName string, srcObjectName, dstObjectName string, timeoutHeight uint64, sig []byte, @@ -1655,17 +1778,14 @@ func (msg *MsgUpdateObjectContent) ValidateBasic() error { if err != nil { return err } - err = s3util.CheckValidObjectName(msg.ObjectName) if err != nil { return err } - err = s3util.CheckValidExpectChecksums(msg.ExpectChecksums) if err != nil { return err } - return nil } @@ -1720,3 +1840,148 @@ func (msg *MsgCancelUpdateObjectContent) ValidateBasic() error { } return nil } + +// NewMsgDelegateCreateObject creates a new MsgDelegateCreateObject instance. +func NewMsgDelegateCreateObject( + operator, creator sdk.AccAddress, + bucketName, objectName string, + payloadSize uint64, + Visibility VisibilityType, + expectChecksums [][]byte, + contentType string, + redundancyType RedundancyType) *MsgDelegateCreateObject { + + return &MsgDelegateCreateObject{ + Operator: operator.String(), + Creator: creator.String(), + BucketName: bucketName, + ObjectName: objectName, + PayloadSize: payloadSize, + Visibility: Visibility, + ContentType: contentType, + ExpectChecksums: expectChecksums, + RedundancyType: redundancyType, + } +} + +// Route implements the sdk.Msg interface. +func (msg *MsgDelegateCreateObject) Route() string { + return RouterKey +} + +// Type implements the sdk.Msg interface. +func (msg *MsgDelegateCreateObject) Type() string { + return TypeMsgDelegateCreateObject +} + +// GetSigners implements the sdk.Msg interface. +func (msg *MsgDelegateCreateObject) GetSigners() []sdk.AccAddress { + Operator, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{Operator} +} + +// GetSignBytes returns the message bytes to sign over. +func (msg *MsgDelegateCreateObject) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +// ValidateBasic implements the sdk.Msg interface. +func (msg *MsgDelegateCreateObject) ValidateBasic() error { + _, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid operator address (%s)", err) + } + _, err = sdk.AccAddressFromHexUnsafe(msg.Creator) + if err != nil { + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + err = s3util.CheckValidBucketName(msg.BucketName) + if err != nil { + return err + } + err = s3util.CheckValidObjectName(msg.ObjectName) + if err != nil { + return err + } + if msg.ExpectChecksums != nil { + if err = s3util.CheckValidExpectChecksums(msg.ExpectChecksums); err != nil { + return err + } + } + err = s3util.CheckValidContentType(msg.ContentType) + if err != nil { + return err + } + if msg.Visibility == VISIBILITY_TYPE_UNSPECIFIED { + return errors.Wrapf(ErrInvalidVisibility, "Unspecified visibility is not allowed.") + } + return nil +} + +func NewMsgDelegateUpdateObjectContent( + operator, updater sdk.AccAddress, bucketName, objectName string, payloadSize uint64, + expectChecksums [][]byte) *MsgDelegateUpdateObjectContent { + return &MsgDelegateUpdateObjectContent{ + Operator: operator.String(), + Updater: updater.String(), + BucketName: bucketName, + ObjectName: objectName, + PayloadSize: payloadSize, + ExpectChecksums: expectChecksums, + } +} + +// Route implements the sdk.Msg interface. +func (msg *MsgDelegateUpdateObjectContent) Route() string { + return RouterKey +} + +// Type implements the sdk.Msg interface. +func (msg *MsgDelegateUpdateObjectContent) Type() string { + return TypeMsgDelegateUpdateObjectContent +} + +// GetSigners implements the sdk.Msg interface. +func (msg *MsgDelegateUpdateObjectContent) GetSigners() []sdk.AccAddress { + operator, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{operator} +} + +// GetSignBytes returns the message bytes to sign over. +func (msg *MsgDelegateUpdateObjectContent) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +// ValidateBasic implements the sdk.Msg interface. +func (msg *MsgDelegateUpdateObjectContent) ValidateBasic() error { + _, err := sdk.AccAddressFromHexUnsafe(msg.Operator) + if err != nil { + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + _, err = sdk.AccAddressFromHexUnsafe(msg.Updater) + if err != nil { + return errors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid updater address (%s)", err) + } + err = s3util.CheckValidBucketName(msg.BucketName) + if err != nil { + return err + } + err = s3util.CheckValidObjectName(msg.ObjectName) + if err != nil { + return err + } + if msg.ExpectChecksums != nil { + if err = s3util.CheckValidExpectChecksums(msg.ExpectChecksums); err != nil { + return err + } + } + return nil +} diff --git a/x/storage/types/options.go b/x/storage/types/options.go index 0db2fbaec..51f42cab6 100644 --- a/x/storage/types/options.go +++ b/x/storage/types/options.go @@ -3,6 +3,8 @@ package types import ( time "time" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/bnb-chain/greenfield/types/common" ) @@ -34,6 +36,8 @@ type CreateObjectOptions struct { Checksums [][]byte PrimarySpApproval *common.Approval ApprovalMsgBytes []byte + Delegated bool + Creator sdk.AccAddress } type CancelCreateObjectOptions struct { @@ -90,4 +94,6 @@ type DeletePolicyOptions struct { type UpdateObjectOptions struct { ContentType string Checksums [][]byte + Delegated bool + Updater sdk.AccAddress } diff --git a/x/storage/types/tx.pb.go b/x/storage/types/tx.pb.go index 716a90b09..a0b7c51b3 100644 --- a/x/storage/types/tx.pb.go +++ b/x/storage/types/tx.pb.go @@ -637,6 +637,135 @@ func (m *MsgSealObjectResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgSealObjectResponse proto.InternalMessageInfo +type MsgSealObjectV2 struct { + // operator defines the account address of primary SP + Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"` + // bucket_name defines the name of the bucket where the object is stored. + BucketName string `protobuf:"bytes,2,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` + // object_name defines the name of object to be sealed. + ObjectName string `protobuf:"bytes,3,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"` + // global_virtual_group_id defines the id of global virtual group + GlobalVirtualGroupId uint32 `protobuf:"varint,4,opt,name=global_virtual_group_id,json=globalVirtualGroupId,proto3" json:"global_virtual_group_id,omitempty"` + // secondary_sp_bls_agg_signatures defines the aggregate bls signature of the secondary sp that can + // acknowledge that the payload data has received and stored. + SecondarySpBlsAggSignatures []byte `protobuf:"bytes,5,opt,name=secondary_sp_bls_agg_signatures,json=secondarySpBlsAggSignatures,proto3" json:"secondary_sp_bls_agg_signatures,omitempty"` + // (optional) checksums define the total checksums of the object which generated by redundancy + // SP might set the checksum of object if it was delegated created by SP, which checksum + // will not be available until sealing object. + ExpectChecksums [][]byte `protobuf:"bytes,6,rep,name=expect_checksums,json=expectChecksums,proto3" json:"expect_checksums,omitempty"` +} + +func (m *MsgSealObjectV2) Reset() { *m = MsgSealObjectV2{} } +func (m *MsgSealObjectV2) String() string { return proto.CompactTextString(m) } +func (*MsgSealObjectV2) ProtoMessage() {} +func (*MsgSealObjectV2) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{10} +} +func (m *MsgSealObjectV2) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSealObjectV2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSealObjectV2.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 *MsgSealObjectV2) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSealObjectV2.Merge(m, src) +} +func (m *MsgSealObjectV2) XXX_Size() int { + return m.Size() +} +func (m *MsgSealObjectV2) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSealObjectV2.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSealObjectV2 proto.InternalMessageInfo + +func (m *MsgSealObjectV2) GetOperator() string { + if m != nil { + return m.Operator + } + return "" +} + +func (m *MsgSealObjectV2) GetBucketName() string { + if m != nil { + return m.BucketName + } + return "" +} + +func (m *MsgSealObjectV2) GetObjectName() string { + if m != nil { + return m.ObjectName + } + return "" +} + +func (m *MsgSealObjectV2) GetGlobalVirtualGroupId() uint32 { + if m != nil { + return m.GlobalVirtualGroupId + } + return 0 +} + +func (m *MsgSealObjectV2) GetSecondarySpBlsAggSignatures() []byte { + if m != nil { + return m.SecondarySpBlsAggSignatures + } + return nil +} + +func (m *MsgSealObjectV2) GetExpectChecksums() [][]byte { + if m != nil { + return m.ExpectChecksums + } + return nil +} + +type MsgSealObjectV2Response struct { +} + +func (m *MsgSealObjectV2Response) Reset() { *m = MsgSealObjectV2Response{} } +func (m *MsgSealObjectV2Response) String() string { return proto.CompactTextString(m) } +func (*MsgSealObjectV2Response) ProtoMessage() {} +func (*MsgSealObjectV2Response) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{11} +} +func (m *MsgSealObjectV2Response) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSealObjectV2Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSealObjectV2Response.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 *MsgSealObjectV2Response) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSealObjectV2Response.Merge(m, src) +} +func (m *MsgSealObjectV2Response) XXX_Size() int { + return m.Size() +} +func (m *MsgSealObjectV2Response) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSealObjectV2Response.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSealObjectV2Response proto.InternalMessageInfo + type MsgRejectSealObject struct { // operator defines the account address of the object owner Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"` @@ -650,7 +779,7 @@ func (m *MsgRejectSealObject) Reset() { *m = MsgRejectSealObject{} } func (m *MsgRejectSealObject) String() string { return proto.CompactTextString(m) } func (*MsgRejectSealObject) ProtoMessage() {} func (*MsgRejectSealObject) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{10} + return fileDescriptor_ddb71b028305a3cc, []int{12} } func (m *MsgRejectSealObject) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -707,7 +836,7 @@ func (m *MsgRejectSealObjectResponse) Reset() { *m = MsgRejectSealObject func (m *MsgRejectSealObjectResponse) String() string { return proto.CompactTextString(m) } func (*MsgRejectSealObjectResponse) ProtoMessage() {} func (*MsgRejectSealObjectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{11} + return fileDescriptor_ddb71b028305a3cc, []int{13} } func (m *MsgRejectSealObjectResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -755,7 +884,7 @@ func (m *MsgCopyObject) Reset() { *m = MsgCopyObject{} } func (m *MsgCopyObject) String() string { return proto.CompactTextString(m) } func (*MsgCopyObject) ProtoMessage() {} func (*MsgCopyObject) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{12} + return fileDescriptor_ddb71b028305a3cc, []int{14} } func (m *MsgCopyObject) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -834,7 +963,7 @@ func (m *MsgCopyObjectResponse) Reset() { *m = MsgCopyObjectResponse{} } func (m *MsgCopyObjectResponse) String() string { return proto.CompactTextString(m) } func (*MsgCopyObjectResponse) ProtoMessage() {} func (*MsgCopyObjectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{13} + return fileDescriptor_ddb71b028305a3cc, []int{15} } func (m *MsgCopyObjectResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -876,7 +1005,7 @@ func (m *MsgDeleteObject) Reset() { *m = MsgDeleteObject{} } func (m *MsgDeleteObject) String() string { return proto.CompactTextString(m) } func (*MsgDeleteObject) ProtoMessage() {} func (*MsgDeleteObject) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{14} + return fileDescriptor_ddb71b028305a3cc, []int{16} } func (m *MsgDeleteObject) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -933,7 +1062,7 @@ func (m *MsgDeleteObjectResponse) Reset() { *m = MsgDeleteObjectResponse func (m *MsgDeleteObjectResponse) String() string { return proto.CompactTextString(m) } func (*MsgDeleteObjectResponse) ProtoMessage() {} func (*MsgDeleteObjectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{15} + return fileDescriptor_ddb71b028305a3cc, []int{17} } func (m *MsgDeleteObjectResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -977,7 +1106,7 @@ func (m *MsgDiscontinueObject) Reset() { *m = MsgDiscontinueObject{} } func (m *MsgDiscontinueObject) String() string { return proto.CompactTextString(m) } func (*MsgDiscontinueObject) ProtoMessage() {} func (*MsgDiscontinueObject) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{16} + return fileDescriptor_ddb71b028305a3cc, []int{18} } func (m *MsgDiscontinueObject) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1034,7 +1163,7 @@ func (m *MsgDiscontinueObjectResponse) Reset() { *m = MsgDiscontinueObje func (m *MsgDiscontinueObjectResponse) String() string { return proto.CompactTextString(m) } func (*MsgDiscontinueObjectResponse) ProtoMessage() {} func (*MsgDiscontinueObjectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{17} + return fileDescriptor_ddb71b028305a3cc, []int{19} } func (m *MsgDiscontinueObjectResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1076,7 +1205,7 @@ func (m *MsgCreateGroup) Reset() { *m = MsgCreateGroup{} } func (m *MsgCreateGroup) String() string { return proto.CompactTextString(m) } func (*MsgCreateGroup) ProtoMessage() {} func (*MsgCreateGroup) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{18} + return fileDescriptor_ddb71b028305a3cc, []int{20} } func (m *MsgCreateGroup) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1134,7 +1263,7 @@ func (m *MsgCreateGroupResponse) Reset() { *m = MsgCreateGroupResponse{} func (m *MsgCreateGroupResponse) String() string { return proto.CompactTextString(m) } func (*MsgCreateGroupResponse) ProtoMessage() {} func (*MsgCreateGroupResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{19} + return fileDescriptor_ddb71b028305a3cc, []int{21} } func (m *MsgCreateGroupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1174,7 +1303,7 @@ func (m *MsgDeleteGroup) Reset() { *m = MsgDeleteGroup{} } func (m *MsgDeleteGroup) String() string { return proto.CompactTextString(m) } func (*MsgDeleteGroup) ProtoMessage() {} func (*MsgDeleteGroup) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{20} + return fileDescriptor_ddb71b028305a3cc, []int{22} } func (m *MsgDeleteGroup) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1224,7 +1353,7 @@ func (m *MsgDeleteGroupResponse) Reset() { *m = MsgDeleteGroupResponse{} func (m *MsgDeleteGroupResponse) String() string { return proto.CompactTextString(m) } func (*MsgDeleteGroupResponse) ProtoMessage() {} func (*MsgDeleteGroupResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{21} + return fileDescriptor_ddb71b028305a3cc, []int{23} } func (m *MsgDeleteGroupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1270,7 +1399,7 @@ func (m *MsgUpdateGroupMember) Reset() { *m = MsgUpdateGroupMember{} } func (m *MsgUpdateGroupMember) String() string { return proto.CompactTextString(m) } func (*MsgUpdateGroupMember) ProtoMessage() {} func (*MsgUpdateGroupMember) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{22} + return fileDescriptor_ddb71b028305a3cc, []int{24} } func (m *MsgUpdateGroupMember) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1341,7 +1470,7 @@ func (m *MsgUpdateGroupMemberResponse) Reset() { *m = MsgUpdateGroupMemb func (m *MsgUpdateGroupMemberResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateGroupMemberResponse) ProtoMessage() {} func (*MsgUpdateGroupMemberResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{23} + return fileDescriptor_ddb71b028305a3cc, []int{25} } func (m *MsgUpdateGroupMemberResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1385,7 +1514,7 @@ func (m *MsgRenewGroupMember) Reset() { *m = MsgRenewGroupMember{} } func (m *MsgRenewGroupMember) String() string { return proto.CompactTextString(m) } func (*MsgRenewGroupMember) ProtoMessage() {} func (*MsgRenewGroupMember) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{24} + return fileDescriptor_ddb71b028305a3cc, []int{26} } func (m *MsgRenewGroupMember) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1449,7 +1578,7 @@ func (m *MsgRenewGroupMemberResponse) Reset() { *m = MsgRenewGroupMember func (m *MsgRenewGroupMemberResponse) String() string { return proto.CompactTextString(m) } func (*MsgRenewGroupMemberResponse) ProtoMessage() {} func (*MsgRenewGroupMemberResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{25} + return fileDescriptor_ddb71b028305a3cc, []int{27} } func (m *MsgRenewGroupMemberResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1489,7 +1618,7 @@ func (m *MsgGroupMember) Reset() { *m = MsgGroupMember{} } func (m *MsgGroupMember) String() string { return proto.CompactTextString(m) } func (*MsgGroupMember) ProtoMessage() {} func (*MsgGroupMember) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{26} + return fileDescriptor_ddb71b028305a3cc, []int{28} } func (m *MsgGroupMember) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1547,7 +1676,7 @@ func (m *MsgUpdateGroupExtra) Reset() { *m = MsgUpdateGroupExtra{} } func (m *MsgUpdateGroupExtra) String() string { return proto.CompactTextString(m) } func (*MsgUpdateGroupExtra) ProtoMessage() {} func (*MsgUpdateGroupExtra) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{27} + return fileDescriptor_ddb71b028305a3cc, []int{29} } func (m *MsgUpdateGroupExtra) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1611,7 +1740,7 @@ func (m *MsgUpdateGroupExtraResponse) Reset() { *m = MsgUpdateGroupExtra func (m *MsgUpdateGroupExtraResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateGroupExtraResponse) ProtoMessage() {} func (*MsgUpdateGroupExtraResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{28} + return fileDescriptor_ddb71b028305a3cc, []int{30} } func (m *MsgUpdateGroupExtraResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1653,7 +1782,7 @@ func (m *MsgLeaveGroup) Reset() { *m = MsgLeaveGroup{} } func (m *MsgLeaveGroup) String() string { return proto.CompactTextString(m) } func (*MsgLeaveGroup) ProtoMessage() {} func (*MsgLeaveGroup) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{29} + return fileDescriptor_ddb71b028305a3cc, []int{31} } func (m *MsgLeaveGroup) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1710,7 +1839,7 @@ func (m *MsgLeaveGroupResponse) Reset() { *m = MsgLeaveGroupResponse{} } func (m *MsgLeaveGroupResponse) String() string { return proto.CompactTextString(m) } func (*MsgLeaveGroupResponse) ProtoMessage() {} func (*MsgLeaveGroupResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{30} + return fileDescriptor_ddb71b028305a3cc, []int{32} } func (m *MsgLeaveGroupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1759,7 +1888,7 @@ func (m *MsgUpdateBucketInfo) Reset() { *m = MsgUpdateBucketInfo{} } func (m *MsgUpdateBucketInfo) String() string { return proto.CompactTextString(m) } func (*MsgUpdateBucketInfo) ProtoMessage() {} func (*MsgUpdateBucketInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{31} + return fileDescriptor_ddb71b028305a3cc, []int{33} } func (m *MsgUpdateBucketInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1830,7 +1959,7 @@ func (m *MsgUpdateBucketInfoResponse) Reset() { *m = MsgUpdateBucketInfo func (m *MsgUpdateBucketInfoResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateBucketInfoResponse) ProtoMessage() {} func (*MsgUpdateBucketInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{32} + return fileDescriptor_ddb71b028305a3cc, []int{34} } func (m *MsgUpdateBucketInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1872,7 +2001,7 @@ func (m *MsgCancelCreateObject) Reset() { *m = MsgCancelCreateObject{} } func (m *MsgCancelCreateObject) String() string { return proto.CompactTextString(m) } func (*MsgCancelCreateObject) ProtoMessage() {} func (*MsgCancelCreateObject) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{33} + return fileDescriptor_ddb71b028305a3cc, []int{35} } func (m *MsgCancelCreateObject) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1929,7 +2058,7 @@ func (m *MsgCancelCreateObjectResponse) Reset() { *m = MsgCancelCreateOb func (m *MsgCancelCreateObjectResponse) String() string { return proto.CompactTextString(m) } func (*MsgCancelCreateObjectResponse) ProtoMessage() {} func (*MsgCancelCreateObjectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{34} + return fileDescriptor_ddb71b028305a3cc, []int{36} } func (m *MsgCancelCreateObjectResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1976,7 +2105,7 @@ func (m *MsgPutPolicy) Reset() { *m = MsgPutPolicy{} } func (m *MsgPutPolicy) String() string { return proto.CompactTextString(m) } func (*MsgPutPolicy) ProtoMessage() {} func (*MsgPutPolicy) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{35} + return fileDescriptor_ddb71b028305a3cc, []int{37} } func (m *MsgPutPolicy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2048,7 +2177,7 @@ func (m *MsgPutPolicyResponse) Reset() { *m = MsgPutPolicyResponse{} } func (m *MsgPutPolicyResponse) String() string { return proto.CompactTextString(m) } func (*MsgPutPolicyResponse) ProtoMessage() {} func (*MsgPutPolicyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{36} + return fileDescriptor_ddb71b028305a3cc, []int{38} } func (m *MsgPutPolicyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2090,7 +2219,7 @@ func (m *MsgDeletePolicy) Reset() { *m = MsgDeletePolicy{} } func (m *MsgDeletePolicy) String() string { return proto.CompactTextString(m) } func (*MsgDeletePolicy) ProtoMessage() {} func (*MsgDeletePolicy) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{37} + return fileDescriptor_ddb71b028305a3cc, []int{39} } func (m *MsgDeletePolicy) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2148,7 +2277,7 @@ func (m *MsgDeletePolicyResponse) Reset() { *m = MsgDeletePolicyResponse func (m *MsgDeletePolicyResponse) String() string { return proto.CompactTextString(m) } func (*MsgDeletePolicyResponse) ProtoMessage() {} func (*MsgDeletePolicyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{38} + return fileDescriptor_ddb71b028305a3cc, []int{40} } func (m *MsgDeletePolicyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2194,7 +2323,7 @@ func (m *MsgMirrorObject) Reset() { *m = MsgMirrorObject{} } func (m *MsgMirrorObject) String() string { return proto.CompactTextString(m) } func (*MsgMirrorObject) ProtoMessage() {} func (*MsgMirrorObject) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{39} + return fileDescriptor_ddb71b028305a3cc, []int{41} } func (m *MsgMirrorObject) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2258,7 +2387,7 @@ func (m *MsgMirrorObjectResponse) Reset() { *m = MsgMirrorObjectResponse func (m *MsgMirrorObjectResponse) String() string { return proto.CompactTextString(m) } func (*MsgMirrorObjectResponse) ProtoMessage() {} func (*MsgMirrorObjectResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{40} + return fileDescriptor_ddb71b028305a3cc, []int{42} } func (m *MsgMirrorObjectResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2302,7 +2431,7 @@ func (m *MsgMirrorBucket) Reset() { *m = MsgMirrorBucket{} } func (m *MsgMirrorBucket) String() string { return proto.CompactTextString(m) } func (*MsgMirrorBucket) ProtoMessage() {} func (*MsgMirrorBucket) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{41} + return fileDescriptor_ddb71b028305a3cc, []int{43} } func (m *MsgMirrorBucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2359,7 +2488,7 @@ func (m *MsgUpdateObjectInfoResponse) Reset() { *m = MsgUpdateObjectInfo func (m *MsgUpdateObjectInfoResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateObjectInfoResponse) ProtoMessage() {} func (*MsgUpdateObjectInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{42} + return fileDescriptor_ddb71b028305a3cc, []int{44} } func (m *MsgUpdateObjectInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2404,7 +2533,7 @@ func (m *MsgUpdateObjectInfo) Reset() { *m = MsgUpdateObjectInfo{} } func (m *MsgUpdateObjectInfo) String() string { return proto.CompactTextString(m) } func (*MsgUpdateObjectInfo) ProtoMessage() {} func (*MsgUpdateObjectInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{43} + return fileDescriptor_ddb71b028305a3cc, []int{45} } func (m *MsgUpdateObjectInfo) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2468,7 +2597,7 @@ func (m *MsgMirrorBucketResponse) Reset() { *m = MsgMirrorBucketResponse func (m *MsgMirrorBucketResponse) String() string { return proto.CompactTextString(m) } func (*MsgMirrorBucketResponse) ProtoMessage() {} func (*MsgMirrorBucketResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{44} + return fileDescriptor_ddb71b028305a3cc, []int{46} } func (m *MsgMirrorBucketResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2512,7 +2641,7 @@ func (m *MsgMirrorGroup) Reset() { *m = MsgMirrorGroup{} } func (m *MsgMirrorGroup) String() string { return proto.CompactTextString(m) } func (*MsgMirrorGroup) ProtoMessage() {} func (*MsgMirrorGroup) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{45} + return fileDescriptor_ddb71b028305a3cc, []int{47} } func (m *MsgMirrorGroup) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2569,7 +2698,7 @@ func (m *MsgMirrorGroupResponse) Reset() { *m = MsgMirrorGroupResponse{} func (m *MsgMirrorGroupResponse) String() string { return proto.CompactTextString(m) } func (*MsgMirrorGroupResponse) ProtoMessage() {} func (*MsgMirrorGroupResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{46} + return fileDescriptor_ddb71b028305a3cc, []int{48} } func (m *MsgMirrorGroupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2611,7 +2740,7 @@ func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } func (*MsgUpdateParams) ProtoMessage() {} func (*MsgUpdateParams) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{47} + return fileDescriptor_ddb71b028305a3cc, []int{49} } func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2662,7 +2791,7 @@ func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateParamsResponse) ProtoMessage() {} func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{48} + return fileDescriptor_ddb71b028305a3cc, []int{50} } func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2706,7 +2835,7 @@ func (m *MsgMigrateBucket) Reset() { *m = MsgMigrateBucket{} } func (m *MsgMigrateBucket) String() string { return proto.CompactTextString(m) } func (*MsgMigrateBucket) ProtoMessage() {} func (*MsgMigrateBucket) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{49} + return fileDescriptor_ddb71b028305a3cc, []int{51} } func (m *MsgMigrateBucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2770,7 +2899,7 @@ func (m *MsgMigrateBucketResponse) Reset() { *m = MsgMigrateBucketRespon func (m *MsgMigrateBucketResponse) String() string { return proto.CompactTextString(m) } func (*MsgMigrateBucketResponse) ProtoMessage() {} func (*MsgMigrateBucketResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{50} + return fileDescriptor_ddb71b028305a3cc, []int{52} } func (m *MsgMigrateBucketResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2815,7 +2944,7 @@ func (m *MsgCompleteMigrateBucket) Reset() { *m = MsgCompleteMigrateBuck func (m *MsgCompleteMigrateBucket) String() string { return proto.CompactTextString(m) } func (*MsgCompleteMigrateBucket) ProtoMessage() {} func (*MsgCompleteMigrateBucket) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{51} + return fileDescriptor_ddb71b028305a3cc, []int{53} } func (m *MsgCompleteMigrateBucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2879,7 +3008,7 @@ func (m *MsgCompleteMigrateBucketResponse) Reset() { *m = MsgCompleteMig func (m *MsgCompleteMigrateBucketResponse) String() string { return proto.CompactTextString(m) } func (*MsgCompleteMigrateBucketResponse) ProtoMessage() {} func (*MsgCompleteMigrateBucketResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{52} + return fileDescriptor_ddb71b028305a3cc, []int{54} } func (m *MsgCompleteMigrateBucketResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2920,7 +3049,7 @@ func (m *MsgCancelMigrateBucket) Reset() { *m = MsgCancelMigrateBucket{} func (m *MsgCancelMigrateBucket) String() string { return proto.CompactTextString(m) } func (*MsgCancelMigrateBucket) ProtoMessage() {} func (*MsgCancelMigrateBucket) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{53} + return fileDescriptor_ddb71b028305a3cc, []int{55} } func (m *MsgCancelMigrateBucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2970,7 +3099,7 @@ func (m *MsgCancelMigrateBucketResponse) Reset() { *m = MsgCancelMigrate func (m *MsgCancelMigrateBucketResponse) String() string { return proto.CompactTextString(m) } func (*MsgCancelMigrateBucketResponse) ProtoMessage() {} func (*MsgCancelMigrateBucketResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{54} + return fileDescriptor_ddb71b028305a3cc, []int{56} } func (m *MsgCancelMigrateBucketResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3011,7 +3140,7 @@ func (m *MsgRejectMigrateBucket) Reset() { *m = MsgRejectMigrateBucket{} func (m *MsgRejectMigrateBucket) String() string { return proto.CompactTextString(m) } func (*MsgRejectMigrateBucket) ProtoMessage() {} func (*MsgRejectMigrateBucket) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{55} + return fileDescriptor_ddb71b028305a3cc, []int{57} } func (m *MsgRejectMigrateBucket) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3061,7 +3190,7 @@ func (m *MsgRejectMigrateBucketResponse) Reset() { *m = MsgRejectMigrate func (m *MsgRejectMigrateBucketResponse) String() string { return proto.CompactTextString(m) } func (*MsgRejectMigrateBucketResponse) ProtoMessage() {} func (*MsgRejectMigrateBucketResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{56} + return fileDescriptor_ddb71b028305a3cc, []int{58} } func (m *MsgRejectMigrateBucketResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3103,7 +3232,7 @@ func (m *MsgSetTag) Reset() { *m = MsgSetTag{} } func (m *MsgSetTag) String() string { return proto.CompactTextString(m) } func (*MsgSetTag) ProtoMessage() {} func (*MsgSetTag) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{57} + return fileDescriptor_ddb71b028305a3cc, []int{59} } func (m *MsgSetTag) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3160,7 +3289,7 @@ func (m *MsgSetTagResponse) Reset() { *m = MsgSetTagResponse{} } func (m *MsgSetTagResponse) String() string { return proto.CompactTextString(m) } func (*MsgSetTagResponse) ProtoMessage() {} func (*MsgSetTagResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{58} + return fileDescriptor_ddb71b028305a3cc, []int{60} } func (m *MsgSetTagResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3208,7 +3337,7 @@ func (m *MsgUpdateObjectContent) Reset() { *m = MsgUpdateObjectContent{} func (m *MsgUpdateObjectContent) String() string { return proto.CompactTextString(m) } func (*MsgUpdateObjectContent) ProtoMessage() {} func (*MsgUpdateObjectContent) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{59} + return fileDescriptor_ddb71b028305a3cc, []int{61} } func (m *MsgUpdateObjectContent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3286,7 +3415,7 @@ func (m *MsgUpdateObjectContentResponse) Reset() { *m = MsgUpdateObjectC func (m *MsgUpdateObjectContentResponse) String() string { return proto.CompactTextString(m) } func (*MsgUpdateObjectContentResponse) ProtoMessage() {} func (*MsgUpdateObjectContentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{60} + return fileDescriptor_ddb71b028305a3cc, []int{62} } func (m *MsgUpdateObjectContentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3328,7 +3457,7 @@ func (m *MsgCancelUpdateObjectContent) Reset() { *m = MsgCancelUpdateObj func (m *MsgCancelUpdateObjectContent) String() string { return proto.CompactTextString(m) } func (*MsgCancelUpdateObjectContent) ProtoMessage() {} func (*MsgCancelUpdateObjectContent) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{61} + return fileDescriptor_ddb71b028305a3cc, []int{63} } func (m *MsgCancelUpdateObjectContent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3385,7 +3514,7 @@ func (m *MsgCancelUpdateObjectContentResponse) Reset() { *m = MsgCancelU func (m *MsgCancelUpdateObjectContentResponse) String() string { return proto.CompactTextString(m) } func (*MsgCancelUpdateObjectContentResponse) ProtoMessage() {} func (*MsgCancelUpdateObjectContentResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_ddb71b028305a3cc, []int{62} + return fileDescriptor_ddb71b028305a3cc, []int{64} } func (m *MsgCancelUpdateObjectContentResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -3414,2380 +3543,1951 @@ func (m *MsgCancelUpdateObjectContentResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgCancelUpdateObjectContentResponse proto.InternalMessageInfo -func init() { - proto.RegisterType((*MsgCreateBucket)(nil), "greenfield.storage.MsgCreateBucket") - proto.RegisterType((*MsgCreateBucketResponse)(nil), "greenfield.storage.MsgCreateBucketResponse") - proto.RegisterType((*MsgDeleteBucket)(nil), "greenfield.storage.MsgDeleteBucket") - proto.RegisterType((*MsgDeleteBucketResponse)(nil), "greenfield.storage.MsgDeleteBucketResponse") - proto.RegisterType((*MsgDiscontinueBucket)(nil), "greenfield.storage.MsgDiscontinueBucket") - proto.RegisterType((*MsgDiscontinueBucketResponse)(nil), "greenfield.storage.MsgDiscontinueBucketResponse") - proto.RegisterType((*MsgCreateObject)(nil), "greenfield.storage.MsgCreateObject") - proto.RegisterType((*MsgCreateObjectResponse)(nil), "greenfield.storage.MsgCreateObjectResponse") - proto.RegisterType((*MsgSealObject)(nil), "greenfield.storage.MsgSealObject") - proto.RegisterType((*MsgSealObjectResponse)(nil), "greenfield.storage.MsgSealObjectResponse") - proto.RegisterType((*MsgRejectSealObject)(nil), "greenfield.storage.MsgRejectSealObject") - proto.RegisterType((*MsgRejectSealObjectResponse)(nil), "greenfield.storage.MsgRejectSealObjectResponse") - proto.RegisterType((*MsgCopyObject)(nil), "greenfield.storage.MsgCopyObject") - proto.RegisterType((*MsgCopyObjectResponse)(nil), "greenfield.storage.MsgCopyObjectResponse") - proto.RegisterType((*MsgDeleteObject)(nil), "greenfield.storage.MsgDeleteObject") - proto.RegisterType((*MsgDeleteObjectResponse)(nil), "greenfield.storage.MsgDeleteObjectResponse") - proto.RegisterType((*MsgDiscontinueObject)(nil), "greenfield.storage.MsgDiscontinueObject") - proto.RegisterType((*MsgDiscontinueObjectResponse)(nil), "greenfield.storage.MsgDiscontinueObjectResponse") - proto.RegisterType((*MsgCreateGroup)(nil), "greenfield.storage.MsgCreateGroup") - proto.RegisterType((*MsgCreateGroupResponse)(nil), "greenfield.storage.MsgCreateGroupResponse") - proto.RegisterType((*MsgDeleteGroup)(nil), "greenfield.storage.MsgDeleteGroup") - proto.RegisterType((*MsgDeleteGroupResponse)(nil), "greenfield.storage.MsgDeleteGroupResponse") - proto.RegisterType((*MsgUpdateGroupMember)(nil), "greenfield.storage.MsgUpdateGroupMember") - proto.RegisterType((*MsgUpdateGroupMemberResponse)(nil), "greenfield.storage.MsgUpdateGroupMemberResponse") - proto.RegisterType((*MsgRenewGroupMember)(nil), "greenfield.storage.MsgRenewGroupMember") - proto.RegisterType((*MsgRenewGroupMemberResponse)(nil), "greenfield.storage.MsgRenewGroupMemberResponse") - proto.RegisterType((*MsgGroupMember)(nil), "greenfield.storage.MsgGroupMember") - proto.RegisterType((*MsgUpdateGroupExtra)(nil), "greenfield.storage.MsgUpdateGroupExtra") - proto.RegisterType((*MsgUpdateGroupExtraResponse)(nil), "greenfield.storage.MsgUpdateGroupExtraResponse") - proto.RegisterType((*MsgLeaveGroup)(nil), "greenfield.storage.MsgLeaveGroup") - proto.RegisterType((*MsgLeaveGroupResponse)(nil), "greenfield.storage.MsgLeaveGroupResponse") - proto.RegisterType((*MsgUpdateBucketInfo)(nil), "greenfield.storage.MsgUpdateBucketInfo") - proto.RegisterType((*MsgUpdateBucketInfoResponse)(nil), "greenfield.storage.MsgUpdateBucketInfoResponse") - proto.RegisterType((*MsgCancelCreateObject)(nil), "greenfield.storage.MsgCancelCreateObject") - proto.RegisterType((*MsgCancelCreateObjectResponse)(nil), "greenfield.storage.MsgCancelCreateObjectResponse") - proto.RegisterType((*MsgPutPolicy)(nil), "greenfield.storage.MsgPutPolicy") - proto.RegisterType((*MsgPutPolicyResponse)(nil), "greenfield.storage.MsgPutPolicyResponse") - proto.RegisterType((*MsgDeletePolicy)(nil), "greenfield.storage.MsgDeletePolicy") - proto.RegisterType((*MsgDeletePolicyResponse)(nil), "greenfield.storage.MsgDeletePolicyResponse") - proto.RegisterType((*MsgMirrorObject)(nil), "greenfield.storage.MsgMirrorObject") - proto.RegisterType((*MsgMirrorObjectResponse)(nil), "greenfield.storage.MsgMirrorObjectResponse") - proto.RegisterType((*MsgMirrorBucket)(nil), "greenfield.storage.MsgMirrorBucket") - proto.RegisterType((*MsgUpdateObjectInfoResponse)(nil), "greenfield.storage.MsgUpdateObjectInfoResponse") - proto.RegisterType((*MsgUpdateObjectInfo)(nil), "greenfield.storage.MsgUpdateObjectInfo") - proto.RegisterType((*MsgMirrorBucketResponse)(nil), "greenfield.storage.MsgMirrorBucketResponse") - proto.RegisterType((*MsgMirrorGroup)(nil), "greenfield.storage.MsgMirrorGroup") - proto.RegisterType((*MsgMirrorGroupResponse)(nil), "greenfield.storage.MsgMirrorGroupResponse") - proto.RegisterType((*MsgUpdateParams)(nil), "greenfield.storage.MsgUpdateParams") - proto.RegisterType((*MsgUpdateParamsResponse)(nil), "greenfield.storage.MsgUpdateParamsResponse") - proto.RegisterType((*MsgMigrateBucket)(nil), "greenfield.storage.MsgMigrateBucket") - proto.RegisterType((*MsgMigrateBucketResponse)(nil), "greenfield.storage.MsgMigrateBucketResponse") - proto.RegisterType((*MsgCompleteMigrateBucket)(nil), "greenfield.storage.MsgCompleteMigrateBucket") - proto.RegisterType((*MsgCompleteMigrateBucketResponse)(nil), "greenfield.storage.MsgCompleteMigrateBucketResponse") - proto.RegisterType((*MsgCancelMigrateBucket)(nil), "greenfield.storage.MsgCancelMigrateBucket") - proto.RegisterType((*MsgCancelMigrateBucketResponse)(nil), "greenfield.storage.MsgCancelMigrateBucketResponse") - proto.RegisterType((*MsgRejectMigrateBucket)(nil), "greenfield.storage.MsgRejectMigrateBucket") - proto.RegisterType((*MsgRejectMigrateBucketResponse)(nil), "greenfield.storage.MsgRejectMigrateBucketResponse") - proto.RegisterType((*MsgSetTag)(nil), "greenfield.storage.MsgSetTag") - proto.RegisterType((*MsgSetTagResponse)(nil), "greenfield.storage.MsgSetTagResponse") - proto.RegisterType((*MsgUpdateObjectContent)(nil), "greenfield.storage.MsgUpdateObjectContent") - proto.RegisterType((*MsgUpdateObjectContentResponse)(nil), "greenfield.storage.MsgUpdateObjectContentResponse") - proto.RegisterType((*MsgCancelUpdateObjectContent)(nil), "greenfield.storage.MsgCancelUpdateObjectContent") - proto.RegisterType((*MsgCancelUpdateObjectContentResponse)(nil), "greenfield.storage.MsgCancelUpdateObjectContentResponse") +type MsgDelegateCreateObject struct { + // operator defines the account address of the operator, it is the delegated agent that allows to creat object under bucket. + Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"` + // creator defines the account address of the object creator. + Creator string `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"` + // bucket_name defines the name of the bucket where the object is stored. + BucketName string `protobuf:"bytes,3,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` + // object_name defines the name of object + ObjectName string `protobuf:"bytes,4,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"` + // payload_size defines size of the object's payload + PayloadSize uint64 `protobuf:"varint,5,opt,name=payload_size,json=payloadSize,proto3" json:"payload_size,omitempty"` + // content_type define the format of the object which should be a standard MIME type. + ContentType string `protobuf:"bytes,6,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"` + // visibility means the object is private or public. if private, only object owner or grantee can access it, + // otherwise every greenfield user can access it. + Visibility VisibilityType `protobuf:"varint,7,opt,name=visibility,proto3,enum=greenfield.storage.VisibilityType" json:"visibility,omitempty"` + // expect_checksums defines a list of hashes which was generate by redundancy algorithm. + ExpectChecksums [][]byte `protobuf:"bytes,8,rep,name=expect_checksums,json=expectChecksums,proto3" json:"expect_checksums,omitempty"` + // redundancy_type can be ec or replica + RedundancyType RedundancyType `protobuf:"varint,9,opt,name=redundancy_type,json=redundancyType,proto3,enum=greenfield.storage.RedundancyType" json:"redundancy_type,omitempty"` } -func init() { proto.RegisterFile("greenfield/storage/tx.proto", fileDescriptor_ddb71b028305a3cc) } - -var fileDescriptor_ddb71b028305a3cc = []byte{ - // 2431 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x4b, 0x6c, 0x1b, 0xc7, - 0x19, 0x36, 0x25, 0x4a, 0x32, 0x7f, 0xea, 0x61, 0xaf, 0x95, 0x98, 0xa6, 0x6b, 0x8a, 0x66, 0x52, - 0x47, 0x7e, 0x89, 0x8e, 0xea, 0x1a, 0xae, 0x51, 0x14, 0x95, 0x94, 0xc6, 0x25, 0x12, 0xc5, 0xca, - 0xca, 0x76, 0x81, 0x00, 0x05, 0x33, 0xe4, 0x8e, 0xd7, 0xdb, 0x90, 0xbb, 0xdb, 0x9d, 0xa5, 0x6c, - 0xa6, 0x40, 0x0f, 0xbd, 0xe4, 0x54, 0xc0, 0x40, 0x7a, 0xe8, 0xa1, 0xe8, 0xa1, 0x40, 0x81, 0x5e, - 0x5a, 0x14, 0x45, 0xce, 0x45, 0x2f, 0x01, 0x8c, 0x9e, 0x8c, 0x9c, 0x8a, 0x1e, 0xdc, 0xc0, 0x2e, - 0x50, 0xf4, 0xda, 0x4b, 0xaf, 0xc1, 0x3c, 0x76, 0x76, 0xb8, 0x4f, 0x4a, 0x96, 0x62, 0x9d, 0xa4, - 0x9d, 0xf9, 0x66, 0xe6, 0x7f, 0xcf, 0x3f, 0xff, 0x4f, 0x38, 0x6d, 0x7a, 0x18, 0xdb, 0xf7, 0x2c, - 0xdc, 0x33, 0x9a, 0xc4, 0x77, 0x3c, 0x64, 0xe2, 0xa6, 0xff, 0x70, 0xc5, 0xf5, 0x1c, 0xdf, 0xd1, - 0xb4, 0x70, 0x72, 0x45, 0x4c, 0x56, 0x4f, 0x76, 0x1d, 0xd2, 0x77, 0x48, 0xb3, 0x4f, 0xcc, 0xe6, - 0xce, 0x9b, 0xf4, 0x0f, 0x07, 0x57, 0x4f, 0xf1, 0x89, 0x36, 0xfb, 0x6a, 0xf2, 0x0f, 0x31, 0xb5, - 0x68, 0x3a, 0xa6, 0xc3, 0xc7, 0xe9, 0x7f, 0x62, 0x74, 0xc9, 0x74, 0x1c, 0xb3, 0x87, 0x9b, 0xec, - 0xab, 0x33, 0xb8, 0xd7, 0xf4, 0xad, 0x3e, 0x26, 0x3e, 0xea, 0xbb, 0x02, 0x50, 0x57, 0x68, 0xeb, - 0x3a, 0xfd, 0xbe, 0x63, 0x37, 0x91, 0xeb, 0x7a, 0xce, 0x0e, 0xea, 0xc9, 0x2d, 0x62, 0x88, 0x07, - 0x1e, 0x72, 0x5d, 0xec, 0x09, 0x40, 0x43, 0x01, 0xb8, 0xd8, 0xeb, 0x5b, 0x84, 0x58, 0x8e, 0x2d, - 0xb0, 0x09, 0x9b, 0x04, 0x22, 0xc8, 0x05, 0xb8, 0xc8, 0x43, 0xfd, 0x80, 0xbf, 0x5a, 0x92, 0x10, - 0x87, 0x2e, 0x16, 0xf3, 0x8d, 0xbf, 0x4e, 0xc2, 0xc2, 0x26, 0x31, 0x37, 0x3c, 0x8c, 0x7c, 0xbc, - 0x3e, 0xe8, 0x7e, 0x84, 0x7d, 0x6d, 0x15, 0x66, 0xba, 0xf4, 0xdb, 0xf1, 0x2a, 0x85, 0x7a, 0x61, - 0xb9, 0xb4, 0x5e, 0xf9, 0xe2, 0xb3, 0xcb, 0x8b, 0x42, 0x6c, 0x6b, 0x86, 0xe1, 0x61, 0x42, 0xb6, - 0x7d, 0xcf, 0xb2, 0x4d, 0x3d, 0x00, 0x6a, 0x4b, 0x50, 0xee, 0xb0, 0xd5, 0x6d, 0x1b, 0xf5, 0x71, - 0x65, 0x82, 0xae, 0xd3, 0x81, 0x0f, 0xbd, 0x87, 0xfa, 0x58, 0x5b, 0x07, 0xd8, 0xb1, 0x88, 0xd5, - 0xb1, 0x7a, 0x96, 0x3f, 0xac, 0x4c, 0xd6, 0x0b, 0xcb, 0xf3, 0xab, 0x8d, 0x95, 0xb8, 0x16, 0x57, - 0xee, 0x4a, 0xd4, 0xed, 0xa1, 0x8b, 0x75, 0x65, 0x95, 0xb6, 0x06, 0x0b, 0x2e, 0x1a, 0xf6, 0xb1, - 0xed, 0xb7, 0x11, 0x27, 0xa3, 0x52, 0xcc, 0x21, 0x70, 0x5e, 0x2c, 0x10, 0xa3, 0xda, 0xdb, 0xa0, - 0xb9, 0x9e, 0xd5, 0x47, 0xde, 0xb0, 0x4d, 0x5c, 0xb9, 0xcb, 0x54, 0xce, 0x2e, 0xc7, 0xc4, 0x9a, - 0x6d, 0x37, 0xd8, 0xe7, 0x1d, 0x38, 0xa1, 0xee, 0x23, 0x74, 0x5f, 0x99, 0xae, 0x17, 0x96, 0xcb, - 0xab, 0xa7, 0x55, 0xbe, 0x84, 0xbe, 0xd6, 0x04, 0x44, 0x3f, 0x1e, 0xee, 0x25, 0x86, 0xb4, 0x4b, - 0xa0, 0x75, 0xef, 0x23, 0xcf, 0xc4, 0x46, 0xdb, 0xc3, 0xc8, 0x68, 0xff, 0x74, 0xe0, 0xf8, 0xa8, - 0x32, 0x53, 0x2f, 0x2c, 0x17, 0xf5, 0x63, 0x62, 0x46, 0xc7, 0xc8, 0x78, 0x9f, 0x8e, 0xdf, 0x98, - 0xfd, 0xc5, 0x7f, 0xfe, 0x7c, 0x21, 0x10, 0x7c, 0x63, 0x1b, 0x4e, 0x46, 0xf4, 0xa7, 0x63, 0xe2, - 0x3a, 0x36, 0xc1, 0xda, 0x75, 0x28, 0x09, 0x9d, 0x58, 0x86, 0xd0, 0xe4, 0xe9, 0xc7, 0x4f, 0x97, - 0x8e, 0xfc, 0xf3, 0xe9, 0x52, 0xf1, 0x8e, 0x65, 0xfb, 0x5f, 0x7c, 0x76, 0xb9, 0x2c, 0xd8, 0xa5, - 0x9f, 0xfa, 0x51, 0x8e, 0x6e, 0x19, 0x8d, 0x07, 0xcc, 0x28, 0xde, 0xc2, 0x3d, 0x2c, 0x8d, 0xe2, - 0x2a, 0x1c, 0x75, 0x5c, 0xec, 0x8d, 0x65, 0x15, 0x12, 0x99, 0x6b, 0x16, 0x37, 0xe6, 0x28, 0x33, - 0x12, 0xdf, 0x38, 0xc5, 0xb8, 0x51, 0x0f, 0x0e, 0xb8, 0x69, 0xfc, 0xaa, 0x00, 0x8b, 0x74, 0xce, - 0x22, 0x5d, 0xc7, 0xf6, 0x2d, 0x7b, 0x70, 0xb0, 0x94, 0x69, 0xaf, 0xc2, 0xb4, 0x87, 0x11, 0x71, - 0x6c, 0x66, 0xac, 0x25, 0x5d, 0x7c, 0x45, 0x29, 0xae, 0xc1, 0x37, 0x92, 0xa8, 0x92, 0x64, 0xff, - 0x5b, 0x75, 0xb0, 0x5b, 0x9d, 0x9f, 0xe0, 0xee, 0x01, 0x39, 0xd8, 0x12, 0x94, 0x1d, 0xb6, 0x3d, - 0x07, 0x70, 0xa2, 0x81, 0x0f, 0x31, 0xc0, 0x59, 0x98, 0x75, 0xd1, 0xb0, 0xe7, 0x20, 0xa3, 0x4d, - 0xac, 0x8f, 0x31, 0x73, 0x9d, 0xa2, 0x5e, 0x16, 0x63, 0xdb, 0xd6, 0xc7, 0x51, 0x27, 0x9d, 0xda, - 0x93, 0x93, 0x9e, 0x85, 0x59, 0x2a, 0x0a, 0xea, 0xa4, 0x34, 0xd0, 0x30, 0x97, 0x28, 0xe9, 0x65, - 0x31, 0x46, 0xe1, 0x69, 0xce, 0x33, 0xb3, 0x27, 0xe7, 0x39, 0x0f, 0xc7, 0xf0, 0x43, 0x97, 0xf2, - 0xdd, 0xbd, 0x8f, 0xbb, 0x1f, 0x91, 0x41, 0x9f, 0x54, 0x8e, 0xd6, 0x27, 0x97, 0x67, 0xf5, 0x05, - 0x3e, 0xbe, 0x11, 0x0c, 0x6b, 0xef, 0xc0, 0x82, 0x87, 0x8d, 0x81, 0x6d, 0x20, 0xbb, 0x3b, 0xe4, - 0xd4, 0x95, 0xd2, 0x79, 0xd4, 0x25, 0x94, 0xf1, 0x38, 0xef, 0x8d, 0x7c, 0x67, 0xb8, 0x21, 0xd7, - 0xb2, 0xea, 0x86, 0x42, 0x31, 0x63, 0xba, 0x21, 0x47, 0xb7, 0x8c, 0xc6, 0xa7, 0x13, 0x30, 0xb7, - 0x49, 0xcc, 0x6d, 0x8c, 0x7a, 0xc2, 0x72, 0x0e, 0xc8, 0xd6, 0x73, 0x6d, 0xe7, 0xdb, 0x70, 0xd2, - 0xec, 0x39, 0x1d, 0xd4, 0x6b, 0xef, 0x58, 0x9e, 0x3f, 0x40, 0xbd, 0xb6, 0xe9, 0x39, 0x03, 0x97, - 0x72, 0x44, 0xcd, 0x68, 0x4e, 0x5f, 0xe4, 0xd3, 0x77, 0xf9, 0xec, 0x4d, 0x3a, 0xd9, 0x32, 0xb4, - 0xb7, 0x60, 0x89, 0xe0, 0xae, 0x63, 0x1b, 0x42, 0xd5, 0x9d, 0x1e, 0x69, 0x23, 0xd3, 0x6c, 0x13, - 0xcb, 0xb4, 0x91, 0x3f, 0xf0, 0x30, 0x0f, 0xbd, 0xb3, 0xfa, 0x69, 0x09, 0xdb, 0x76, 0xd7, 0x7b, - 0x64, 0xcd, 0x34, 0xb7, 0x25, 0x24, 0xea, 0x71, 0x27, 0xe1, 0x95, 0x11, 0xa1, 0x48, 0x57, 0xfb, - 0x4d, 0x01, 0x4e, 0x6c, 0x12, 0x53, 0xc7, 0x74, 0xf4, 0xe5, 0x0b, 0x2d, 0x4a, 0xf7, 0x19, 0x38, - 0x9d, 0x40, 0x9d, 0xa4, 0xfe, 0x4f, 0x5c, 0xd9, 0x1b, 0x8e, 0x3b, 0x14, 0x74, 0x57, 0xa3, 0x74, - 0x2b, 0xd4, 0x9d, 0x83, 0x05, 0xe2, 0x75, 0xdb, 0x71, 0x0a, 0xe7, 0x88, 0xd7, 0x5d, 0x0f, 0x89, - 0x3c, 0x07, 0x0b, 0x06, 0xf1, 0x47, 0x70, 0x9c, 0xd0, 0x39, 0x83, 0xf8, 0xa3, 0x38, 0xba, 0x9f, - 0xca, 0x50, 0x51, 0xee, 0x77, 0x2b, 0x34, 0x04, 0xb1, 0x9f, 0x8a, 0x9b, 0x92, 0xfb, 0x29, 0x38, - 0x1d, 0x4e, 0x52, 0xdc, 0x1e, 0xef, 0xc8, 0x45, 0x83, 0xf8, 0x5b, 0x51, 0x4f, 0x8f, 0xca, 0xf3, - 0x7d, 0x66, 0x07, 0xa1, 0xbc, 0xf6, 0xc1, 0xe1, 0x7e, 0x5d, 0x50, 0x2e, 0xbe, 0xc3, 0x65, 0x3d, - 0xea, 0xcd, 0x18, 0xb1, 0x9c, 0x27, 0xb1, 0x9b, 0xf1, 0x60, 0x49, 0xbf, 0x01, 0x20, 0xe5, 0x4b, - 0x2a, 0x93, 0xf5, 0xc9, 0x3c, 0x01, 0x97, 0x02, 0x01, 0x13, 0xe5, 0x56, 0x2d, 0xee, 0xea, 0x56, - 0x8d, 0xb0, 0xfc, 0x49, 0x01, 0xe6, 0x65, 0xbc, 0x65, 0xd1, 0x66, 0x4f, 0x97, 0xea, 0x19, 0x00, - 0x1e, 0xc7, 0x14, 0x4e, 0x4b, 0x6c, 0x84, 0x31, 0xba, 0x08, 0x53, 0xf8, 0xa1, 0xef, 0x21, 0xa1, - 0x1d, 0xfe, 0x11, 0x09, 0xfc, 0x5b, 0xf0, 0xea, 0x28, 0x21, 0xd2, 0x0c, 0xaf, 0xc1, 0x51, 0x19, - 0x24, 0xc7, 0xb0, 0xc2, 0x19, 0x93, 0x07, 0xcd, 0x86, 0xcf, 0x58, 0xe3, 0x9a, 0xe6, 0xac, 0xed, - 0x4d, 0x8f, 0xd9, 0xcc, 0x45, 0x25, 0x5e, 0x61, 0x7c, 0x28, 0xa7, 0x4a, 0x59, 0x7f, 0x3e, 0xc1, - 0xcc, 0xeb, 0x8e, 0x6b, 0x04, 0x2c, 0x6e, 0xe2, 0x7e, 0x07, 0x7b, 0x7b, 0x24, 0xeb, 0x3b, 0x50, - 0xe6, 0x64, 0x39, 0x0f, 0x6c, 0xec, 0x71, 0xba, 0x32, 0x16, 0x72, 0x1e, 0x6e, 0x51, 0x6c, 0x84, - 0xa3, 0xc9, 0xa8, 0xba, 0x7e, 0x08, 0xf3, 0x7d, 0x46, 0x19, 0x69, 0xfb, 0x0e, 0xcd, 0xed, 0x2b, - 0xc5, 0xfa, 0xe4, 0x72, 0x39, 0xf9, 0x76, 0xdf, 0x24, 0xa6, 0xc2, 0x8b, 0x3e, 0x2b, 0x56, 0xde, - 0x76, 0xd6, 0x0c, 0x7a, 0x6f, 0x1d, 0x57, 0x76, 0x32, 0x98, 0x50, 0x2a, 0x53, 0xcc, 0xd0, 0xd3, - 0x29, 0x5d, 0x90, 0x5b, 0x70, 0x29, 0x26, 0xdb, 0x74, 0x4c, 0x8c, 0x52, 0xce, 0xff, 0x0b, 0xae, - 0x2f, 0x1b, 0x3f, 0x38, 0xcc, 0x62, 0xfe, 0x2e, 0xcc, 0x08, 0x4e, 0x77, 0x21, 0xdf, 0x60, 0x49, - 0xda, 0xa5, 0x38, 0xca, 0xb3, 0x94, 0xc9, 0x2f, 0xb9, 0x9f, 0xab, 0xe2, 0xb8, 0x02, 0xd3, 0x7c, - 0xaf, 0x5c, 0x61, 0x08, 0x9c, 0xd6, 0x02, 0x9a, 0x09, 0x5a, 0x1e, 0xf2, 0x2d, 0xc7, 0x6e, 0xd3, - 0xa7, 0x3c, 0x13, 0x47, 0x79, 0xb5, 0xba, 0xc2, 0xdf, 0xf9, 0x2b, 0xc1, 0x3b, 0x7f, 0xe5, 0x76, - 0xf0, 0xce, 0x5f, 0x2f, 0x3e, 0xfa, 0xd7, 0x52, 0x41, 0x9f, 0x0f, 0x17, 0xd2, 0xa9, 0xc6, 0xdf, - 0xb9, 0x8e, 0x14, 0x25, 0xfe, 0x80, 0xc6, 0x84, 0x43, 0xa7, 0x23, 0x19, 0xb9, 0x8a, 0x6a, 0xe4, - 0x4a, 0x94, 0x7d, 0x94, 0x17, 0x29, 0xfb, 0x3f, 0x14, 0x58, 0x42, 0xf2, 0x2e, 0x46, 0x3b, 0x22, - 0x0e, 0xed, 0x5e, 0xf4, 0x07, 0xc6, 0xe1, 0x8d, 0x32, 0xe5, 0x45, 0x1c, 0x23, 0x52, 0xc2, 0x90, - 0xd2, 0xf0, 0x6a, 0x9c, 0x50, 0xf4, 0xc5, 0xd3, 0x9d, 0x96, 0x7d, 0xcf, 0x39, 0xa8, 0x9b, 0xf1, - 0xdd, 0xc4, 0x87, 0xfc, 0x24, 0x33, 0xb6, 0x5a, 0x42, 0xc2, 0x73, 0xa7, 0x65, 0xfb, 0xd7, 0xae, - 0xde, 0x45, 0xbd, 0x01, 0x8e, 0x3f, 0xf4, 0xf7, 0xa3, 0xdc, 0xb1, 0x0f, 0x0f, 0xba, 0x2c, 0xab, - 0x09, 0x25, 0x2a, 0x25, 0xfe, 0xdb, 0x02, 0x4f, 0xcb, 0x90, 0xdd, 0xc5, 0xbd, 0x91, 0x57, 0xef, - 0x21, 0x49, 0xa4, 0x96, 0xe0, 0x4c, 0x22, 0x7d, 0x92, 0x83, 0xbf, 0x4d, 0xc0, 0xec, 0x26, 0x31, - 0xb7, 0x06, 0xfe, 0x96, 0xd3, 0xb3, 0xba, 0xc3, 0x3d, 0x12, 0xfe, 0x3d, 0x28, 0xb9, 0x9e, 0x65, - 0x77, 0x2d, 0x17, 0xf5, 0x44, 0xbc, 0xa9, 0xab, 0x92, 0x0f, 0x6b, 0x7e, 0x2b, 0x5b, 0x01, 0x4e, - 0x0f, 0x97, 0xd0, 0xec, 0xdf, 0xc3, 0xc4, 0x19, 0x78, 0xdd, 0x80, 0x29, 0xf9, 0xad, 0x7d, 0x1f, - 0x80, 0xf8, 0xc8, 0xc7, 0x54, 0xd5, 0x41, 0x14, 0x4e, 0xdb, 0x7c, 0x3b, 0x00, 0xea, 0xca, 0x1a, - 0x6d, 0x33, 0x1e, 0x13, 0x67, 0x72, 0x63, 0xe2, 0xd1, 0xc7, 0x4f, 0x97, 0x0a, 0x49, 0x71, 0x31, - 0x2a, 0xe3, 0x2d, 0x96, 0x31, 0x48, 0x09, 0xaa, 0x99, 0xb9, 0xcb, 0x46, 0x82, 0x87, 0x63, 0x5e, - 0x66, 0xce, 0xd1, 0x2d, 0xa3, 0xf1, 0x17, 0x35, 0x33, 0x3f, 0xac, 0x7a, 0x89, 0x8a, 0x61, 0x5b, - 0xc9, 0xd9, 0xf7, 0x4d, 0x12, 0xff, 0xe5, 0x92, 0xd8, 0xb4, 0x3c, 0xcf, 0xf1, 0x5e, 0xc8, 0xb5, - 0x2e, 0xc2, 0x84, 0x65, 0x88, 0x98, 0x9c, 0x79, 0xf8, 0x84, 0x65, 0x44, 0xfd, 0x70, 0x32, 0xcf, - 0x0f, 0x8b, 0xb1, 0x1a, 0x42, 0x03, 0xe6, 0x0c, 0x4c, 0xfc, 0x76, 0xf7, 0x3e, 0xb2, 0x6c, 0xca, - 0xf6, 0x14, 0xab, 0x1c, 0x94, 0xe9, 0xe0, 0x06, 0x1d, 0x6b, 0x19, 0xc9, 0x8f, 0x1e, 0x95, 0x55, - 0xe9, 0xa5, 0x8f, 0x55, 0x31, 0xbc, 0x50, 0x25, 0x70, 0x7f, 0xc5, 0x10, 0xe3, 0xb2, 0x98, 0xcb, - 0xa5, 0x1a, 0x51, 0x39, 0x97, 0x23, 0x11, 0xf5, 0x4b, 0x35, 0xe7, 0x08, 0xe7, 0x5f, 0x5a, 0x2d, - 0x68, 0xf4, 0x4e, 0x29, 0xee, 0xc7, 0x9d, 0xa2, 0xea, 0x39, 0x52, 0x3f, 0xfd, 0x9c, 0x67, 0x80, - 0x7c, 0xee, 0x45, 0x9e, 0x43, 0xbb, 0x52, 0x73, 0x4e, 0x7a, 0xb5, 0x07, 0x25, 0xf3, 0xf7, 0x95, - 0xc2, 0x86, 0xe4, 0xf0, 0x53, 0x6e, 0xc9, 0x5c, 0xbf, 0x5b, 0xac, 0x79, 0xa3, 0x5d, 0x83, 0x12, - 0x1a, 0xf8, 0xf7, 0x1d, 0x8f, 0x8a, 0x38, 0x8f, 0xc7, 0x10, 0xaa, 0x5d, 0x87, 0x69, 0xde, 0xfe, - 0x09, 0x33, 0xdc, 0xb8, 0x5e, 0xf8, 0x19, 0xeb, 0x45, 0x2a, 0x04, 0x5d, 0xe0, 0x6f, 0xcc, 0x53, - 0x72, 0xc3, 0x9d, 0x84, 0x4a, 0x54, 0xa2, 0x24, 0xc1, 0xff, 0x2f, 0xc0, 0x31, 0xc6, 0x8b, 0xe9, - 0xa1, 0x03, 0xee, 0x0f, 0x68, 0xe7, 0xe1, 0x78, 0xa4, 0x8e, 0x64, 0x19, 0x4c, 0x1f, 0x73, 0xfa, - 0xbc, 0x5a, 0x24, 0x6a, 0x19, 0x59, 0x25, 0xa7, 0xe2, 0x3e, 0x95, 0x9c, 0xaa, 0x50, 0x89, 0x32, - 0x1e, 0x96, 0x24, 0x26, 0xd8, 0xe4, 0x86, 0xd3, 0x77, 0x69, 0xbc, 0xff, 0x5a, 0xa4, 0xb3, 0x0e, - 0xb5, 0xc4, 0xb2, 0xec, 0x3d, 0xd4, 0xb7, 0x7a, 0xc3, 0x50, 0x54, 0xd5, 0x78, 0x75, 0xf6, 0x6d, - 0x06, 0x69, 0x19, 0xda, 0x1a, 0xcc, 0x9a, 0x3b, 0x66, 0xbb, 0x8f, 0x5c, 0xd7, 0xb2, 0xcd, 0x20, - 0x9b, 0xa8, 0x25, 0x19, 0xce, 0xcd, 0xbb, 0x37, 0x37, 0x39, 0x4c, 0x2f, 0x9b, 0x3b, 0xa6, 0xf8, - 0x3f, 0xf6, 0xa6, 0x6b, 0x40, 0x3d, 0x4d, 0x10, 0x52, 0x5a, 0x3f, 0xe7, 0x65, 0x13, 0x96, 0x85, - 0x7d, 0x1d, 0xa2, 0x8a, 0xd2, 0x58, 0x87, 0x5a, 0xf2, 0xf9, 0x11, 0x0a, 0x79, 0xb9, 0xf6, 0xe5, - 0x51, 0x98, 0x70, 0xbe, 0xa4, 0xf0, 0x77, 0x05, 0x28, 0xb1, 0x4a, 0xb8, 0x7f, 0x1b, 0x99, 0x7b, - 0xa4, 0x4a, 0xcd, 0x66, 0x26, 0x22, 0x59, 0xe6, 0x55, 0x28, 0xfa, 0xc8, 0x24, 0xe2, 0xfd, 0x52, - 0x4f, 0xee, 0x91, 0x70, 0xec, 0x6d, 0x64, 0x12, 0x9d, 0xa1, 0xa3, 0x6c, 0x9c, 0x80, 0xe3, 0x92, - 0x46, 0x49, 0xf9, 0xa3, 0x09, 0x26, 0x5c, 0xf5, 0x4a, 0xdb, 0xe0, 0xfd, 0xa1, 0x97, 0x76, 0xab, - 0x8d, 0xd1, 0x1d, 0x8b, 0x76, 0xb6, 0xa6, 0xe2, 0x9d, 0xad, 0xa4, 0x66, 0xd4, 0x74, 0x62, 0x33, - 0x2a, 0x59, 0xdd, 0x09, 0x12, 0x91, 0x42, 0xfb, 0x7d, 0x81, 0x15, 0x90, 0xb8, 0xcd, 0x1e, 0x22, - 0xd1, 0x45, 0x39, 0x39, 0x07, 0xaf, 0x67, 0x91, 0x19, 0xf0, 0xb3, 0xfa, 0xc7, 0x53, 0x30, 0xb9, - 0x49, 0x4c, 0xed, 0x43, 0x98, 0x1d, 0xf9, 0xf9, 0xc1, 0x6b, 0x29, 0xe5, 0x24, 0x15, 0x54, 0xbd, - 0x38, 0x06, 0x48, 0x26, 0xdb, 0x1f, 0xc2, 0xec, 0x48, 0x2f, 0x3b, 0xed, 0x04, 0x15, 0x94, 0x7a, - 0x42, 0x52, 0x73, 0x5a, 0xeb, 0xc1, 0xb1, 0x58, 0x8d, 0xe1, 0x8d, 0x94, 0x0d, 0xa2, 0xc0, 0x6a, - 0x73, 0x4c, 0xa0, 0xca, 0xcf, 0x48, 0xde, 0x9b, 0xc6, 0x8f, 0x0a, 0x4a, 0xe5, 0x27, 0x29, 0xeb, - 0xd2, 0x1c, 0x38, 0x1e, 0x6f, 0xb4, 0x2f, 0xa7, 0x49, 0x24, 0x8a, 0xac, 0x5e, 0x19, 0x17, 0xa9, - 0xb2, 0x34, 0x52, 0x2c, 0xc8, 0x36, 0x02, 0x0e, 0xca, 0x31, 0x82, 0x48, 0x57, 0xe8, 0x03, 0x00, - 0xa5, 0x27, 0x78, 0x36, 0x65, 0x69, 0x08, 0xa9, 0x9e, 0xcf, 0x85, 0xa8, 0xea, 0x8f, 0x75, 0x1d, - 0xd3, 0xd4, 0x1f, 0x05, 0xa6, 0xaa, 0x3f, 0xad, 0x53, 0x48, 0x39, 0x51, 0xba, 0x84, 0x69, 0x9c, - 0x84, 0x90, 0x54, 0x4e, 0x12, 0x7a, 0x67, 0xd2, 0x55, 0x72, 0xf4, 0xa0, 0x82, 0x72, 0x5c, 0x25, - 0x72, 0x82, 0x07, 0x5a, 0x42, 0x71, 0x28, 0x95, 0xc4, 0x18, 0xb4, 0xfa, 0xe6, 0xd8, 0xd0, 0xb8, - 0xc3, 0xe4, 0x70, 0xa5, 0x82, 0x72, 0x1c, 0x26, 0x72, 0xc2, 0xa8, 0xc3, 0x88, 0x63, 0xc6, 0x70, - 0x18, 0x71, 0xd6, 0x95, 0x71, 0x91, 0xf1, 0x88, 0xa3, 0xbc, 0x08, 0xb3, 0x23, 0x4e, 0x08, 0xcc, - 0x89, 0x38, 0xf1, 0x37, 0xa8, 0x36, 0x80, 0x13, 0x49, 0x37, 0xce, 0x85, 0x31, 0xf6, 0x11, 0xd8, - 0xea, 0xea, 0xf8, 0x58, 0x79, 0xec, 0x27, 0x05, 0x38, 0x95, 0x7e, 0xdf, 0x5d, 0xc9, 0x34, 0x84, - 0x24, 0x1a, 0xae, 0xef, 0x76, 0x85, 0xa4, 0xe4, 0xc7, 0x50, 0x56, 0x9b, 0x8d, 0x8d, 0xcc, 0xc8, - 0xc3, 0x30, 0xd5, 0x0b, 0xf9, 0x18, 0x75, 0x7b, 0xb5, 0xe1, 0xd7, 0xc8, 0x74, 0xa8, 0xec, 0xed, - 0x13, 0x5a, 0x78, 0xd4, 0x3a, 0xe3, 0xed, 0xbb, 0xe5, 0x4c, 0x85, 0x28, 0xc8, 0x54, 0xeb, 0x4c, - 0xed, 0x65, 0x85, 0xd6, 0xa9, 0xf4, 0x48, 0xde, 0xc8, 0xdf, 0x85, 0x01, 0x73, 0xac, 0x33, 0xde, - 0xa9, 0xa0, 0x01, 0x51, 0xe9, 0x52, 0xa4, 0x05, 0xc4, 0x10, 0x92, 0x1a, 0x10, 0xe3, 0x1d, 0x04, - 0xaa, 0x19, 0xb5, 0xf6, 0xd0, 0xc8, 0x0c, 0x0a, 0xd9, 0x9a, 0x49, 0x78, 0xfc, 0xf3, 0x9b, 0x23, - 0xd2, 0xf0, 0x4b, 0xbf, 0x39, 0x46, 0x81, 0x19, 0x37, 0x47, 0x72, 0x3b, 0x4d, 0xfb, 0x11, 0x94, - 0xc2, 0xb2, 0x76, 0x3d, 0x65, 0xb5, 0x44, 0x54, 0x97, 0xf3, 0x10, 0xf1, 0x6b, 0x43, 0xec, 0x9d, - 0x7d, 0x6d, 0x88, 0xed, 0x2f, 0x8e, 0x01, 0x52, 0x4f, 0x18, 0xa9, 0x90, 0xbc, 0x96, 0x69, 0x24, - 0x1c, 0x94, 0x7a, 0x42, 0x52, 0x59, 0x43, 0xeb, 0xc2, 0xdc, 0xe8, 0x3b, 0xef, 0xf5, 0x54, 0x3d, - 0x2a, 0xa8, 0xea, 0xa5, 0x71, 0x50, 0xf2, 0x90, 0x9f, 0xc1, 0x2b, 0xc9, 0x15, 0x82, 0x4b, 0xa9, - 0x77, 0x74, 0x02, 0xba, 0x7a, 0x75, 0x37, 0x68, 0x35, 0x8a, 0x27, 0xbd, 0xb8, 0x2f, 0x64, 0x46, - 0xc5, 0xd1, 0x83, 0x57, 0xc7, 0xc7, 0xaa, 0xc7, 0x26, 0x3d, 0xa3, 0x2f, 0x64, 0xe6, 0x3d, 0xe3, - 0x1d, 0x9b, 0xf1, 0x3c, 0xd6, 0xde, 0x83, 0x69, 0xf1, 0x34, 0x3e, 0x93, 0x9a, 0xc9, 0xd1, 0xe9, - 0xea, 0x37, 0x33, 0xa7, 0x83, 0xfd, 0xd6, 0x5b, 0x8f, 0x9f, 0xd5, 0x0a, 0x4f, 0x9e, 0xd5, 0x0a, - 0x5f, 0x3e, 0xab, 0x15, 0x1e, 0x3d, 0xaf, 0x1d, 0x79, 0xf2, 0xbc, 0x76, 0xe4, 0x1f, 0xcf, 0x6b, - 0x47, 0x3e, 0x68, 0x9a, 0x96, 0x7f, 0x7f, 0xd0, 0x59, 0xe9, 0x3a, 0xfd, 0x66, 0xc7, 0xee, 0x5c, - 0x66, 0x65, 0xc1, 0xa6, 0xf2, 0xcb, 0xeb, 0x87, 0xa3, 0xbf, 0xbd, 0xee, 0x4c, 0xb3, 0xe6, 0xca, - 0xb7, 0xbe, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x3c, 0xcb, 0x74, 0x8a, 0xe3, 0x2e, 0x00, 0x00, +func (m *MsgDelegateCreateObject) Reset() { *m = MsgDelegateCreateObject{} } +func (m *MsgDelegateCreateObject) String() string { return proto.CompactTextString(m) } +func (*MsgDelegateCreateObject) ProtoMessage() {} +func (*MsgDelegateCreateObject) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{65} +} +func (m *MsgDelegateCreateObject) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDelegateCreateObject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDelegateCreateObject.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 *MsgDelegateCreateObject) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDelegateCreateObject.Merge(m, src) +} +func (m *MsgDelegateCreateObject) XXX_Size() int { + return m.Size() +} +func (m *MsgDelegateCreateObject) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDelegateCreateObject.DiscardUnknown(m) } -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 +var xxx_messageInfo_MsgDelegateCreateObject proto.InternalMessageInfo -// MsgClient is the client API for Msg service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type MsgClient interface { - // basic operation of bucket - CreateBucket(ctx context.Context, in *MsgCreateBucket, opts ...grpc.CallOption) (*MsgCreateBucketResponse, error) - DeleteBucket(ctx context.Context, in *MsgDeleteBucket, opts ...grpc.CallOption) (*MsgDeleteBucketResponse, error) - UpdateBucketInfo(ctx context.Context, in *MsgUpdateBucketInfo, opts ...grpc.CallOption) (*MsgUpdateBucketInfoResponse, error) - MirrorBucket(ctx context.Context, in *MsgMirrorBucket, opts ...grpc.CallOption) (*MsgMirrorBucketResponse, error) - DiscontinueBucket(ctx context.Context, in *MsgDiscontinueBucket, opts ...grpc.CallOption) (*MsgDiscontinueBucketResponse, error) - // basic operation of object - CreateObject(ctx context.Context, in *MsgCreateObject, opts ...grpc.CallOption) (*MsgCreateObjectResponse, error) - SealObject(ctx context.Context, in *MsgSealObject, opts ...grpc.CallOption) (*MsgSealObjectResponse, error) - RejectSealObject(ctx context.Context, in *MsgRejectSealObject, opts ...grpc.CallOption) (*MsgRejectSealObjectResponse, error) - CopyObject(ctx context.Context, in *MsgCopyObject, opts ...grpc.CallOption) (*MsgCopyObjectResponse, error) - DeleteObject(ctx context.Context, in *MsgDeleteObject, opts ...grpc.CallOption) (*MsgDeleteObjectResponse, error) - CancelCreateObject(ctx context.Context, in *MsgCancelCreateObject, opts ...grpc.CallOption) (*MsgCancelCreateObjectResponse, error) - MirrorObject(ctx context.Context, in *MsgMirrorObject, opts ...grpc.CallOption) (*MsgMirrorObjectResponse, error) - DiscontinueObject(ctx context.Context, in *MsgDiscontinueObject, opts ...grpc.CallOption) (*MsgDiscontinueObjectResponse, error) - UpdateObjectInfo(ctx context.Context, in *MsgUpdateObjectInfo, opts ...grpc.CallOption) (*MsgUpdateObjectInfoResponse, error) - UpdateObjectContent(ctx context.Context, in *MsgUpdateObjectContent, opts ...grpc.CallOption) (*MsgUpdateObjectContentResponse, error) - CancelUpdateObjectContent(ctx context.Context, in *MsgCancelUpdateObjectContent, opts ...grpc.CallOption) (*MsgCancelUpdateObjectContentResponse, error) - // basic operation of group - CreateGroup(ctx context.Context, in *MsgCreateGroup, opts ...grpc.CallOption) (*MsgCreateGroupResponse, error) - DeleteGroup(ctx context.Context, in *MsgDeleteGroup, opts ...grpc.CallOption) (*MsgDeleteGroupResponse, error) - UpdateGroupMember(ctx context.Context, in *MsgUpdateGroupMember, opts ...grpc.CallOption) (*MsgUpdateGroupMemberResponse, error) - UpdateGroupExtra(ctx context.Context, in *MsgUpdateGroupExtra, opts ...grpc.CallOption) (*MsgUpdateGroupExtraResponse, error) - LeaveGroup(ctx context.Context, in *MsgLeaveGroup, opts ...grpc.CallOption) (*MsgLeaveGroupResponse, error) - MirrorGroup(ctx context.Context, in *MsgMirrorGroup, opts ...grpc.CallOption) (*MsgMirrorGroupResponse, error) - RenewGroupMember(ctx context.Context, in *MsgRenewGroupMember, opts ...grpc.CallOption) (*MsgRenewGroupMemberResponse, error) - // basic operation of policy - PutPolicy(ctx context.Context, in *MsgPutPolicy, opts ...grpc.CallOption) (*MsgPutPolicyResponse, error) - DeletePolicy(ctx context.Context, in *MsgDeletePolicy, opts ...grpc.CallOption) (*MsgDeletePolicyResponse, error) - // Since: cosmos-sdk 0.47 - UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) - MigrateBucket(ctx context.Context, in *MsgMigrateBucket, opts ...grpc.CallOption) (*MsgMigrateBucketResponse, error) - CompleteMigrateBucket(ctx context.Context, in *MsgCompleteMigrateBucket, opts ...grpc.CallOption) (*MsgCompleteMigrateBucketResponse, error) - CancelMigrateBucket(ctx context.Context, in *MsgCancelMigrateBucket, opts ...grpc.CallOption) (*MsgCancelMigrateBucketResponse, error) - 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) +func (m *MsgDelegateCreateObject) GetOperator() string { + if m != nil { + return m.Operator + } + return "" } -type msgClient struct { - cc grpc1.ClientConn +func (m *MsgDelegateCreateObject) GetCreator() string { + if m != nil { + return m.Creator + } + return "" } -func NewMsgClient(cc grpc1.ClientConn) MsgClient { - return &msgClient{cc} +func (m *MsgDelegateCreateObject) GetBucketName() string { + if m != nil { + return m.BucketName + } + return "" } -func (c *msgClient) CreateBucket(ctx context.Context, in *MsgCreateBucket, opts ...grpc.CallOption) (*MsgCreateBucketResponse, error) { - out := new(MsgCreateBucketResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CreateBucket", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateCreateObject) GetObjectName() string { + if m != nil { + return m.ObjectName } - return out, nil + return "" } -func (c *msgClient) DeleteBucket(ctx context.Context, in *MsgDeleteBucket, opts ...grpc.CallOption) (*MsgDeleteBucketResponse, error) { - out := new(MsgDeleteBucketResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DeleteBucket", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateCreateObject) GetPayloadSize() uint64 { + if m != nil { + return m.PayloadSize } - return out, nil + return 0 } -func (c *msgClient) UpdateBucketInfo(ctx context.Context, in *MsgUpdateBucketInfo, opts ...grpc.CallOption) (*MsgUpdateBucketInfoResponse, error) { - out := new(MsgUpdateBucketInfoResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateBucketInfo", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateCreateObject) GetContentType() string { + if m != nil { + return m.ContentType } - return out, nil + return "" } -func (c *msgClient) MirrorBucket(ctx context.Context, in *MsgMirrorBucket, opts ...grpc.CallOption) (*MsgMirrorBucketResponse, error) { - out := new(MsgMirrorBucketResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/MirrorBucket", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateCreateObject) GetVisibility() VisibilityType { + if m != nil { + return m.Visibility } - return out, nil + return VISIBILITY_TYPE_UNSPECIFIED } -func (c *msgClient) DiscontinueBucket(ctx context.Context, in *MsgDiscontinueBucket, opts ...grpc.CallOption) (*MsgDiscontinueBucketResponse, error) { - out := new(MsgDiscontinueBucketResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DiscontinueBucket", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateCreateObject) GetExpectChecksums() [][]byte { + if m != nil { + return m.ExpectChecksums } - return out, nil + return nil } -func (c *msgClient) CreateObject(ctx context.Context, in *MsgCreateObject, opts ...grpc.CallOption) (*MsgCreateObjectResponse, error) { - out := new(MsgCreateObjectResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CreateObject", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateCreateObject) GetRedundancyType() RedundancyType { + if m != nil { + return m.RedundancyType } - return out, nil + return REDUNDANCY_EC_TYPE } -func (c *msgClient) SealObject(ctx context.Context, in *MsgSealObject, opts ...grpc.CallOption) (*MsgSealObjectResponse, error) { - out := new(MsgSealObjectResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/SealObject", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type MsgDelegateCreateObjectResponse struct { + ObjectId Uint `protobuf:"bytes,1,opt,name=object_id,json=objectId,proto3,customtype=Uint" json:"object_id"` } -func (c *msgClient) RejectSealObject(ctx context.Context, in *MsgRejectSealObject, opts ...grpc.CallOption) (*MsgRejectSealObjectResponse, error) { - out := new(MsgRejectSealObjectResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/RejectSealObject", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateCreateObjectResponse) Reset() { *m = MsgDelegateCreateObjectResponse{} } +func (m *MsgDelegateCreateObjectResponse) String() string { return proto.CompactTextString(m) } +func (*MsgDelegateCreateObjectResponse) ProtoMessage() {} +func (*MsgDelegateCreateObjectResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{66} +} +func (m *MsgDelegateCreateObjectResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDelegateCreateObjectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDelegateCreateObjectResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *MsgDelegateCreateObjectResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDelegateCreateObjectResponse.Merge(m, src) +} +func (m *MsgDelegateCreateObjectResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgDelegateCreateObjectResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDelegateCreateObjectResponse.DiscardUnknown(m) } -func (c *msgClient) CopyObject(ctx context.Context, in *MsgCopyObject, opts ...grpc.CallOption) (*MsgCopyObjectResponse, error) { - out := new(MsgCopyObjectResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CopyObject", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +var xxx_messageInfo_MsgDelegateCreateObjectResponse proto.InternalMessageInfo + +type MsgDelegateUpdateObjectContent struct { + // operator defines the account address of the operator, it is the delegated agent that allows to creat object under bucket. + Operator string `protobuf:"bytes,1,opt,name=operator,proto3" json:"operator,omitempty"` + // updater defines the account address of the object updater. + Updater string `protobuf:"bytes,2,opt,name=updater,proto3" json:"updater,omitempty"` + // bucket_name defines the name of the bucket where the object is stored. + BucketName string `protobuf:"bytes,3,opt,name=bucket_name,json=bucketName,proto3" json:"bucket_name,omitempty"` + // object_name defines the name of object + ObjectName string `protobuf:"bytes,4,opt,name=object_name,json=objectName,proto3" json:"object_name,omitempty"` + // payload_size defines size of the object's payload + PayloadSize uint64 `protobuf:"varint,5,opt,name=payload_size,json=payloadSize,proto3" json:"payload_size,omitempty"` + // content_type define the format of the object which should be a standard MIME type. + ContentType string `protobuf:"bytes,6,opt,name=content_type,json=contentType,proto3" json:"content_type,omitempty"` + // expect_checksums defines a list of hashes which was generate by redundancy algorithm. + ExpectChecksums [][]byte `protobuf:"bytes,7,rep,name=expect_checksums,json=expectChecksums,proto3" json:"expect_checksums,omitempty"` } -func (c *msgClient) DeleteObject(ctx context.Context, in *MsgDeleteObject, opts ...grpc.CallOption) (*MsgDeleteObjectResponse, error) { - out := new(MsgDeleteObjectResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DeleteObject", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateUpdateObjectContent) Reset() { *m = MsgDelegateUpdateObjectContent{} } +func (m *MsgDelegateUpdateObjectContent) String() string { return proto.CompactTextString(m) } +func (*MsgDelegateUpdateObjectContent) ProtoMessage() {} +func (*MsgDelegateUpdateObjectContent) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{67} +} +func (m *MsgDelegateUpdateObjectContent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDelegateUpdateObjectContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDelegateUpdateObjectContent.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *MsgDelegateUpdateObjectContent) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDelegateUpdateObjectContent.Merge(m, src) +} +func (m *MsgDelegateUpdateObjectContent) XXX_Size() int { + return m.Size() +} +func (m *MsgDelegateUpdateObjectContent) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDelegateUpdateObjectContent.DiscardUnknown(m) } -func (c *msgClient) CancelCreateObject(ctx context.Context, in *MsgCancelCreateObject, opts ...grpc.CallOption) (*MsgCancelCreateObjectResponse, error) { - out := new(MsgCancelCreateObjectResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CancelCreateObject", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_MsgDelegateUpdateObjectContent proto.InternalMessageInfo + +func (m *MsgDelegateUpdateObjectContent) GetOperator() string { + if m != nil { + return m.Operator } - return out, nil + return "" } -func (c *msgClient) MirrorObject(ctx context.Context, in *MsgMirrorObject, opts ...grpc.CallOption) (*MsgMirrorObjectResponse, error) { - out := new(MsgMirrorObjectResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/MirrorObject", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateUpdateObjectContent) GetUpdater() string { + if m != nil { + return m.Updater } - return out, nil + return "" } -func (c *msgClient) DiscontinueObject(ctx context.Context, in *MsgDiscontinueObject, opts ...grpc.CallOption) (*MsgDiscontinueObjectResponse, error) { - out := new(MsgDiscontinueObjectResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DiscontinueObject", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateUpdateObjectContent) GetBucketName() string { + if m != nil { + return m.BucketName } - return out, nil + return "" } -func (c *msgClient) UpdateObjectInfo(ctx context.Context, in *MsgUpdateObjectInfo, opts ...grpc.CallOption) (*MsgUpdateObjectInfoResponse, error) { - out := new(MsgUpdateObjectInfoResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateObjectInfo", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateUpdateObjectContent) GetObjectName() string { + if m != nil { + return m.ObjectName } - return out, nil + return "" } -func (c *msgClient) UpdateObjectContent(ctx context.Context, in *MsgUpdateObjectContent, opts ...grpc.CallOption) (*MsgUpdateObjectContentResponse, error) { - out := new(MsgUpdateObjectContentResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateObjectContent", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateUpdateObjectContent) GetPayloadSize() uint64 { + if m != nil { + return m.PayloadSize } - return out, nil + return 0 } -func (c *msgClient) CancelUpdateObjectContent(ctx context.Context, in *MsgCancelUpdateObjectContent, opts ...grpc.CallOption) (*MsgCancelUpdateObjectContentResponse, error) { - out := new(MsgCancelUpdateObjectContentResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CancelUpdateObjectContent", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateUpdateObjectContent) GetContentType() string { + if m != nil { + return m.ContentType } - return out, nil + return "" } -func (c *msgClient) CreateGroup(ctx context.Context, in *MsgCreateGroup, opts ...grpc.CallOption) (*MsgCreateGroupResponse, error) { - out := new(MsgCreateGroupResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CreateGroup", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateUpdateObjectContent) GetExpectChecksums() [][]byte { + if m != nil { + return m.ExpectChecksums } - return out, nil + return nil } -func (c *msgClient) DeleteGroup(ctx context.Context, in *MsgDeleteGroup, opts ...grpc.CallOption) (*MsgDeleteGroupResponse, error) { - out := new(MsgDeleteGroupResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DeleteGroup", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type MsgDelegateUpdateObjectContentResponse struct { } -func (c *msgClient) UpdateGroupMember(ctx context.Context, in *MsgUpdateGroupMember, opts ...grpc.CallOption) (*MsgUpdateGroupMemberResponse, error) { - out := new(MsgUpdateGroupMemberResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateGroupMember", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *MsgDelegateUpdateObjectContentResponse) Reset() { + *m = MsgDelegateUpdateObjectContentResponse{} } - -func (c *msgClient) UpdateGroupExtra(ctx context.Context, in *MsgUpdateGroupExtra, opts ...grpc.CallOption) (*MsgUpdateGroupExtraResponse, error) { - out := new(MsgUpdateGroupExtraResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateGroupExtra", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *MsgDelegateUpdateObjectContentResponse) String() string { return proto.CompactTextString(m) } +func (*MsgDelegateUpdateObjectContentResponse) ProtoMessage() {} +func (*MsgDelegateUpdateObjectContentResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{68} } - -func (c *msgClient) LeaveGroup(ctx context.Context, in *MsgLeaveGroup, opts ...grpc.CallOption) (*MsgLeaveGroupResponse, error) { - out := new(MsgLeaveGroupResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/LeaveGroup", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *MsgDelegateUpdateObjectContentResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *msgClient) MirrorGroup(ctx context.Context, in *MsgMirrorGroup, opts ...grpc.CallOption) (*MsgMirrorGroupResponse, error) { - out := new(MsgMirrorGroupResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/MirrorGroup", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgDelegateUpdateObjectContentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDelegateUpdateObjectContentResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil } - -func (c *msgClient) RenewGroupMember(ctx context.Context, in *MsgRenewGroupMember, opts ...grpc.CallOption) (*MsgRenewGroupMemberResponse, error) { - out := new(MsgRenewGroupMemberResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/RenewGroupMember", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *MsgDelegateUpdateObjectContentResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDelegateUpdateObjectContentResponse.Merge(m, src) } - -func (c *msgClient) PutPolicy(ctx context.Context, in *MsgPutPolicy, opts ...grpc.CallOption) (*MsgPutPolicyResponse, error) { - out := new(MsgPutPolicyResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/PutPolicy", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *MsgDelegateUpdateObjectContentResponse) XXX_Size() int { + return m.Size() } - -func (c *msgClient) DeletePolicy(ctx context.Context, in *MsgDeletePolicy, opts ...grpc.CallOption) (*MsgDeletePolicyResponse, error) { - out := new(MsgDeletePolicyResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DeletePolicy", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *MsgDelegateUpdateObjectContentResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDelegateUpdateObjectContentResponse.DiscardUnknown(m) } -func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { - out := new(MsgUpdateParamsResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateParams", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} +var xxx_messageInfo_MsgDelegateUpdateObjectContentResponse proto.InternalMessageInfo -func (c *msgClient) MigrateBucket(ctx context.Context, in *MsgMigrateBucket, opts ...grpc.CallOption) (*MsgMigrateBucketResponse, error) { - out := new(MsgMigrateBucketResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/MigrateBucket", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +type MsgToggleSPAsDelegatedAgent struct { + // operator defines the account address of the operator, only the bucket owner can send the tx. + 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"` } -func (c *msgClient) CompleteMigrateBucket(ctx context.Context, in *MsgCompleteMigrateBucket, opts ...grpc.CallOption) (*MsgCompleteMigrateBucketResponse, error) { - out := new(MsgCompleteMigrateBucketResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CompleteMigrateBucket", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *MsgToggleSPAsDelegatedAgent) Reset() { *m = MsgToggleSPAsDelegatedAgent{} } +func (m *MsgToggleSPAsDelegatedAgent) String() string { return proto.CompactTextString(m) } +func (*MsgToggleSPAsDelegatedAgent) ProtoMessage() {} +func (*MsgToggleSPAsDelegatedAgent) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{69} } - -func (c *msgClient) CancelMigrateBucket(ctx context.Context, in *MsgCancelMigrateBucket, opts ...grpc.CallOption) (*MsgCancelMigrateBucketResponse, error) { - out := new(MsgCancelMigrateBucketResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CancelMigrateBucket", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil +func (m *MsgToggleSPAsDelegatedAgent) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } - -func (c *msgClient) RejectMigrateBucket(ctx context.Context, in *MsgRejectMigrateBucket, opts ...grpc.CallOption) (*MsgRejectMigrateBucketResponse, error) { - out := new(MsgRejectMigrateBucketResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/RejectMigrateBucket", in, out, opts...) - if err != nil { - return nil, err +func (m *MsgToggleSPAsDelegatedAgent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgToggleSPAsDelegatedAgent.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil } - return out, nil +} +func (m *MsgToggleSPAsDelegatedAgent) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgToggleSPAsDelegatedAgent.Merge(m, src) +} +func (m *MsgToggleSPAsDelegatedAgent) XXX_Size() int { + return m.Size() +} +func (m *MsgToggleSPAsDelegatedAgent) XXX_DiscardUnknown() { + xxx_messageInfo_MsgToggleSPAsDelegatedAgent.DiscardUnknown(m) } -func (c *msgClient) SetTag(ctx context.Context, in *MsgSetTag, opts ...grpc.CallOption) (*MsgSetTagResponse, error) { - out := new(MsgSetTagResponse) - err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/SetTag", in, out, opts...) - if err != nil { - return nil, err +var xxx_messageInfo_MsgToggleSPAsDelegatedAgent proto.InternalMessageInfo + +func (m *MsgToggleSPAsDelegatedAgent) GetOperator() string { + if m != nil { + return m.Operator } - return out, nil + return "" } -// MsgServer is the server API for Msg service. -type MsgServer interface { - // basic operation of bucket - CreateBucket(context.Context, *MsgCreateBucket) (*MsgCreateBucketResponse, error) - DeleteBucket(context.Context, *MsgDeleteBucket) (*MsgDeleteBucketResponse, error) - UpdateBucketInfo(context.Context, *MsgUpdateBucketInfo) (*MsgUpdateBucketInfoResponse, error) - MirrorBucket(context.Context, *MsgMirrorBucket) (*MsgMirrorBucketResponse, error) - DiscontinueBucket(context.Context, *MsgDiscontinueBucket) (*MsgDiscontinueBucketResponse, error) - // basic operation of object - CreateObject(context.Context, *MsgCreateObject) (*MsgCreateObjectResponse, error) - SealObject(context.Context, *MsgSealObject) (*MsgSealObjectResponse, error) - RejectSealObject(context.Context, *MsgRejectSealObject) (*MsgRejectSealObjectResponse, error) - CopyObject(context.Context, *MsgCopyObject) (*MsgCopyObjectResponse, error) - DeleteObject(context.Context, *MsgDeleteObject) (*MsgDeleteObjectResponse, error) - CancelCreateObject(context.Context, *MsgCancelCreateObject) (*MsgCancelCreateObjectResponse, error) - MirrorObject(context.Context, *MsgMirrorObject) (*MsgMirrorObjectResponse, error) - DiscontinueObject(context.Context, *MsgDiscontinueObject) (*MsgDiscontinueObjectResponse, error) - UpdateObjectInfo(context.Context, *MsgUpdateObjectInfo) (*MsgUpdateObjectInfoResponse, error) - UpdateObjectContent(context.Context, *MsgUpdateObjectContent) (*MsgUpdateObjectContentResponse, error) - CancelUpdateObjectContent(context.Context, *MsgCancelUpdateObjectContent) (*MsgCancelUpdateObjectContentResponse, error) - // basic operation of group - CreateGroup(context.Context, *MsgCreateGroup) (*MsgCreateGroupResponse, error) - DeleteGroup(context.Context, *MsgDeleteGroup) (*MsgDeleteGroupResponse, error) - UpdateGroupMember(context.Context, *MsgUpdateGroupMember) (*MsgUpdateGroupMemberResponse, error) - UpdateGroupExtra(context.Context, *MsgUpdateGroupExtra) (*MsgUpdateGroupExtraResponse, error) - LeaveGroup(context.Context, *MsgLeaveGroup) (*MsgLeaveGroupResponse, error) - MirrorGroup(context.Context, *MsgMirrorGroup) (*MsgMirrorGroupResponse, error) - RenewGroupMember(context.Context, *MsgRenewGroupMember) (*MsgRenewGroupMemberResponse, error) - // basic operation of policy - PutPolicy(context.Context, *MsgPutPolicy) (*MsgPutPolicyResponse, error) - DeletePolicy(context.Context, *MsgDeletePolicy) (*MsgDeletePolicyResponse, error) - // Since: cosmos-sdk 0.47 - UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) - MigrateBucket(context.Context, *MsgMigrateBucket) (*MsgMigrateBucketResponse, error) - CompleteMigrateBucket(context.Context, *MsgCompleteMigrateBucket) (*MsgCompleteMigrateBucketResponse, error) - CancelMigrateBucket(context.Context, *MsgCancelMigrateBucket) (*MsgCancelMigrateBucketResponse, error) - RejectMigrateBucket(context.Context, *MsgRejectMigrateBucket) (*MsgRejectMigrateBucketResponse, error) - // Since: Manchurian upgrade - SetTag(context.Context, *MsgSetTag) (*MsgSetTagResponse, error) +func (m *MsgToggleSPAsDelegatedAgent) GetBucketName() string { + if m != nil { + return m.BucketName + } + return "" } -// UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { +type MsgToggleSPAsDelegatedAgentResponse struct { } -func (*UnimplementedMsgServer) CreateBucket(ctx context.Context, req *MsgCreateBucket) (*MsgCreateBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CreateBucket not implemented") -} -func (*UnimplementedMsgServer) DeleteBucket(ctx context.Context, req *MsgDeleteBucket) (*MsgDeleteBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DeleteBucket not implemented") -} -func (*UnimplementedMsgServer) UpdateBucketInfo(ctx context.Context, req *MsgUpdateBucketInfo) (*MsgUpdateBucketInfoResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateBucketInfo not implemented") -} -func (*UnimplementedMsgServer) MirrorBucket(ctx context.Context, req *MsgMirrorBucket) (*MsgMirrorBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MirrorBucket not implemented") -} -func (*UnimplementedMsgServer) DiscontinueBucket(ctx context.Context, req *MsgDiscontinueBucket) (*MsgDiscontinueBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DiscontinueBucket not implemented") -} -func (*UnimplementedMsgServer) CreateObject(ctx context.Context, req *MsgCreateObject) (*MsgCreateObjectResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CreateObject not implemented") -} -func (*UnimplementedMsgServer) SealObject(ctx context.Context, req *MsgSealObject) (*MsgSealObjectResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method SealObject not implemented") -} -func (*UnimplementedMsgServer) RejectSealObject(ctx context.Context, req *MsgRejectSealObject) (*MsgRejectSealObjectResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method RejectSealObject not implemented") -} -func (*UnimplementedMsgServer) CopyObject(ctx context.Context, req *MsgCopyObject) (*MsgCopyObjectResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CopyObject not implemented") -} -func (*UnimplementedMsgServer) DeleteObject(ctx context.Context, req *MsgDeleteObject) (*MsgDeleteObjectResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DeleteObject not implemented") +func (m *MsgToggleSPAsDelegatedAgentResponse) Reset() { *m = MsgToggleSPAsDelegatedAgentResponse{} } +func (m *MsgToggleSPAsDelegatedAgentResponse) String() string { return proto.CompactTextString(m) } +func (*MsgToggleSPAsDelegatedAgentResponse) ProtoMessage() {} +func (*MsgToggleSPAsDelegatedAgentResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_ddb71b028305a3cc, []int{70} } -func (*UnimplementedMsgServer) CancelCreateObject(ctx context.Context, req *MsgCancelCreateObject) (*MsgCancelCreateObjectResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CancelCreateObject not implemented") +func (m *MsgToggleSPAsDelegatedAgentResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) } -func (*UnimplementedMsgServer) MirrorObject(ctx context.Context, req *MsgMirrorObject) (*MsgMirrorObjectResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MirrorObject not implemented") +func (m *MsgToggleSPAsDelegatedAgentResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgToggleSPAsDelegatedAgentResponse.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 (*UnimplementedMsgServer) DiscontinueObject(ctx context.Context, req *MsgDiscontinueObject) (*MsgDiscontinueObjectResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DiscontinueObject not implemented") +func (m *MsgToggleSPAsDelegatedAgentResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgToggleSPAsDelegatedAgentResponse.Merge(m, src) } -func (*UnimplementedMsgServer) UpdateObjectInfo(ctx context.Context, req *MsgUpdateObjectInfo) (*MsgUpdateObjectInfoResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateObjectInfo not implemented") +func (m *MsgToggleSPAsDelegatedAgentResponse) XXX_Size() int { + return m.Size() } -func (*UnimplementedMsgServer) UpdateObjectContent(ctx context.Context, req *MsgUpdateObjectContent) (*MsgUpdateObjectContentResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateObjectContent not implemented") +func (m *MsgToggleSPAsDelegatedAgentResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgToggleSPAsDelegatedAgentResponse.DiscardUnknown(m) } -func (*UnimplementedMsgServer) CancelUpdateObjectContent(ctx context.Context, req *MsgCancelUpdateObjectContent) (*MsgCancelUpdateObjectContentResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CancelUpdateObjectContent not implemented") -} -func (*UnimplementedMsgServer) CreateGroup(ctx context.Context, req *MsgCreateGroup) (*MsgCreateGroupResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CreateGroup not implemented") -} -func (*UnimplementedMsgServer) DeleteGroup(ctx context.Context, req *MsgDeleteGroup) (*MsgDeleteGroupResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DeleteGroup not implemented") -} -func (*UnimplementedMsgServer) UpdateGroupMember(ctx context.Context, req *MsgUpdateGroupMember) (*MsgUpdateGroupMemberResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateGroupMember not implemented") -} -func (*UnimplementedMsgServer) UpdateGroupExtra(ctx context.Context, req *MsgUpdateGroupExtra) (*MsgUpdateGroupExtraResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateGroupExtra not implemented") -} -func (*UnimplementedMsgServer) LeaveGroup(ctx context.Context, req *MsgLeaveGroup) (*MsgLeaveGroupResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method LeaveGroup not implemented") -} -func (*UnimplementedMsgServer) MirrorGroup(ctx context.Context, req *MsgMirrorGroup) (*MsgMirrorGroupResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MirrorGroup not implemented") -} -func (*UnimplementedMsgServer) RenewGroupMember(ctx context.Context, req *MsgRenewGroupMember) (*MsgRenewGroupMemberResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method RenewGroupMember not implemented") -} -func (*UnimplementedMsgServer) PutPolicy(ctx context.Context, req *MsgPutPolicy) (*MsgPutPolicyResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method PutPolicy not implemented") -} -func (*UnimplementedMsgServer) DeletePolicy(ctx context.Context, req *MsgDeletePolicy) (*MsgDeletePolicyResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method DeletePolicy not implemented") -} -func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") -} -func (*UnimplementedMsgServer) MigrateBucket(ctx context.Context, req *MsgMigrateBucket) (*MsgMigrateBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MigrateBucket not implemented") -} -func (*UnimplementedMsgServer) CompleteMigrateBucket(ctx context.Context, req *MsgCompleteMigrateBucket) (*MsgCompleteMigrateBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CompleteMigrateBucket not implemented") + +var xxx_messageInfo_MsgToggleSPAsDelegatedAgentResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgCreateBucket)(nil), "greenfield.storage.MsgCreateBucket") + proto.RegisterType((*MsgCreateBucketResponse)(nil), "greenfield.storage.MsgCreateBucketResponse") + proto.RegisterType((*MsgDeleteBucket)(nil), "greenfield.storage.MsgDeleteBucket") + proto.RegisterType((*MsgDeleteBucketResponse)(nil), "greenfield.storage.MsgDeleteBucketResponse") + proto.RegisterType((*MsgDiscontinueBucket)(nil), "greenfield.storage.MsgDiscontinueBucket") + proto.RegisterType((*MsgDiscontinueBucketResponse)(nil), "greenfield.storage.MsgDiscontinueBucketResponse") + proto.RegisterType((*MsgCreateObject)(nil), "greenfield.storage.MsgCreateObject") + proto.RegisterType((*MsgCreateObjectResponse)(nil), "greenfield.storage.MsgCreateObjectResponse") + proto.RegisterType((*MsgSealObject)(nil), "greenfield.storage.MsgSealObject") + proto.RegisterType((*MsgSealObjectResponse)(nil), "greenfield.storage.MsgSealObjectResponse") + proto.RegisterType((*MsgSealObjectV2)(nil), "greenfield.storage.MsgSealObjectV2") + proto.RegisterType((*MsgSealObjectV2Response)(nil), "greenfield.storage.MsgSealObjectV2Response") + proto.RegisterType((*MsgRejectSealObject)(nil), "greenfield.storage.MsgRejectSealObject") + proto.RegisterType((*MsgRejectSealObjectResponse)(nil), "greenfield.storage.MsgRejectSealObjectResponse") + proto.RegisterType((*MsgCopyObject)(nil), "greenfield.storage.MsgCopyObject") + proto.RegisterType((*MsgCopyObjectResponse)(nil), "greenfield.storage.MsgCopyObjectResponse") + proto.RegisterType((*MsgDeleteObject)(nil), "greenfield.storage.MsgDeleteObject") + proto.RegisterType((*MsgDeleteObjectResponse)(nil), "greenfield.storage.MsgDeleteObjectResponse") + proto.RegisterType((*MsgDiscontinueObject)(nil), "greenfield.storage.MsgDiscontinueObject") + proto.RegisterType((*MsgDiscontinueObjectResponse)(nil), "greenfield.storage.MsgDiscontinueObjectResponse") + proto.RegisterType((*MsgCreateGroup)(nil), "greenfield.storage.MsgCreateGroup") + proto.RegisterType((*MsgCreateGroupResponse)(nil), "greenfield.storage.MsgCreateGroupResponse") + proto.RegisterType((*MsgDeleteGroup)(nil), "greenfield.storage.MsgDeleteGroup") + proto.RegisterType((*MsgDeleteGroupResponse)(nil), "greenfield.storage.MsgDeleteGroupResponse") + proto.RegisterType((*MsgUpdateGroupMember)(nil), "greenfield.storage.MsgUpdateGroupMember") + proto.RegisterType((*MsgUpdateGroupMemberResponse)(nil), "greenfield.storage.MsgUpdateGroupMemberResponse") + proto.RegisterType((*MsgRenewGroupMember)(nil), "greenfield.storage.MsgRenewGroupMember") + proto.RegisterType((*MsgRenewGroupMemberResponse)(nil), "greenfield.storage.MsgRenewGroupMemberResponse") + proto.RegisterType((*MsgGroupMember)(nil), "greenfield.storage.MsgGroupMember") + proto.RegisterType((*MsgUpdateGroupExtra)(nil), "greenfield.storage.MsgUpdateGroupExtra") + proto.RegisterType((*MsgUpdateGroupExtraResponse)(nil), "greenfield.storage.MsgUpdateGroupExtraResponse") + proto.RegisterType((*MsgLeaveGroup)(nil), "greenfield.storage.MsgLeaveGroup") + proto.RegisterType((*MsgLeaveGroupResponse)(nil), "greenfield.storage.MsgLeaveGroupResponse") + proto.RegisterType((*MsgUpdateBucketInfo)(nil), "greenfield.storage.MsgUpdateBucketInfo") + proto.RegisterType((*MsgUpdateBucketInfoResponse)(nil), "greenfield.storage.MsgUpdateBucketInfoResponse") + proto.RegisterType((*MsgCancelCreateObject)(nil), "greenfield.storage.MsgCancelCreateObject") + proto.RegisterType((*MsgCancelCreateObjectResponse)(nil), "greenfield.storage.MsgCancelCreateObjectResponse") + proto.RegisterType((*MsgPutPolicy)(nil), "greenfield.storage.MsgPutPolicy") + proto.RegisterType((*MsgPutPolicyResponse)(nil), "greenfield.storage.MsgPutPolicyResponse") + proto.RegisterType((*MsgDeletePolicy)(nil), "greenfield.storage.MsgDeletePolicy") + proto.RegisterType((*MsgDeletePolicyResponse)(nil), "greenfield.storage.MsgDeletePolicyResponse") + proto.RegisterType((*MsgMirrorObject)(nil), "greenfield.storage.MsgMirrorObject") + proto.RegisterType((*MsgMirrorObjectResponse)(nil), "greenfield.storage.MsgMirrorObjectResponse") + proto.RegisterType((*MsgMirrorBucket)(nil), "greenfield.storage.MsgMirrorBucket") + proto.RegisterType((*MsgUpdateObjectInfoResponse)(nil), "greenfield.storage.MsgUpdateObjectInfoResponse") + proto.RegisterType((*MsgUpdateObjectInfo)(nil), "greenfield.storage.MsgUpdateObjectInfo") + proto.RegisterType((*MsgMirrorBucketResponse)(nil), "greenfield.storage.MsgMirrorBucketResponse") + proto.RegisterType((*MsgMirrorGroup)(nil), "greenfield.storage.MsgMirrorGroup") + proto.RegisterType((*MsgMirrorGroupResponse)(nil), "greenfield.storage.MsgMirrorGroupResponse") + proto.RegisterType((*MsgUpdateParams)(nil), "greenfield.storage.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "greenfield.storage.MsgUpdateParamsResponse") + proto.RegisterType((*MsgMigrateBucket)(nil), "greenfield.storage.MsgMigrateBucket") + proto.RegisterType((*MsgMigrateBucketResponse)(nil), "greenfield.storage.MsgMigrateBucketResponse") + proto.RegisterType((*MsgCompleteMigrateBucket)(nil), "greenfield.storage.MsgCompleteMigrateBucket") + proto.RegisterType((*MsgCompleteMigrateBucketResponse)(nil), "greenfield.storage.MsgCompleteMigrateBucketResponse") + proto.RegisterType((*MsgCancelMigrateBucket)(nil), "greenfield.storage.MsgCancelMigrateBucket") + proto.RegisterType((*MsgCancelMigrateBucketResponse)(nil), "greenfield.storage.MsgCancelMigrateBucketResponse") + proto.RegisterType((*MsgRejectMigrateBucket)(nil), "greenfield.storage.MsgRejectMigrateBucket") + proto.RegisterType((*MsgRejectMigrateBucketResponse)(nil), "greenfield.storage.MsgRejectMigrateBucketResponse") + proto.RegisterType((*MsgSetTag)(nil), "greenfield.storage.MsgSetTag") + proto.RegisterType((*MsgSetTagResponse)(nil), "greenfield.storage.MsgSetTagResponse") + proto.RegisterType((*MsgUpdateObjectContent)(nil), "greenfield.storage.MsgUpdateObjectContent") + proto.RegisterType((*MsgUpdateObjectContentResponse)(nil), "greenfield.storage.MsgUpdateObjectContentResponse") + proto.RegisterType((*MsgCancelUpdateObjectContent)(nil), "greenfield.storage.MsgCancelUpdateObjectContent") + proto.RegisterType((*MsgCancelUpdateObjectContentResponse)(nil), "greenfield.storage.MsgCancelUpdateObjectContentResponse") + proto.RegisterType((*MsgDelegateCreateObject)(nil), "greenfield.storage.MsgDelegateCreateObject") + proto.RegisterType((*MsgDelegateCreateObjectResponse)(nil), "greenfield.storage.MsgDelegateCreateObjectResponse") + proto.RegisterType((*MsgDelegateUpdateObjectContent)(nil), "greenfield.storage.MsgDelegateUpdateObjectContent") + proto.RegisterType((*MsgDelegateUpdateObjectContentResponse)(nil), "greenfield.storage.MsgDelegateUpdateObjectContentResponse") + proto.RegisterType((*MsgToggleSPAsDelegatedAgent)(nil), "greenfield.storage.MsgToggleSPAsDelegatedAgent") + proto.RegisterType((*MsgToggleSPAsDelegatedAgentResponse)(nil), "greenfield.storage.MsgToggleSPAsDelegatedAgentResponse") } -func (*UnimplementedMsgServer) CancelMigrateBucket(ctx context.Context, req *MsgCancelMigrateBucket) (*MsgCancelMigrateBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method CancelMigrateBucket not implemented") + +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, } -func (*UnimplementedMsgServer) RejectMigrateBucket(ctx context.Context, req *MsgRejectMigrateBucket) (*MsgRejectMigrateBucketResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method RejectMigrateBucket not implemented") + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + // basic operation of bucket + CreateBucket(ctx context.Context, in *MsgCreateBucket, opts ...grpc.CallOption) (*MsgCreateBucketResponse, error) + DeleteBucket(ctx context.Context, in *MsgDeleteBucket, opts ...grpc.CallOption) (*MsgDeleteBucketResponse, error) + UpdateBucketInfo(ctx context.Context, in *MsgUpdateBucketInfo, opts ...grpc.CallOption) (*MsgUpdateBucketInfoResponse, error) + MirrorBucket(ctx context.Context, in *MsgMirrorBucket, opts ...grpc.CallOption) (*MsgMirrorBucketResponse, error) + DiscontinueBucket(ctx context.Context, in *MsgDiscontinueBucket, opts ...grpc.CallOption) (*MsgDiscontinueBucketResponse, error) + ToggleSPAsDelegatedAgent(ctx context.Context, in *MsgToggleSPAsDelegatedAgent, opts ...grpc.CallOption) (*MsgToggleSPAsDelegatedAgentResponse, error) + // basic operation of object + CreateObject(ctx context.Context, in *MsgCreateObject, opts ...grpc.CallOption) (*MsgCreateObjectResponse, error) + SealObject(ctx context.Context, in *MsgSealObject, opts ...grpc.CallOption) (*MsgSealObjectResponse, error) + SealObjectV2(ctx context.Context, in *MsgSealObjectV2, opts ...grpc.CallOption) (*MsgSealObjectV2Response, error) + RejectSealObject(ctx context.Context, in *MsgRejectSealObject, opts ...grpc.CallOption) (*MsgRejectSealObjectResponse, error) + CopyObject(ctx context.Context, in *MsgCopyObject, opts ...grpc.CallOption) (*MsgCopyObjectResponse, error) + DeleteObject(ctx context.Context, in *MsgDeleteObject, opts ...grpc.CallOption) (*MsgDeleteObjectResponse, error) + CancelCreateObject(ctx context.Context, in *MsgCancelCreateObject, opts ...grpc.CallOption) (*MsgCancelCreateObjectResponse, error) + MirrorObject(ctx context.Context, in *MsgMirrorObject, opts ...grpc.CallOption) (*MsgMirrorObjectResponse, error) + DiscontinueObject(ctx context.Context, in *MsgDiscontinueObject, opts ...grpc.CallOption) (*MsgDiscontinueObjectResponse, error) + UpdateObjectInfo(ctx context.Context, in *MsgUpdateObjectInfo, opts ...grpc.CallOption) (*MsgUpdateObjectInfoResponse, error) + UpdateObjectContent(ctx context.Context, in *MsgUpdateObjectContent, opts ...grpc.CallOption) (*MsgUpdateObjectContentResponse, error) + CancelUpdateObjectContent(ctx context.Context, in *MsgCancelUpdateObjectContent, opts ...grpc.CallOption) (*MsgCancelUpdateObjectContentResponse, error) + DelegateCreateObject(ctx context.Context, in *MsgDelegateCreateObject, opts ...grpc.CallOption) (*MsgDelegateCreateObjectResponse, error) + DelegateUpdateObjectContent(ctx context.Context, in *MsgDelegateUpdateObjectContent, opts ...grpc.CallOption) (*MsgDelegateUpdateObjectContentResponse, error) + // basic operation of group + CreateGroup(ctx context.Context, in *MsgCreateGroup, opts ...grpc.CallOption) (*MsgCreateGroupResponse, error) + DeleteGroup(ctx context.Context, in *MsgDeleteGroup, opts ...grpc.CallOption) (*MsgDeleteGroupResponse, error) + UpdateGroupMember(ctx context.Context, in *MsgUpdateGroupMember, opts ...grpc.CallOption) (*MsgUpdateGroupMemberResponse, error) + UpdateGroupExtra(ctx context.Context, in *MsgUpdateGroupExtra, opts ...grpc.CallOption) (*MsgUpdateGroupExtraResponse, error) + LeaveGroup(ctx context.Context, in *MsgLeaveGroup, opts ...grpc.CallOption) (*MsgLeaveGroupResponse, error) + MirrorGroup(ctx context.Context, in *MsgMirrorGroup, opts ...grpc.CallOption) (*MsgMirrorGroupResponse, error) + RenewGroupMember(ctx context.Context, in *MsgRenewGroupMember, opts ...grpc.CallOption) (*MsgRenewGroupMemberResponse, error) + // basic operation of policy + PutPolicy(ctx context.Context, in *MsgPutPolicy, opts ...grpc.CallOption) (*MsgPutPolicyResponse, error) + DeletePolicy(ctx context.Context, in *MsgDeletePolicy, opts ...grpc.CallOption) (*MsgDeletePolicyResponse, error) + // Since: cosmos-sdk 0.47 + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) + MigrateBucket(ctx context.Context, in *MsgMigrateBucket, opts ...grpc.CallOption) (*MsgMigrateBucketResponse, error) + CompleteMigrateBucket(ctx context.Context, in *MsgCompleteMigrateBucket, opts ...grpc.CallOption) (*MsgCompleteMigrateBucketResponse, error) + CancelMigrateBucket(ctx context.Context, in *MsgCancelMigrateBucket, opts ...grpc.CallOption) (*MsgCancelMigrateBucketResponse, error) + 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) } -func (*UnimplementedMsgServer) SetTag(ctx context.Context, req *MsgSetTag) (*MsgSetTagResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method SetTag not implemented") + +type msgClient struct { + cc grpc1.ClientConn } -func RegisterMsgServer(s grpc1.Server, srv MsgServer) { - s.RegisterService(&_Msg_serviceDesc, srv) +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} } -func _Msg_CreateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCreateBucket) - if err := dec(in); err != nil { +func (c *msgClient) CreateBucket(ctx context.Context, in *MsgCreateBucket, opts ...grpc.CallOption) (*MsgCreateBucketResponse, error) { + out := new(MsgCreateBucketResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CreateBucket", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).CreateBucket(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/CreateBucket", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CreateBucket(ctx, req.(*MsgCreateBucket)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_DeleteBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDeleteBucket) - if err := dec(in); err != nil { +func (c *msgClient) DeleteBucket(ctx context.Context, in *MsgDeleteBucket, opts ...grpc.CallOption) (*MsgDeleteBucketResponse, error) { + out := new(MsgDeleteBucketResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DeleteBucket", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).DeleteBucket(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/DeleteBucket", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DeleteBucket(ctx, req.(*MsgDeleteBucket)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_UpdateBucketInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgUpdateBucketInfo) - if err := dec(in); err != nil { +func (c *msgClient) UpdateBucketInfo(ctx context.Context, in *MsgUpdateBucketInfo, opts ...grpc.CallOption) (*MsgUpdateBucketInfoResponse, error) { + out := new(MsgUpdateBucketInfoResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateBucketInfo", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).UpdateBucketInfo(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/UpdateBucketInfo", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).UpdateBucketInfo(ctx, req.(*MsgUpdateBucketInfo)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_MirrorBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgMirrorBucket) - if err := dec(in); err != nil { +func (c *msgClient) MirrorBucket(ctx context.Context, in *MsgMirrorBucket, opts ...grpc.CallOption) (*MsgMirrorBucketResponse, error) { + out := new(MsgMirrorBucketResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/MirrorBucket", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).MirrorBucket(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/MirrorBucket", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MirrorBucket(ctx, req.(*MsgMirrorBucket)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_DiscontinueBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDiscontinueBucket) - if err := dec(in); err != nil { +func (c *msgClient) DiscontinueBucket(ctx context.Context, in *MsgDiscontinueBucket, opts ...grpc.CallOption) (*MsgDiscontinueBucketResponse, error) { + out := new(MsgDiscontinueBucketResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DiscontinueBucket", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).DiscontinueBucket(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/DiscontinueBucket", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DiscontinueBucket(ctx, req.(*MsgDiscontinueBucket)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_CreateObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCreateObject) - if err := dec(in); err != nil { +func (c *msgClient) ToggleSPAsDelegatedAgent(ctx context.Context, in *MsgToggleSPAsDelegatedAgent, opts ...grpc.CallOption) (*MsgToggleSPAsDelegatedAgentResponse, error) { + out := new(MsgToggleSPAsDelegatedAgentResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/ToggleSPAsDelegatedAgent", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).CreateObject(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/CreateObject", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CreateObject(ctx, req.(*MsgCreateObject)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_SealObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgSealObject) - if err := dec(in); err != nil { +func (c *msgClient) CreateObject(ctx context.Context, in *MsgCreateObject, opts ...grpc.CallOption) (*MsgCreateObjectResponse, error) { + out := new(MsgCreateObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CreateObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).SealObject(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/SealObject", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).SealObject(ctx, req.(*MsgSealObject)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_RejectSealObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgRejectSealObject) - if err := dec(in); err != nil { +func (c *msgClient) SealObject(ctx context.Context, in *MsgSealObject, opts ...grpc.CallOption) (*MsgSealObjectResponse, error) { + out := new(MsgSealObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/SealObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).RejectSealObject(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/RejectSealObject", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).RejectSealObject(ctx, req.(*MsgRejectSealObject)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_CopyObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCopyObject) - if err := dec(in); err != nil { +func (c *msgClient) SealObjectV2(ctx context.Context, in *MsgSealObjectV2, opts ...grpc.CallOption) (*MsgSealObjectV2Response, error) { + out := new(MsgSealObjectV2Response) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/SealObjectV2", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).CopyObject(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/CopyObject", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CopyObject(ctx, req.(*MsgCopyObject)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_DeleteObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDeleteObject) - if err := dec(in); err != nil { +func (c *msgClient) RejectSealObject(ctx context.Context, in *MsgRejectSealObject, opts ...grpc.CallOption) (*MsgRejectSealObjectResponse, error) { + out := new(MsgRejectSealObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/RejectSealObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).DeleteObject(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/DeleteObject", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DeleteObject(ctx, req.(*MsgDeleteObject)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_CancelCreateObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCancelCreateObject) - if err := dec(in); err != nil { +func (c *msgClient) CopyObject(ctx context.Context, in *MsgCopyObject, opts ...grpc.CallOption) (*MsgCopyObjectResponse, error) { + out := new(MsgCopyObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CopyObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).CancelCreateObject(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/CancelCreateObject", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CancelCreateObject(ctx, req.(*MsgCancelCreateObject)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_MirrorObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgMirrorObject) - if err := dec(in); err != nil { +func (c *msgClient) DeleteObject(ctx context.Context, in *MsgDeleteObject, opts ...grpc.CallOption) (*MsgDeleteObjectResponse, error) { + out := new(MsgDeleteObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DeleteObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).MirrorObject(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/MirrorObject", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MirrorObject(ctx, req.(*MsgMirrorObject)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_DiscontinueObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDiscontinueObject) - if err := dec(in); err != nil { +func (c *msgClient) CancelCreateObject(ctx context.Context, in *MsgCancelCreateObject, opts ...grpc.CallOption) (*MsgCancelCreateObjectResponse, error) { + out := new(MsgCancelCreateObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CancelCreateObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).DiscontinueObject(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/DiscontinueObject", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DiscontinueObject(ctx, req.(*MsgDiscontinueObject)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_UpdateObjectInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgUpdateObjectInfo) - if err := dec(in); err != nil { +func (c *msgClient) MirrorObject(ctx context.Context, in *MsgMirrorObject, opts ...grpc.CallOption) (*MsgMirrorObjectResponse, error) { + out := new(MsgMirrorObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/MirrorObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).UpdateObjectInfo(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/UpdateObjectInfo", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).UpdateObjectInfo(ctx, req.(*MsgUpdateObjectInfo)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_UpdateObjectContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgUpdateObjectContent) - if err := dec(in); err != nil { +func (c *msgClient) DiscontinueObject(ctx context.Context, in *MsgDiscontinueObject, opts ...grpc.CallOption) (*MsgDiscontinueObjectResponse, error) { + out := new(MsgDiscontinueObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DiscontinueObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).UpdateObjectContent(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/UpdateObjectContent", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).UpdateObjectContent(ctx, req.(*MsgUpdateObjectContent)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_CancelUpdateObjectContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCancelUpdateObjectContent) - if err := dec(in); err != nil { +func (c *msgClient) UpdateObjectInfo(ctx context.Context, in *MsgUpdateObjectInfo, opts ...grpc.CallOption) (*MsgUpdateObjectInfoResponse, error) { + out := new(MsgUpdateObjectInfoResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateObjectInfo", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).CancelUpdateObjectContent(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/CancelUpdateObjectContent", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CancelUpdateObjectContent(ctx, req.(*MsgCancelUpdateObjectContent)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_CreateGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCreateGroup) - if err := dec(in); err != nil { +func (c *msgClient) UpdateObjectContent(ctx context.Context, in *MsgUpdateObjectContent, opts ...grpc.CallOption) (*MsgUpdateObjectContentResponse, error) { + out := new(MsgUpdateObjectContentResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateObjectContent", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).CreateGroup(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/CreateGroup", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CreateGroup(ctx, req.(*MsgCreateGroup)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_DeleteGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDeleteGroup) - if err := dec(in); err != nil { +func (c *msgClient) CancelUpdateObjectContent(ctx context.Context, in *MsgCancelUpdateObjectContent, opts ...grpc.CallOption) (*MsgCancelUpdateObjectContentResponse, error) { + out := new(MsgCancelUpdateObjectContentResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CancelUpdateObjectContent", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).DeleteGroup(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/DeleteGroup", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DeleteGroup(ctx, req.(*MsgDeleteGroup)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_UpdateGroupMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgUpdateGroupMember) - if err := dec(in); err != nil { +func (c *msgClient) DelegateCreateObject(ctx context.Context, in *MsgDelegateCreateObject, opts ...grpc.CallOption) (*MsgDelegateCreateObjectResponse, error) { + out := new(MsgDelegateCreateObjectResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DelegateCreateObject", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).UpdateGroupMember(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/UpdateGroupMember", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).UpdateGroupMember(ctx, req.(*MsgUpdateGroupMember)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_UpdateGroupExtra_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgUpdateGroupExtra) - if err := dec(in); err != nil { +func (c *msgClient) DelegateUpdateObjectContent(ctx context.Context, in *MsgDelegateUpdateObjectContent, opts ...grpc.CallOption) (*MsgDelegateUpdateObjectContentResponse, error) { + out := new(MsgDelegateUpdateObjectContentResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DelegateUpdateObjectContent", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).UpdateGroupExtra(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/UpdateGroupExtra", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).UpdateGroupExtra(ctx, req.(*MsgUpdateGroupExtra)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_LeaveGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgLeaveGroup) - if err := dec(in); err != nil { +func (c *msgClient) CreateGroup(ctx context.Context, in *MsgCreateGroup, opts ...grpc.CallOption) (*MsgCreateGroupResponse, error) { + out := new(MsgCreateGroupResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CreateGroup", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).LeaveGroup(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/LeaveGroup", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).LeaveGroup(ctx, req.(*MsgLeaveGroup)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_MirrorGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgMirrorGroup) - if err := dec(in); err != nil { +func (c *msgClient) DeleteGroup(ctx context.Context, in *MsgDeleteGroup, opts ...grpc.CallOption) (*MsgDeleteGroupResponse, error) { + out := new(MsgDeleteGroupResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DeleteGroup", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).MirrorGroup(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/MirrorGroup", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MirrorGroup(ctx, req.(*MsgMirrorGroup)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_RenewGroupMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgRenewGroupMember) - if err := dec(in); err != nil { +func (c *msgClient) UpdateGroupMember(ctx context.Context, in *MsgUpdateGroupMember, opts ...grpc.CallOption) (*MsgUpdateGroupMemberResponse, error) { + out := new(MsgUpdateGroupMemberResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateGroupMember", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).RenewGroupMember(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/RenewGroupMember", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).RenewGroupMember(ctx, req.(*MsgRenewGroupMember)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_PutPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgPutPolicy) - if err := dec(in); err != nil { +func (c *msgClient) UpdateGroupExtra(ctx context.Context, in *MsgUpdateGroupExtra, opts ...grpc.CallOption) (*MsgUpdateGroupExtraResponse, error) { + out := new(MsgUpdateGroupExtraResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateGroupExtra", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).PutPolicy(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/PutPolicy", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).PutPolicy(ctx, req.(*MsgPutPolicy)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_DeletePolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDeletePolicy) - if err := dec(in); err != nil { +func (c *msgClient) LeaveGroup(ctx context.Context, in *MsgLeaveGroup, opts ...grpc.CallOption) (*MsgLeaveGroupResponse, error) { + out := new(MsgLeaveGroupResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/LeaveGroup", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).DeletePolicy(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/DeletePolicy", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).DeletePolicy(ctx, req.(*MsgDeletePolicy)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgUpdateParams) - if err := dec(in); err != nil { +func (c *msgClient) MirrorGroup(ctx context.Context, in *MsgMirrorGroup, opts ...grpc.CallOption) (*MsgMirrorGroupResponse, error) { + out := new(MsgMirrorGroupResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/MirrorGroup", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).UpdateParams(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/UpdateParams", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_MigrateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgMigrateBucket) - if err := dec(in); err != nil { +func (c *msgClient) RenewGroupMember(ctx context.Context, in *MsgRenewGroupMember, opts ...grpc.CallOption) (*MsgRenewGroupMemberResponse, error) { + out := new(MsgRenewGroupMemberResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/RenewGroupMember", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).MigrateBucket(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/MigrateBucket", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MigrateBucket(ctx, req.(*MsgMigrateBucket)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_CompleteMigrateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCompleteMigrateBucket) - if err := dec(in); err != nil { +func (c *msgClient) PutPolicy(ctx context.Context, in *MsgPutPolicy, opts ...grpc.CallOption) (*MsgPutPolicyResponse, error) { + out := new(MsgPutPolicyResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/PutPolicy", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).CompleteMigrateBucket(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/CompleteMigrateBucket", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CompleteMigrateBucket(ctx, req.(*MsgCompleteMigrateBucket)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_CancelMigrateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCancelMigrateBucket) - if err := dec(in); err != nil { +func (c *msgClient) DeletePolicy(ctx context.Context, in *MsgDeletePolicy, opts ...grpc.CallOption) (*MsgDeletePolicyResponse, error) { + out := new(MsgDeletePolicyResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/DeletePolicy", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).CancelMigrateBucket(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/CancelMigrateBucket", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).CancelMigrateBucket(ctx, req.(*MsgCancelMigrateBucket)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_RejectMigrateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgRejectMigrateBucket) - if err := dec(in); err != nil { +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/UpdateParams", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).RejectMigrateBucket(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/RejectMigrateBucket", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).RejectMigrateBucket(ctx, req.(*MsgRejectMigrateBucket)) - } - return interceptor(ctx, in, info, handler) + return out, nil } -func _Msg_SetTag_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgSetTag) - if err := dec(in); err != nil { +func (c *msgClient) MigrateBucket(ctx context.Context, in *MsgMigrateBucket, opts ...grpc.CallOption) (*MsgMigrateBucketResponse, error) { + out := new(MsgMigrateBucketResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/MigrateBucket", in, out, opts...) + if err != nil { return nil, err } - if interceptor == nil { - return srv.(MsgServer).SetTag(ctx, in) + return out, nil +} + +func (c *msgClient) CompleteMigrateBucket(ctx context.Context, in *MsgCompleteMigrateBucket, opts ...grpc.CallOption) (*MsgCompleteMigrateBucketResponse, error) { + out := new(MsgCompleteMigrateBucketResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CompleteMigrateBucket", in, out, opts...) + if err != nil { + return nil, err } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/greenfield.storage.Msg/SetTag", + return out, nil +} + +func (c *msgClient) CancelMigrateBucket(ctx context.Context, in *MsgCancelMigrateBucket, opts ...grpc.CallOption) (*MsgCancelMigrateBucketResponse, error) { + out := new(MsgCancelMigrateBucketResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/CancelMigrateBucket", in, out, opts...) + if err != nil { + return nil, err } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).SetTag(ctx, req.(*MsgSetTag)) + return out, nil +} + +func (c *msgClient) RejectMigrateBucket(ctx context.Context, in *MsgRejectMigrateBucket, opts ...grpc.CallOption) (*MsgRejectMigrateBucketResponse, error) { + out := new(MsgRejectMigrateBucketResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/RejectMigrateBucket", in, out, opts...) + if err != nil { + return nil, err } - return interceptor(ctx, in, info, handler) + return out, nil } -var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "greenfield.storage.Msg", - HandlerType: (*MsgServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "CreateBucket", - Handler: _Msg_CreateBucket_Handler, - }, - { - MethodName: "DeleteBucket", - Handler: _Msg_DeleteBucket_Handler, - }, - { - MethodName: "UpdateBucketInfo", - Handler: _Msg_UpdateBucketInfo_Handler, - }, - { - MethodName: "MirrorBucket", - Handler: _Msg_MirrorBucket_Handler, - }, - { - MethodName: "DiscontinueBucket", - Handler: _Msg_DiscontinueBucket_Handler, - }, - { - MethodName: "CreateObject", - Handler: _Msg_CreateObject_Handler, - }, - { - MethodName: "SealObject", - Handler: _Msg_SealObject_Handler, - }, - { - MethodName: "RejectSealObject", - Handler: _Msg_RejectSealObject_Handler, - }, - { - MethodName: "CopyObject", - Handler: _Msg_CopyObject_Handler, - }, - { - MethodName: "DeleteObject", - Handler: _Msg_DeleteObject_Handler, - }, - { - MethodName: "CancelCreateObject", - Handler: _Msg_CancelCreateObject_Handler, - }, - { - MethodName: "MirrorObject", - Handler: _Msg_MirrorObject_Handler, - }, - { - MethodName: "DiscontinueObject", - Handler: _Msg_DiscontinueObject_Handler, - }, - { - MethodName: "UpdateObjectInfo", - Handler: _Msg_UpdateObjectInfo_Handler, - }, - { - MethodName: "UpdateObjectContent", - Handler: _Msg_UpdateObjectContent_Handler, - }, - { - MethodName: "CancelUpdateObjectContent", - Handler: _Msg_CancelUpdateObjectContent_Handler, - }, - { - MethodName: "CreateGroup", - Handler: _Msg_CreateGroup_Handler, - }, - { - MethodName: "DeleteGroup", - Handler: _Msg_DeleteGroup_Handler, - }, - { - MethodName: "UpdateGroupMember", - Handler: _Msg_UpdateGroupMember_Handler, - }, - { - MethodName: "UpdateGroupExtra", - Handler: _Msg_UpdateGroupExtra_Handler, - }, - { - MethodName: "LeaveGroup", - Handler: _Msg_LeaveGroup_Handler, - }, - { - MethodName: "MirrorGroup", - Handler: _Msg_MirrorGroup_Handler, - }, - { - MethodName: "RenewGroupMember", - Handler: _Msg_RenewGroupMember_Handler, - }, - { - MethodName: "PutPolicy", - Handler: _Msg_PutPolicy_Handler, - }, - { - MethodName: "DeletePolicy", - Handler: _Msg_DeletePolicy_Handler, - }, - { - MethodName: "UpdateParams", - Handler: _Msg_UpdateParams_Handler, - }, - { - MethodName: "MigrateBucket", - Handler: _Msg_MigrateBucket_Handler, - }, - { - MethodName: "CompleteMigrateBucket", - Handler: _Msg_CompleteMigrateBucket_Handler, - }, - { - MethodName: "CancelMigrateBucket", - Handler: _Msg_CancelMigrateBucket_Handler, - }, - { - MethodName: "RejectMigrateBucket", - Handler: _Msg_RejectMigrateBucket_Handler, - }, - { - MethodName: "SetTag", - Handler: _Msg_SetTag_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "greenfield/storage/tx.proto", -} - -func (m *MsgCreateBucket) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) +func (c *msgClient) SetTag(ctx context.Context, in *MsgSetTag, opts ...grpc.CallOption) (*MsgSetTagResponse, error) { + out := new(MsgSetTagResponse) + err := c.cc.Invoke(ctx, "/greenfield.storage.Msg/SetTag", in, out, opts...) if err != nil { return nil, err } - return dAtA[:n], nil + return out, nil } -func (m *MsgCreateBucket) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +// MsgServer is the server API for Msg service. +type MsgServer interface { + // basic operation of bucket + CreateBucket(context.Context, *MsgCreateBucket) (*MsgCreateBucketResponse, error) + DeleteBucket(context.Context, *MsgDeleteBucket) (*MsgDeleteBucketResponse, error) + UpdateBucketInfo(context.Context, *MsgUpdateBucketInfo) (*MsgUpdateBucketInfoResponse, error) + MirrorBucket(context.Context, *MsgMirrorBucket) (*MsgMirrorBucketResponse, error) + DiscontinueBucket(context.Context, *MsgDiscontinueBucket) (*MsgDiscontinueBucketResponse, error) + ToggleSPAsDelegatedAgent(context.Context, *MsgToggleSPAsDelegatedAgent) (*MsgToggleSPAsDelegatedAgentResponse, error) + // basic operation of object + CreateObject(context.Context, *MsgCreateObject) (*MsgCreateObjectResponse, error) + SealObject(context.Context, *MsgSealObject) (*MsgSealObjectResponse, error) + SealObjectV2(context.Context, *MsgSealObjectV2) (*MsgSealObjectV2Response, error) + RejectSealObject(context.Context, *MsgRejectSealObject) (*MsgRejectSealObjectResponse, error) + CopyObject(context.Context, *MsgCopyObject) (*MsgCopyObjectResponse, error) + DeleteObject(context.Context, *MsgDeleteObject) (*MsgDeleteObjectResponse, error) + CancelCreateObject(context.Context, *MsgCancelCreateObject) (*MsgCancelCreateObjectResponse, error) + MirrorObject(context.Context, *MsgMirrorObject) (*MsgMirrorObjectResponse, error) + DiscontinueObject(context.Context, *MsgDiscontinueObject) (*MsgDiscontinueObjectResponse, error) + UpdateObjectInfo(context.Context, *MsgUpdateObjectInfo) (*MsgUpdateObjectInfoResponse, error) + UpdateObjectContent(context.Context, *MsgUpdateObjectContent) (*MsgUpdateObjectContentResponse, error) + CancelUpdateObjectContent(context.Context, *MsgCancelUpdateObjectContent) (*MsgCancelUpdateObjectContentResponse, error) + DelegateCreateObject(context.Context, *MsgDelegateCreateObject) (*MsgDelegateCreateObjectResponse, error) + DelegateUpdateObjectContent(context.Context, *MsgDelegateUpdateObjectContent) (*MsgDelegateUpdateObjectContentResponse, error) + // basic operation of group + CreateGroup(context.Context, *MsgCreateGroup) (*MsgCreateGroupResponse, error) + DeleteGroup(context.Context, *MsgDeleteGroup) (*MsgDeleteGroupResponse, error) + UpdateGroupMember(context.Context, *MsgUpdateGroupMember) (*MsgUpdateGroupMemberResponse, error) + UpdateGroupExtra(context.Context, *MsgUpdateGroupExtra) (*MsgUpdateGroupExtraResponse, error) + LeaveGroup(context.Context, *MsgLeaveGroup) (*MsgLeaveGroupResponse, error) + MirrorGroup(context.Context, *MsgMirrorGroup) (*MsgMirrorGroupResponse, error) + RenewGroupMember(context.Context, *MsgRenewGroupMember) (*MsgRenewGroupMemberResponse, error) + // basic operation of policy + PutPolicy(context.Context, *MsgPutPolicy) (*MsgPutPolicyResponse, error) + DeletePolicy(context.Context, *MsgDeletePolicy) (*MsgDeletePolicyResponse, error) + // Since: cosmos-sdk 0.47 + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) + MigrateBucket(context.Context, *MsgMigrateBucket) (*MsgMigrateBucketResponse, error) + CompleteMigrateBucket(context.Context, *MsgCompleteMigrateBucket) (*MsgCompleteMigrateBucketResponse, error) + CancelMigrateBucket(context.Context, *MsgCancelMigrateBucket) (*MsgCancelMigrateBucketResponse, error) + RejectMigrateBucket(context.Context, *MsgRejectMigrateBucket) (*MsgRejectMigrateBucketResponse, error) + // Since: Manchurian upgrade + SetTag(context.Context, *MsgSetTag) (*MsgSetTagResponse, error) } -func (m *MsgCreateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.ChargedReadQuota != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.ChargedReadQuota)) - i-- - dAtA[i] = 0x38 - } - if m.PrimarySpApproval != nil { - { - size, err := m.PrimarySpApproval.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - } - if len(m.PrimarySpAddress) > 0 { - i -= len(m.PrimarySpAddress) - copy(dAtA[i:], m.PrimarySpAddress) - i = encodeVarintTx(dAtA, i, uint64(len(m.PrimarySpAddress))) - 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 m.Visibility != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) - i-- - dAtA[i] = 0x18 - } - 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.Creator) > 0 { - i -= len(m.Creator) - copy(dAtA[i:], m.Creator) - i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { } -func (m *MsgCreateBucketResponse) 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 (*UnimplementedMsgServer) CreateBucket(ctx context.Context, req *MsgCreateBucket) (*MsgCreateBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateBucket not implemented") } - -func (m *MsgCreateBucketResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) DeleteBucket(ctx context.Context, req *MsgDeleteBucket) (*MsgDeleteBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteBucket not implemented") } - -func (m *MsgCreateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.BucketId.Size() - i -= size - if _, err := m.BucketId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil +func (*UnimplementedMsgServer) UpdateBucketInfo(ctx context.Context, req *MsgUpdateBucketInfo) (*MsgUpdateBucketInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateBucketInfo not implemented") } - -func (m *MsgDeleteBucket) 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 (*UnimplementedMsgServer) MirrorBucket(ctx context.Context, req *MsgMirrorBucket) (*MsgMirrorBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MirrorBucket not implemented") } - -func (m *MsgDeleteBucket) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) DiscontinueBucket(ctx context.Context, req *MsgDiscontinueBucket) (*MsgDiscontinueBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DiscontinueBucket not implemented") } - -func (m *MsgDeleteBucket) 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 = 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 (*UnimplementedMsgServer) ToggleSPAsDelegatedAgent(ctx context.Context, req *MsgToggleSPAsDelegatedAgent) (*MsgToggleSPAsDelegatedAgentResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ToggleSPAsDelegatedAgent not implemented") } - -func (m *MsgDeleteBucketResponse) 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 (*UnimplementedMsgServer) CreateObject(ctx context.Context, req *MsgCreateObject) (*MsgCreateObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateObject not implemented") } - -func (m *MsgDeleteBucketResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func (*UnimplementedMsgServer) SealObject(ctx context.Context, req *MsgSealObject) (*MsgSealObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SealObject not implemented") +} +func (*UnimplementedMsgServer) SealObjectV2(ctx context.Context, req *MsgSealObjectV2) (*MsgSealObjectV2Response, error) { + return nil, status.Errorf(codes.Unimplemented, "method SealObjectV2 not implemented") +} +func (*UnimplementedMsgServer) RejectSealObject(ctx context.Context, req *MsgRejectSealObject) (*MsgRejectSealObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RejectSealObject not implemented") +} +func (*UnimplementedMsgServer) CopyObject(ctx context.Context, req *MsgCopyObject) (*MsgCopyObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CopyObject not implemented") +} +func (*UnimplementedMsgServer) DeleteObject(ctx context.Context, req *MsgDeleteObject) (*MsgDeleteObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteObject not implemented") +} +func (*UnimplementedMsgServer) CancelCreateObject(ctx context.Context, req *MsgCancelCreateObject) (*MsgCancelCreateObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CancelCreateObject not implemented") +} +func (*UnimplementedMsgServer) MirrorObject(ctx context.Context, req *MsgMirrorObject) (*MsgMirrorObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MirrorObject not implemented") +} +func (*UnimplementedMsgServer) DiscontinueObject(ctx context.Context, req *MsgDiscontinueObject) (*MsgDiscontinueObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DiscontinueObject not implemented") +} +func (*UnimplementedMsgServer) UpdateObjectInfo(ctx context.Context, req *MsgUpdateObjectInfo) (*MsgUpdateObjectInfoResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateObjectInfo not implemented") +} +func (*UnimplementedMsgServer) UpdateObjectContent(ctx context.Context, req *MsgUpdateObjectContent) (*MsgUpdateObjectContentResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateObjectContent not implemented") +} +func (*UnimplementedMsgServer) CancelUpdateObjectContent(ctx context.Context, req *MsgCancelUpdateObjectContent) (*MsgCancelUpdateObjectContentResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CancelUpdateObjectContent not implemented") +} +func (*UnimplementedMsgServer) DelegateCreateObject(ctx context.Context, req *MsgDelegateCreateObject) (*MsgDelegateCreateObjectResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DelegateCreateObject not implemented") +} +func (*UnimplementedMsgServer) DelegateUpdateObjectContent(ctx context.Context, req *MsgDelegateUpdateObjectContent) (*MsgDelegateUpdateObjectContentResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DelegateUpdateObjectContent not implemented") +} +func (*UnimplementedMsgServer) CreateGroup(ctx context.Context, req *MsgCreateGroup) (*MsgCreateGroupResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CreateGroup not implemented") +} +func (*UnimplementedMsgServer) DeleteGroup(ctx context.Context, req *MsgDeleteGroup) (*MsgDeleteGroupResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteGroup not implemented") +} +func (*UnimplementedMsgServer) UpdateGroupMember(ctx context.Context, req *MsgUpdateGroupMember) (*MsgUpdateGroupMemberResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateGroupMember not implemented") +} +func (*UnimplementedMsgServer) UpdateGroupExtra(ctx context.Context, req *MsgUpdateGroupExtra) (*MsgUpdateGroupExtraResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateGroupExtra not implemented") +} +func (*UnimplementedMsgServer) LeaveGroup(ctx context.Context, req *MsgLeaveGroup) (*MsgLeaveGroupResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LeaveGroup not implemented") +} +func (*UnimplementedMsgServer) MirrorGroup(ctx context.Context, req *MsgMirrorGroup) (*MsgMirrorGroupResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MirrorGroup not implemented") +} +func (*UnimplementedMsgServer) RenewGroupMember(ctx context.Context, req *MsgRenewGroupMember) (*MsgRenewGroupMemberResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RenewGroupMember not implemented") +} +func (*UnimplementedMsgServer) PutPolicy(ctx context.Context, req *MsgPutPolicy) (*MsgPutPolicyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method PutPolicy not implemented") +} +func (*UnimplementedMsgServer) DeletePolicy(ctx context.Context, req *MsgDeletePolicy) (*MsgDeletePolicyResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeletePolicy not implemented") +} +func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} +func (*UnimplementedMsgServer) MigrateBucket(ctx context.Context, req *MsgMigrateBucket) (*MsgMigrateBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MigrateBucket not implemented") +} +func (*UnimplementedMsgServer) CompleteMigrateBucket(ctx context.Context, req *MsgCompleteMigrateBucket) (*MsgCompleteMigrateBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CompleteMigrateBucket not implemented") +} +func (*UnimplementedMsgServer) CancelMigrateBucket(ctx context.Context, req *MsgCancelMigrateBucket) (*MsgCancelMigrateBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CancelMigrateBucket not implemented") +} +func (*UnimplementedMsgServer) RejectMigrateBucket(ctx context.Context, req *MsgRejectMigrateBucket) (*MsgRejectMigrateBucketResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RejectMigrateBucket not implemented") +} +func (*UnimplementedMsgServer) SetTag(ctx context.Context, req *MsgSetTag) (*MsgSetTagResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetTag not implemented") } -func (m *MsgDeleteBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) } -func (m *MsgDiscontinueBucket) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_CreateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCreateBucket) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(MsgServer).CreateBucket(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/CreateBucket", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CreateBucket(ctx, req.(*MsgCreateBucket)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDiscontinueBucket) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _Msg_DeleteBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDeleteBucket) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).DeleteBucket(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/DeleteBucket", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DeleteBucket(ctx, req.(*MsgDeleteBucket)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDiscontinueBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Reason) > 0 { - i -= len(m.Reason) - copy(dAtA[i:], m.Reason) - i = encodeVarintTx(dAtA, i, uint64(len(m.Reason))) - i-- - dAtA[i] = 0x1a +func _Msg_UpdateBucketInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateBucketInfo) + if err := dec(in); err != nil { + return nil, err } - 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 interceptor == nil { + return srv.(MsgServer).UpdateBucketInfo(ctx, in) } - 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 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/UpdateBucketInfo", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateBucketInfo(ctx, req.(*MsgUpdateBucketInfo)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDiscontinueBucketResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_MirrorBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMirrorBucket) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(MsgServer).MirrorBucket(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/MirrorBucket", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MirrorBucket(ctx, req.(*MsgMirrorBucket)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDiscontinueBucketResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgDiscontinueBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *MsgCreateObject) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_DiscontinueBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDiscontinueBucket) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgCreateObject) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).DiscontinueBucket(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/DiscontinueBucket", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DiscontinueBucket(ctx, req.(*MsgDiscontinueBucket)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCreateObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.RedundancyType != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.RedundancyType)) - i-- - dAtA[i] = 0x48 - } - if len(m.ExpectChecksums) > 0 { - for iNdEx := len(m.ExpectChecksums) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.ExpectChecksums[iNdEx]) - copy(dAtA[i:], m.ExpectChecksums[iNdEx]) - i = encodeVarintTx(dAtA, i, uint64(len(m.ExpectChecksums[iNdEx]))) - i-- - dAtA[i] = 0x42 - } +func _Msg_ToggleSPAsDelegatedAgent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgToggleSPAsDelegatedAgent) + if err := dec(in); err != nil { + return nil, err } - if m.PrimarySpApproval != nil { - { - size, err := m.PrimarySpApproval.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3a + if interceptor == nil { + return srv.(MsgServer).ToggleSPAsDelegatedAgent(ctx, in) } - if len(m.ContentType) > 0 { - i -= len(m.ContentType) - copy(dAtA[i:], m.ContentType) - i = encodeVarintTx(dAtA, i, uint64(len(m.ContentType))) - i-- - dAtA[i] = 0x32 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/ToggleSPAsDelegatedAgent", } - if m.Visibility != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) - i-- - dAtA[i] = 0x28 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ToggleSPAsDelegatedAgent(ctx, req.(*MsgToggleSPAsDelegatedAgent)) } - if m.PayloadSize != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.PayloadSize)) - i-- - dAtA[i] = 0x20 + return interceptor(ctx, in, info, handler) +} + +func _Msg_CreateObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCreateObject) + if err := dec(in); err != nil { + return nil, err } - if len(m.ObjectName) > 0 { - i -= len(m.ObjectName) - copy(dAtA[i:], m.ObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) - i-- - dAtA[i] = 0x1a + if interceptor == nil { + return srv.(MsgServer).CreateObject(ctx, in) } - 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 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/CreateObject", } - if len(m.Creator) > 0 { - i -= len(m.Creator) - copy(dAtA[i:], m.Creator) - i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) - i-- - dAtA[i] = 0xa + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CreateObject(ctx, req.(*MsgCreateObject)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *MsgCreateObjectResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_SealObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSealObject) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgCreateObjectResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgCreateObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.ObjectId.Size() - i -= size - if _, err := m.ObjectId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) + if interceptor == nil { + return srv.(MsgServer).SealObject(ctx, in) } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/SealObject", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).SealObject(ctx, req.(*MsgSealObject)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgSealObject) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_SealObjectV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSealObjectV2) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgSealObject) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).SealObjectV2(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/SealObjectV2", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).SealObjectV2(ctx, req.(*MsgSealObjectV2)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgSealObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.SecondarySpBlsAggSignatures) > 0 { - i -= len(m.SecondarySpBlsAggSignatures) - copy(dAtA[i:], m.SecondarySpBlsAggSignatures) - i = encodeVarintTx(dAtA, i, uint64(len(m.SecondarySpBlsAggSignatures))) - i-- - dAtA[i] = 0x2a - } - if m.GlobalVirtualGroupId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.GlobalVirtualGroupId)) - i-- - dAtA[i] = 0x20 +func _Msg_RejectSealObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRejectSealObject) + if err := dec(in); err != nil { + return nil, err } - if len(m.ObjectName) > 0 { - i -= len(m.ObjectName) - copy(dAtA[i:], m.ObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) - i-- - dAtA[i] = 0x1a + if interceptor == nil { + return srv.(MsgServer).RejectSealObject(ctx, in) } - 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 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/RejectSealObject", } - 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 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RejectSealObject(ctx, req.(*MsgRejectSealObject)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *MsgSealObjectResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_CopyObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCopyObject) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgSealObjectResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).CopyObject(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/CopyObject", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CopyObject(ctx, req.(*MsgCopyObject)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgSealObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *MsgRejectSealObject) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_DeleteObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDeleteObject) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgRejectSealObject) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).DeleteObject(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/DeleteObject", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DeleteObject(ctx, req.(*MsgDeleteObject)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRejectSealObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ObjectName) > 0 { - i -= len(m.ObjectName) - copy(dAtA[i:], m.ObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) - i-- - dAtA[i] = 0x1a +func _Msg_CancelCreateObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCancelCreateObject) + if err := dec(in); err != nil { + return nil, err } - 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 interceptor == nil { + return srv.(MsgServer).CancelCreateObject(ctx, in) } - 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 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/CancelCreateObject", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CancelCreateObject(ctx, req.(*MsgCancelCreateObject)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRejectSealObjectResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_MirrorObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMirrorObject) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(MsgServer).MirrorObject(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/MirrorObject", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MirrorObject(ctx, req.(*MsgMirrorObject)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRejectSealObjectResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _Msg_DiscontinueObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDiscontinueObject) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).DiscontinueObject(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/DiscontinueObject", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DiscontinueObject(ctx, req.(*MsgDiscontinueObject)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgRejectSealObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func _Msg_UpdateObjectInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateObjectInfo) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateObjectInfo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/UpdateObjectInfo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateObjectInfo(ctx, req.(*MsgUpdateObjectInfo)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCopyObject) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_UpdateObjectContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateObjectContent) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(MsgServer).UpdateObjectContent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/UpdateObjectContent", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateObjectContent(ctx, req.(*MsgUpdateObjectContent)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCopyObject) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) +func _Msg_CancelUpdateObjectContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCancelUpdateObjectContent) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).CancelUpdateObjectContent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/CancelUpdateObjectContent", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CancelUpdateObjectContent(ctx, req.(*MsgCancelUpdateObjectContent)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCopyObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.DstPrimarySpApproval != nil { - { - size, err := m.DstPrimarySpApproval.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 +func _Msg_DelegateCreateObject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDelegateCreateObject) + if err := dec(in); err != nil { + return nil, err } - if len(m.DstObjectName) > 0 { - i -= len(m.DstObjectName) - copy(dAtA[i:], m.DstObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.DstObjectName))) - i-- - dAtA[i] = 0x2a + if interceptor == nil { + return srv.(MsgServer).DelegateCreateObject(ctx, in) } - if len(m.SrcObjectName) > 0 { - i -= len(m.SrcObjectName) - copy(dAtA[i:], m.SrcObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.SrcObjectName))) - i-- - dAtA[i] = 0x22 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/DelegateCreateObject", } - if len(m.DstBucketName) > 0 { - i -= len(m.DstBucketName) - copy(dAtA[i:], m.DstBucketName) - i = encodeVarintTx(dAtA, i, uint64(len(m.DstBucketName))) - i-- - dAtA[i] = 0x1a + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DelegateCreateObject(ctx, req.(*MsgDelegateCreateObject)) } - if len(m.SrcBucketName) > 0 { - i -= len(m.SrcBucketName) - copy(dAtA[i:], m.SrcBucketName) - i = encodeVarintTx(dAtA, i, uint64(len(m.SrcBucketName))) - i-- - dAtA[i] = 0x12 + return interceptor(ctx, in, info, handler) +} + +func _Msg_DelegateUpdateObjectContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDelegateUpdateObjectContent) + if err := dec(in); err != nil { + return nil, err } - 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 + if interceptor == nil { + return srv.(MsgServer).DelegateUpdateObjectContent(ctx, in) } - return len(dAtA) - i, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/DelegateUpdateObjectContent", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DelegateUpdateObjectContent(ctx, req.(*MsgDelegateUpdateObjectContent)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCopyObjectResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_CreateGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCreateGroup) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(MsgServer).CreateGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/CreateGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CreateGroup(ctx, req.(*MsgCreateGroup)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCopyObjectResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgCopyObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.ObjectId.Size() - i -= size - if _, err := m.ObjectId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) +func _Msg_DeleteGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDeleteGroup) + if err := dec(in); err != nil { + return nil, err } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil + if interceptor == nil { + return srv.(MsgServer).DeleteGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/DeleteGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DeleteGroup(ctx, req.(*MsgDeleteGroup)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDeleteObject) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_UpdateGroupMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateGroupMember) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgDeleteObject) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgDeleteObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ObjectName) > 0 { - i -= len(m.ObjectName) - copy(dAtA[i:], m.ObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) - i-- - dAtA[i] = 0x1a + if interceptor == nil { + return srv.(MsgServer).UpdateGroupMember(ctx, in) } - 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 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/UpdateGroupMember", } - 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 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateGroupMember(ctx, req.(*MsgUpdateGroupMember)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *MsgDeleteObjectResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_UpdateGroupExtra_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateGroupExtra) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgDeleteObjectResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgDeleteObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil + if interceptor == nil { + return srv.(MsgServer).UpdateGroupExtra(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/UpdateGroupExtra", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateGroupExtra(ctx, req.(*MsgUpdateGroupExtra)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDiscontinueObject) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_LeaveGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgLeaveGroup) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgDiscontinueObject) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).LeaveGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/LeaveGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).LeaveGroup(ctx, req.(*MsgLeaveGroup)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDiscontinueObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Reason) > 0 { - i -= len(m.Reason) - copy(dAtA[i:], m.Reason) - i = encodeVarintTx(dAtA, i, uint64(len(m.Reason))) - i-- - dAtA[i] = 0x22 +func _Msg_MirrorGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMirrorGroup) + if err := dec(in); err != nil { + return nil, err } - if len(m.ObjectIds) > 0 { - for iNdEx := len(m.ObjectIds) - 1; iNdEx >= 0; iNdEx-- { - { - size := m.ObjectIds[iNdEx].Size() - i -= size - if _, err := m.ObjectIds[iNdEx].MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } + if interceptor == nil { + return srv.(MsgServer).MirrorGroup(ctx, in) } - 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 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/MirrorGroup", } - 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 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MirrorGroup(ctx, req.(*MsgMirrorGroup)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *MsgDiscontinueObjectResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_RenewGroupMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRenewGroupMember) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgDiscontinueObjectResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).RenewGroupMember(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/RenewGroupMember", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RenewGroupMember(ctx, req.(*MsgRenewGroupMember)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDiscontinueObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +func _Msg_PutPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgPutPolicy) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).PutPolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/PutPolicy", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).PutPolicy(ctx, req.(*MsgPutPolicy)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCreateGroup) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_DeletePolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDeletePolicy) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil + if interceptor == nil { + return srv.(MsgServer).DeletePolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/DeletePolicy", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).DeletePolicy(ctx, req.(*MsgDeletePolicy)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCreateGroup) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgCreateGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Extra) > 0 { - i -= len(m.Extra) - copy(dAtA[i:], m.Extra) - i = encodeVarintTx(dAtA, i, uint64(len(m.Extra))) - i-- - dAtA[i] = 0x1a +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err } - if len(m.GroupName) > 0 { - i -= len(m.GroupName) - copy(dAtA[i:], m.GroupName) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) - i-- - dAtA[i] = 0x12 + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) } - if len(m.Creator) > 0 { - i -= len(m.Creator) - copy(dAtA[i:], m.Creator) - i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) - i-- - dAtA[i] = 0xa + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/UpdateParams", } - return len(dAtA) - i, nil + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgCreateGroupResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_MigrateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgMigrateBucket) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgCreateGroupResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgCreateGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.GroupId.Size() - i -= size - if _, err := m.GroupId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) + if interceptor == nil { + return srv.(MsgServer).MigrateBucket(ctx, in) } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/MigrateBucket", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MigrateBucket(ctx, req.(*MsgMigrateBucket)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgDeleteGroup) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_CompleteMigrateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCompleteMigrateBucket) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgDeleteGroup) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgDeleteGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.GroupName) > 0 { - i -= len(m.GroupName) - copy(dAtA[i:], m.GroupName) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) - i-- - dAtA[i] = 0x12 + if interceptor == nil { + return srv.(MsgServer).CompleteMigrateBucket(ctx, in) } - 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 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/CompleteMigrateBucket", } - return len(dAtA) - i, nil -} - -func (m *MsgDeleteGroupResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CompleteMigrateBucket(ctx, req.(*MsgCompleteMigrateBucket)) } - return dAtA[:n], nil -} - -func (m *MsgDeleteGroupResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgDeleteGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *MsgUpdateGroupMember) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_CancelMigrateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCancelMigrateBucket) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgUpdateGroupMember) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).CancelMigrateBucket(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/CancelMigrateBucket", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).CancelMigrateBucket(ctx, req.(*MsgCancelMigrateBucket)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgUpdateGroupMember) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.MembersToDelete) > 0 { - for iNdEx := len(m.MembersToDelete) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.MembersToDelete[iNdEx]) - copy(dAtA[i:], m.MembersToDelete[iNdEx]) - i = encodeVarintTx(dAtA, i, uint64(len(m.MembersToDelete[iNdEx]))) - i-- - dAtA[i] = 0x2a - } - } - if len(m.MembersToAdd) > 0 { - for iNdEx := len(m.MembersToAdd) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.MembersToAdd[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } +func _Msg_RejectMigrateBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRejectMigrateBucket) + if err := dec(in); err != nil { + return nil, err } - if len(m.GroupName) > 0 { - i -= len(m.GroupName) - copy(dAtA[i:], m.GroupName) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) - i-- - dAtA[i] = 0x1a + if interceptor == nil { + return srv.(MsgServer).RejectMigrateBucket(ctx, in) } - if len(m.GroupOwner) > 0 { - i -= len(m.GroupOwner) - copy(dAtA[i:], m.GroupOwner) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupOwner))) - i-- - dAtA[i] = 0x12 + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/RejectMigrateBucket", } - 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 + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RejectMigrateBucket(ctx, req.(*MsgRejectMigrateBucket)) } - return len(dAtA) - i, nil + return interceptor(ctx, in, info, handler) } -func (m *MsgUpdateGroupMemberResponse) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { +func _Msg_SetTag_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSetTag) + if err := dec(in); err != nil { return nil, err } - return dAtA[:n], nil -} - -func (m *MsgUpdateGroupMemberResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) + if interceptor == nil { + return srv.(MsgServer).SetTag(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/greenfield.storage.Msg/SetTag", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).SetTag(ctx, req.(*MsgSetTag)) + } + return interceptor(ctx, in, info, handler) } -func (m *MsgUpdateGroupMemberResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "greenfield.storage.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateBucket", + Handler: _Msg_CreateBucket_Handler, + }, + { + MethodName: "DeleteBucket", + Handler: _Msg_DeleteBucket_Handler, + }, + { + MethodName: "UpdateBucketInfo", + Handler: _Msg_UpdateBucketInfo_Handler, + }, + { + MethodName: "MirrorBucket", + Handler: _Msg_MirrorBucket_Handler, + }, + { + MethodName: "DiscontinueBucket", + Handler: _Msg_DiscontinueBucket_Handler, + }, + { + MethodName: "ToggleSPAsDelegatedAgent", + Handler: _Msg_ToggleSPAsDelegatedAgent_Handler, + }, + { + MethodName: "CreateObject", + Handler: _Msg_CreateObject_Handler, + }, + { + MethodName: "SealObject", + Handler: _Msg_SealObject_Handler, + }, + { + MethodName: "SealObjectV2", + Handler: _Msg_SealObjectV2_Handler, + }, + { + MethodName: "RejectSealObject", + Handler: _Msg_RejectSealObject_Handler, + }, + { + MethodName: "CopyObject", + Handler: _Msg_CopyObject_Handler, + }, + { + MethodName: "DeleteObject", + Handler: _Msg_DeleteObject_Handler, + }, + { + MethodName: "CancelCreateObject", + Handler: _Msg_CancelCreateObject_Handler, + }, + { + MethodName: "MirrorObject", + Handler: _Msg_MirrorObject_Handler, + }, + { + MethodName: "DiscontinueObject", + Handler: _Msg_DiscontinueObject_Handler, + }, + { + MethodName: "UpdateObjectInfo", + Handler: _Msg_UpdateObjectInfo_Handler, + }, + { + MethodName: "UpdateObjectContent", + Handler: _Msg_UpdateObjectContent_Handler, + }, + { + MethodName: "CancelUpdateObjectContent", + Handler: _Msg_CancelUpdateObjectContent_Handler, + }, + { + MethodName: "DelegateCreateObject", + Handler: _Msg_DelegateCreateObject_Handler, + }, + { + MethodName: "DelegateUpdateObjectContent", + Handler: _Msg_DelegateUpdateObjectContent_Handler, + }, + { + MethodName: "CreateGroup", + Handler: _Msg_CreateGroup_Handler, + }, + { + MethodName: "DeleteGroup", + Handler: _Msg_DeleteGroup_Handler, + }, + { + MethodName: "UpdateGroupMember", + Handler: _Msg_UpdateGroupMember_Handler, + }, + { + MethodName: "UpdateGroupExtra", + Handler: _Msg_UpdateGroupExtra_Handler, + }, + { + MethodName: "LeaveGroup", + Handler: _Msg_LeaveGroup_Handler, + }, + { + MethodName: "MirrorGroup", + Handler: _Msg_MirrorGroup_Handler, + }, + { + MethodName: "RenewGroupMember", + Handler: _Msg_RenewGroupMember_Handler, + }, + { + MethodName: "PutPolicy", + Handler: _Msg_PutPolicy_Handler, + }, + { + MethodName: "DeletePolicy", + Handler: _Msg_DeletePolicy_Handler, + }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, + { + MethodName: "MigrateBucket", + Handler: _Msg_MigrateBucket_Handler, + }, + { + MethodName: "CompleteMigrateBucket", + Handler: _Msg_CompleteMigrateBucket_Handler, + }, + { + MethodName: "CancelMigrateBucket", + Handler: _Msg_CancelMigrateBucket_Handler, + }, + { + MethodName: "RejectMigrateBucket", + Handler: _Msg_RejectMigrateBucket_Handler, + }, + { + MethodName: "SetTag", + Handler: _Msg_SetTag_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "greenfield/storage/tx.proto", } -func (m *MsgRenewGroupMember) Marshal() (dAtA []byte, err error) { +func (m *MsgCreateBucket) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5797,55 +5497,70 @@ func (m *MsgRenewGroupMember) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgRenewGroupMember) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCreateBucket) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgRenewGroupMember) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCreateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Members) > 0 { - for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) + if m.ChargedReadQuota != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.ChargedReadQuota)) + i-- + dAtA[i] = 0x38 + } + if m.PrimarySpApproval != nil { + { + size, err := m.PrimarySpApproval.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } - i-- - dAtA[i] = 0x22 + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x32 } - if len(m.GroupName) > 0 { - i -= len(m.GroupName) - copy(dAtA[i:], m.GroupName) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) + if len(m.PrimarySpAddress) > 0 { + i -= len(m.PrimarySpAddress) + copy(dAtA[i:], m.PrimarySpAddress) + i = encodeVarintTx(dAtA, i, uint64(len(m.PrimarySpAddress))) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x2a } - if len(m.GroupOwner) > 0 { - i -= len(m.GroupOwner) - copy(dAtA[i:], m.GroupOwner) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupOwner))) + 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 m.Visibility != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) + i-- + dAtA[i] = 0x18 + } + 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))) + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *MsgRenewGroupMemberResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgCreateBucketResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5855,20 +5570,30 @@ func (m *MsgRenewGroupMemberResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgRenewGroupMemberResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCreateBucketResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgRenewGroupMemberResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCreateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l + { + size := m.BucketId.Size() + i -= size + if _, err := m.BucketId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *MsgGroupMember) Marshal() (dAtA []byte, err error) { +func (m *MsgDeleteBucket) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5878,37 +5603,34 @@ func (m *MsgGroupMember) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgGroupMember) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDeleteBucket) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgGroupMember) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDeleteBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.ExpirationTime != nil { - n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime):]) - if err4 != nil { - return 0, err4 - } - i -= n4 - i = encodeVarintTx(dAtA, i, uint64(n4)) + 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.Member) > 0 { - i -= len(m.Member) - copy(dAtA[i:], m.Member) - i = encodeVarintTx(dAtA, i, uint64(len(m.Member))) + 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 *MsgUpdateGroupExtra) Marshal() (dAtA []byte, err error) { +func (m *MsgDeleteBucketResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5918,63 +5640,12 @@ func (m *MsgUpdateGroupExtra) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateGroupExtra) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDeleteBucketResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateGroupExtra) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Extra) > 0 { - i -= len(m.Extra) - copy(dAtA[i:], m.Extra) - i = encodeVarintTx(dAtA, i, uint64(len(m.Extra))) - i-- - dAtA[i] = 0x22 - } - if len(m.GroupName) > 0 { - i -= len(m.GroupName) - copy(dAtA[i:], m.GroupName) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) - i-- - dAtA[i] = 0x1a - } - if len(m.GroupOwner) > 0 { - i -= len(m.GroupOwner) - copy(dAtA[i:], m.GroupOwner) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupOwner))) - 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 *MsgUpdateGroupExtraResponse) 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 *MsgUpdateGroupExtraResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgUpdateGroupExtraResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDeleteBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -5982,7 +5653,7 @@ func (m *MsgUpdateGroupExtraResponse) MarshalToSizedBuffer(dAtA []byte) (int, er return len(dAtA) - i, nil } -func (m *MsgLeaveGroup) Marshal() (dAtA []byte, err error) { +func (m *MsgDiscontinueBucket) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -5992,41 +5663,41 @@ func (m *MsgLeaveGroup) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgLeaveGroup) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDiscontinueBucket) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgLeaveGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDiscontinueBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.GroupName) > 0 { - i -= len(m.GroupName) - copy(dAtA[i:], m.GroupName) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintTx(dAtA, i, uint64(len(m.Reason))) i-- dAtA[i] = 0x1a } - if len(m.GroupOwner) > 0 { - i -= len(m.GroupOwner) - copy(dAtA[i:], m.GroupOwner) - i = encodeVarintTx(dAtA, i, uint64(len(m.GroupOwner))) + 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.Member) > 0 { - i -= len(m.Member) - copy(dAtA[i:], m.Member) - i = encodeVarintTx(dAtA, i, uint64(len(m.Member))) + 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 *MsgLeaveGroupResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgDiscontinueBucketResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6036,12 +5707,12 @@ func (m *MsgLeaveGroupResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgLeaveGroupResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDiscontinueBucketResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgLeaveGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDiscontinueBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6049,7 +5720,7 @@ func (m *MsgLeaveGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgUpdateBucketInfo) Marshal() (dAtA []byte, err error) { +func (m *MsgCreateObject) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6059,31 +5730,33 @@ func (m *MsgUpdateBucketInfo) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateBucketInfo) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCreateObject) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCreateObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Visibility != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) + if m.RedundancyType != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.RedundancyType)) i-- - dAtA[i] = 0x28 + dAtA[i] = 0x48 } - 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.ExpectChecksums) > 0 { + for iNdEx := len(m.ExpectChecksums) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ExpectChecksums[iNdEx]) + copy(dAtA[i:], m.ExpectChecksums[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExpectChecksums[iNdEx]))) + i-- + dAtA[i] = 0x42 + } } - if m.ChargedReadQuota != nil { + if m.PrimarySpApproval != nil { { - size, err := m.ChargedReadQuota.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.PrimarySpApproval.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -6091,6 +5764,30 @@ func (m *MsgUpdateBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintTx(dAtA, i, uint64(size)) } i-- + dAtA[i] = 0x3a + } + if len(m.ContentType) > 0 { + i -= len(m.ContentType) + copy(dAtA[i:], m.ContentType) + i = encodeVarintTx(dAtA, i, uint64(len(m.ContentType))) + i-- + dAtA[i] = 0x32 + } + if m.Visibility != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) + i-- + dAtA[i] = 0x28 + } + if m.PayloadSize != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.PayloadSize)) + i-- + dAtA[i] = 0x20 + } + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + i-- dAtA[i] = 0x1a } if len(m.BucketName) > 0 { @@ -6100,17 +5797,17 @@ func (m *MsgUpdateBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 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))) + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *MsgUpdateBucketInfoResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgCreateObjectResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6120,20 +5817,30 @@ func (m *MsgUpdateBucketInfoResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateBucketInfoResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCreateObjectResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateBucketInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCreateObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l + { + size := m.ObjectId.Size() + i -= size + if _, err := m.ObjectId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *MsgCancelCreateObject) Marshal() (dAtA []byte, err error) { +func (m *MsgSealObject) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6143,16 +5850,28 @@ func (m *MsgCancelCreateObject) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCancelCreateObject) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgSealObject) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelCreateObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgSealObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l + if len(m.SecondarySpBlsAggSignatures) > 0 { + i -= len(m.SecondarySpBlsAggSignatures) + copy(dAtA[i:], m.SecondarySpBlsAggSignatures) + i = encodeVarintTx(dAtA, i, uint64(len(m.SecondarySpBlsAggSignatures))) + i-- + dAtA[i] = 0x2a + } + if m.GlobalVirtualGroupId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.GlobalVirtualGroupId)) + i-- + dAtA[i] = 0x20 + } if len(m.ObjectName) > 0 { i -= len(m.ObjectName) copy(dAtA[i:], m.ObjectName) @@ -6177,7 +5896,7 @@ func (m *MsgCancelCreateObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgCancelCreateObjectResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgSealObjectResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6187,12 +5906,12 @@ func (m *MsgCancelCreateObjectResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCancelCreateObjectResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgSealObjectResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelCreateObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgSealObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6200,7 +5919,7 @@ func (m *MsgCancelCreateObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } -func (m *MsgPutPolicy) Marshal() (dAtA []byte, err error) { +func (m *MsgSealObjectV2) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6210,56 +5929,48 @@ func (m *MsgPutPolicy) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgPutPolicy) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgSealObjectV2) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgPutPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgSealObjectV2) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.ExpirationTime != nil { - n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime):]) - if err6 != nil { - return 0, err6 + if len(m.ExpectChecksums) > 0 { + for iNdEx := len(m.ExpectChecksums) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ExpectChecksums[iNdEx]) + copy(dAtA[i:], m.ExpectChecksums[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExpectChecksums[iNdEx]))) + i-- + dAtA[i] = 0x32 } - i -= n6 - i = encodeVarintTx(dAtA, i, uint64(n6)) + } + if len(m.SecondarySpBlsAggSignatures) > 0 { + i -= len(m.SecondarySpBlsAggSignatures) + copy(dAtA[i:], m.SecondarySpBlsAggSignatures) + i = encodeVarintTx(dAtA, i, uint64(len(m.SecondarySpBlsAggSignatures))) i-- - dAtA[i] = 0x3a + dAtA[i] = 0x2a } - if len(m.Statements) > 0 { - for iNdEx := len(m.Statements) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Statements[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - } + if m.GlobalVirtualGroupId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.GlobalVirtualGroupId)) + i-- + dAtA[i] = 0x20 } - if len(m.Resource) > 0 { - i -= len(m.Resource) - copy(dAtA[i:], m.Resource) - i = encodeVarintTx(dAtA, i, uint64(len(m.Resource))) + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) i-- dAtA[i] = 0x1a } - if m.Principal != nil { - { - size, err := m.Principal.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } + 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 } @@ -6273,7 +5984,7 @@ func (m *MsgPutPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgPutPolicyResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgSealObjectV2Response) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6283,30 +5994,20 @@ func (m *MsgPutPolicyResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgPutPolicyResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgSealObjectV2Response) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgPutPolicyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgSealObjectV2Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - { - size := m.PolicyId.Size() - i -= size - if _, err := m.PolicyId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 return len(dAtA) - i, nil } -func (m *MsgDeletePolicy) Marshal() (dAtA []byte, err error) { +func (m *MsgRejectSealObject) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6316,32 +6017,27 @@ func (m *MsgDeletePolicy) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgDeletePolicy) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgRejectSealObject) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgDeletePolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgRejectSealObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.Resource) > 0 { - i -= len(m.Resource) - copy(dAtA[i:], m.Resource) - i = encodeVarintTx(dAtA, i, uint64(len(m.Resource))) + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) i-- dAtA[i] = 0x1a } - if m.Principal != nil { - { - size, err := m.Principal.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } + 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 } @@ -6355,7 +6051,7 @@ func (m *MsgDeletePolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgDeletePolicyResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgRejectSealObjectResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6365,30 +6061,20 @@ func (m *MsgDeletePolicyResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgDeletePolicyResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgRejectSealObjectResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgDeletePolicyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgRejectSealObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - { - size := m.PolicyId.Size() - i -= size - if _, err := m.PolicyId.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 return len(dAtA) - i, nil } -func (m *MsgMirrorObject) Marshal() (dAtA []byte, err error) { +func (m *MsgCopyObject) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6398,45 +6084,56 @@ func (m *MsgMirrorObject) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgMirrorObject) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCopyObject) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMirrorObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCopyObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DestChainId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.DestChainId)) + if m.DstPrimarySpApproval != nil { + { + size, err := m.DstPrimarySpApproval.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } i-- - dAtA[i] = 0x28 + dAtA[i] = 0x32 } - if len(m.ObjectName) > 0 { - i -= len(m.ObjectName) - copy(dAtA[i:], m.ObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + if len(m.DstObjectName) > 0 { + i -= len(m.DstObjectName) + copy(dAtA[i:], m.DstObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.DstObjectName))) + i-- + dAtA[i] = 0x2a + } + if len(m.SrcObjectName) > 0 { + i -= len(m.SrcObjectName) + copy(dAtA[i:], m.SrcObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.SrcObjectName))) i-- dAtA[i] = 0x22 } - if len(m.BucketName) > 0 { - i -= len(m.BucketName) - copy(dAtA[i:], m.BucketName) - i = encodeVarintTx(dAtA, i, uint64(len(m.BucketName))) + if len(m.DstBucketName) > 0 { + i -= len(m.DstBucketName) + copy(dAtA[i:], m.DstBucketName) + i = encodeVarintTx(dAtA, i, uint64(len(m.DstBucketName))) i-- dAtA[i] = 0x1a } - { - size := m.Id.Size() - i -= size - if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) + if len(m.SrcBucketName) > 0 { + i -= len(m.SrcBucketName) + copy(dAtA[i:], m.SrcBucketName) + i = encodeVarintTx(dAtA, i, uint64(len(m.SrcBucketName))) + i-- + dAtA[i] = 0x12 } - i-- - dAtA[i] = 0x12 if len(m.Operator) > 0 { i -= len(m.Operator) copy(dAtA[i:], m.Operator) @@ -6447,7 +6144,7 @@ func (m *MsgMirrorObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgMirrorObjectResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgCopyObjectResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6457,20 +6154,30 @@ func (m *MsgMirrorObjectResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgMirrorObjectResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCopyObjectResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMirrorObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCopyObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l + { + size := m.ObjectId.Size() + i -= size + if _, err := m.ObjectId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *MsgMirrorBucket) Marshal() (dAtA []byte, err error) { +func (m *MsgDeleteObject) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6480,38 +6187,30 @@ func (m *MsgMirrorBucket) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgMirrorBucket) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDeleteObject) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMirrorBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDeleteObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DestChainId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.DestChainId)) + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) i-- - dAtA[i] = 0x20 + 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] = 0x1a - } - { - size := m.Id.Size() - i -= size - if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) + dAtA[i] = 0x12 } - i-- - dAtA[i] = 0x12 if len(m.Operator) > 0 { i -= len(m.Operator) copy(dAtA[i:], m.Operator) @@ -6522,7 +6221,7 @@ func (m *MsgMirrorBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgUpdateObjectInfoResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgDeleteObjectResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6532,12 +6231,12 @@ func (m *MsgUpdateObjectInfoResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateObjectInfoResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDeleteObjectResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateObjectInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDeleteObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6545,7 +6244,7 @@ func (m *MsgUpdateObjectInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, er return len(dAtA) - i, nil } -func (m *MsgUpdateObjectInfo) Marshal() (dAtA []byte, err error) { +func (m *MsgDiscontinueObject) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6555,27 +6254,36 @@ func (m *MsgUpdateObjectInfo) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateObjectInfo) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDiscontinueObject) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDiscontinueObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Visibility != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) + if len(m.Reason) > 0 { + i -= len(m.Reason) + copy(dAtA[i:], m.Reason) + i = encodeVarintTx(dAtA, i, uint64(len(m.Reason))) i-- - dAtA[i] = 0x20 + dAtA[i] = 0x22 } - if len(m.ObjectName) > 0 { - i -= len(m.ObjectName) - copy(dAtA[i:], m.ObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) - i-- - dAtA[i] = 0x1a + if len(m.ObjectIds) > 0 { + for iNdEx := len(m.ObjectIds) - 1; iNdEx >= 0; iNdEx-- { + { + size := m.ObjectIds[iNdEx].Size() + i -= size + if _, err := m.ObjectIds[iNdEx].MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } } if len(m.BucketName) > 0 { i -= len(m.BucketName) @@ -6594,7 +6302,7 @@ func (m *MsgUpdateObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgMirrorBucketResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgDiscontinueObjectResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6604,12 +6312,12 @@ func (m *MsgMirrorBucketResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgMirrorBucketResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDiscontinueObjectResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMirrorBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDiscontinueObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6617,7 +6325,7 @@ func (m *MsgMirrorBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *MsgMirrorGroup) Marshal() (dAtA []byte, err error) { +func (m *MsgCreateGroup) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6627,49 +6335,41 @@ func (m *MsgMirrorGroup) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgMirrorGroup) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCreateGroup) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMirrorGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCreateGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DestChainId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.DestChainId)) + if len(m.Extra) > 0 { + i -= len(m.Extra) + copy(dAtA[i:], m.Extra) + i = encodeVarintTx(dAtA, i, uint64(len(m.Extra))) i-- - dAtA[i] = 0x20 + dAtA[i] = 0x1a } if len(m.GroupName) > 0 { i -= len(m.GroupName) copy(dAtA[i:], m.GroupName) i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) i-- - dAtA[i] = 0x1a - } - { - size := m.Id.Size() - i -= size - if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) + dAtA[i] = 0x12 } - 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))) + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *MsgMirrorGroupResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgCreateGroupResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6679,20 +6379,30 @@ func (m *MsgMirrorGroupResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgMirrorGroupResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCreateGroupResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMirrorGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCreateGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l + { + size := m.GroupId.Size() + i -= size + if _, err := m.GroupId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } -func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { +func (m *MsgDeleteGroup) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6702,37 +6412,34 @@ func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDeleteGroup) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDeleteGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - { - size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) + if len(m.GroupName) > 0 { + i -= len(m.GroupName) + copy(dAtA[i:], m.GroupName) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) + i-- + dAtA[i] = 0x12 } - i-- - dAtA[i] = 0x12 - if len(m.Authority) > 0 { - i -= len(m.Authority) - copy(dAtA[i:], m.Authority) - i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + 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 *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgDeleteGroupResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6742,12 +6449,12 @@ func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgDeleteGroupResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgDeleteGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6755,7 +6462,7 @@ func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *MsgMigrateBucket) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateGroupMember) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6765,37 +6472,50 @@ func (m *MsgMigrateBucket) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgMigrateBucket) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateGroupMember) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateGroupMember) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.DstPrimarySpApproval != nil { - { - size, err := m.DstPrimarySpApproval.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.MembersToDelete) > 0 { + for iNdEx := len(m.MembersToDelete) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.MembersToDelete[iNdEx]) + copy(dAtA[i:], m.MembersToDelete[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.MembersToDelete[iNdEx]))) + i-- + dAtA[i] = 0x2a + } + } + if len(m.MembersToAdd) > 0 { + for iNdEx := len(m.MembersToAdd) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.MembersToAdd[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 } - i-- - dAtA[i] = 0x22 } - if m.DstPrimarySpId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.DstPrimarySpId)) + if len(m.GroupName) > 0 { + i -= len(m.GroupName) + copy(dAtA[i:], m.GroupName) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) i-- - dAtA[i] = 0x18 + 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))) + if len(m.GroupOwner) > 0 { + i -= len(m.GroupOwner) + copy(dAtA[i:], m.GroupOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupOwner))) i-- dAtA[i] = 0x12 } @@ -6809,7 +6529,7 @@ func (m *MsgMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgMigrateBucketResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateGroupMemberResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6819,12 +6539,12 @@ func (m *MsgMigrateBucketResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgMigrateBucketResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateGroupMemberResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateGroupMemberResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6832,7 +6552,7 @@ func (m *MsgMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } -func (m *MsgCompleteMigrateBucket) Marshal() (dAtA []byte, err error) { +func (m *MsgRenewGroupMember) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6842,20 +6562,20 @@ func (m *MsgCompleteMigrateBucket) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCompleteMigrateBucket) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgRenewGroupMember) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCompleteMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgRenewGroupMember) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.GvgMappings) > 0 { - for iNdEx := len(m.GvgMappings) - 1; iNdEx >= 0; iNdEx-- { + if len(m.Members) > 0 { + for iNdEx := len(m.Members) - 1; iNdEx >= 0; iNdEx-- { { - size, err := m.GvgMappings[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + size, err := m.Members[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -6866,15 +6586,17 @@ func (m *MsgCompleteMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error dAtA[i] = 0x22 } } - if m.GlobalVirtualGroupFamilyId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.GlobalVirtualGroupFamilyId)) + if len(m.GroupName) > 0 { + i -= len(m.GroupName) + copy(dAtA[i:], m.GroupName) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) i-- - dAtA[i] = 0x18 + 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))) + if len(m.GroupOwner) > 0 { + i -= len(m.GroupOwner) + copy(dAtA[i:], m.GroupOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupOwner))) i-- dAtA[i] = 0x12 } @@ -6888,7 +6610,7 @@ func (m *MsgCompleteMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error return len(dAtA) - i, nil } -func (m *MsgCompleteMigrateBucketResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgRenewGroupMemberResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6898,12 +6620,12 @@ func (m *MsgCompleteMigrateBucketResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCompleteMigrateBucketResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgRenewGroupMemberResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCompleteMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgRenewGroupMemberResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6911,7 +6633,7 @@ func (m *MsgCompleteMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (in return len(dAtA) - i, nil } -func (m *MsgCancelMigrateBucket) Marshal() (dAtA []byte, err error) { +func (m *MsgGroupMember) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6921,20 +6643,74 @@ func (m *MsgCancelMigrateBucket) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCancelMigrateBucket) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgGroupMember) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgGroupMember) 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 = encodeVarintTx(dAtA, i, uint64(len(m.BucketName))) + if m.ExpirationTime != nil { + n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime):]) + if err4 != nil { + return 0, err4 + } + i -= n4 + i = encodeVarintTx(dAtA, i, uint64(n4)) + i-- + dAtA[i] = 0x12 + } + if len(m.Member) > 0 { + i -= len(m.Member) + copy(dAtA[i:], m.Member) + i = encodeVarintTx(dAtA, i, uint64(len(m.Member))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateGroupExtra) 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 *MsgUpdateGroupExtra) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateGroupExtra) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Extra) > 0 { + i -= len(m.Extra) + copy(dAtA[i:], m.Extra) + i = encodeVarintTx(dAtA, i, uint64(len(m.Extra))) + i-- + dAtA[i] = 0x22 + } + if len(m.GroupName) > 0 { + i -= len(m.GroupName) + copy(dAtA[i:], m.GroupName) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) + i-- + dAtA[i] = 0x1a + } + if len(m.GroupOwner) > 0 { + i -= len(m.GroupOwner) + copy(dAtA[i:], m.GroupOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupOwner))) i-- dAtA[i] = 0x12 } @@ -6948,7 +6724,7 @@ func (m *MsgCancelMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *MsgCancelMigrateBucketResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateGroupExtraResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6958,12 +6734,12 @@ func (m *MsgCancelMigrateBucketResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCancelMigrateBucketResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateGroupExtraResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateGroupExtraResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -6971,7 +6747,7 @@ func (m *MsgCancelMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } -func (m *MsgRejectMigrateBucket) Marshal() (dAtA []byte, err error) { +func (m *MsgLeaveGroup) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -6981,34 +6757,41 @@ func (m *MsgRejectMigrateBucket) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgRejectMigrateBucket) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgLeaveGroup) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgRejectMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgLeaveGroup) 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 = encodeVarintTx(dAtA, i, uint64(len(m.BucketName))) + if len(m.GroupName) > 0 { + i -= len(m.GroupName) + copy(dAtA[i:], m.GroupName) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) + i-- + dAtA[i] = 0x1a + } + if len(m.GroupOwner) > 0 { + i -= len(m.GroupOwner) + copy(dAtA[i:], m.GroupOwner) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupOwner))) 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))) + if len(m.Member) > 0 { + i -= len(m.Member) + copy(dAtA[i:], m.Member) + i = encodeVarintTx(dAtA, i, uint64(len(m.Member))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *MsgRejectMigrateBucketResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgLeaveGroupResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7018,12 +6801,12 @@ func (m *MsgRejectMigrateBucketResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgRejectMigrateBucketResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgLeaveGroupResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgRejectMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgLeaveGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -7031,7 +6814,7 @@ func (m *MsgRejectMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } -func (m *MsgSetTag) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateBucketInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7041,19 +6824,31 @@ func (m *MsgSetTag) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgSetTag) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateBucketInfo) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgSetTag) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateBucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.Tags != nil { + if m.Visibility != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) + i-- + dAtA[i] = 0x28 + } + 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 m.ChargedReadQuota != nil { { - size, err := m.Tags.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.ChargedReadQuota.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -7063,10 +6858,10 @@ func (m *MsgSetTag) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x1a } - if len(m.Resource) > 0 { - i -= len(m.Resource) - copy(dAtA[i:], m.Resource) - i = encodeVarintTx(dAtA, i, uint64(len(m.Resource))) + 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 } @@ -7080,7 +6875,7 @@ func (m *MsgSetTag) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgSetTagResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgUpdateBucketInfoResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7090,12 +6885,12 @@ func (m *MsgSetTagResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgSetTagResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgUpdateBucketInfoResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgSetTagResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgUpdateBucketInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -7103,7 +6898,7 @@ func (m *MsgSetTagResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MsgUpdateObjectContent) Marshal() (dAtA []byte, err error) { +func (m *MsgCancelCreateObject) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7113,37 +6908,16 @@ func (m *MsgUpdateObjectContent) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateObjectContent) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCancelCreateObject) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCancelCreateObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.ExpectChecksums) > 0 { - for iNdEx := len(m.ExpectChecksums) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.ExpectChecksums[iNdEx]) - copy(dAtA[i:], m.ExpectChecksums[iNdEx]) - i = encodeVarintTx(dAtA, i, uint64(len(m.ExpectChecksums[iNdEx]))) - i-- - dAtA[i] = 0x32 - } - } - if len(m.ContentType) > 0 { - i -= len(m.ContentType) - copy(dAtA[i:], m.ContentType) - i = encodeVarintTx(dAtA, i, uint64(len(m.ContentType))) - i-- - dAtA[i] = 0x2a - } - if m.PayloadSize != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.PayloadSize)) - i-- - dAtA[i] = 0x20 - } if len(m.ObjectName) > 0 { i -= len(m.ObjectName) copy(dAtA[i:], m.ObjectName) @@ -7168,7 +6942,7 @@ func (m *MsgUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *MsgUpdateObjectContentResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgCancelCreateObjectResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7178,12 +6952,12 @@ func (m *MsgUpdateObjectContentResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgUpdateObjectContentResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgCancelCreateObjectResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateObjectContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgCancelCreateObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -7191,7 +6965,7 @@ func (m *MsgUpdateObjectContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } -func (m *MsgCancelUpdateObjectContent) Marshal() (dAtA []byte, err error) { +func (m *MsgPutPolicy) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7201,27 +6975,56 @@ func (m *MsgCancelUpdateObjectContent) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MsgCancelUpdateObjectContent) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgPutPolicy) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgPutPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.ObjectName) > 0 { - i -= len(m.ObjectName) - copy(dAtA[i:], m.ObjectName) - i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + if m.ExpirationTime != nil { + n6, err6 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.ExpirationTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime):]) + if err6 != nil { + return 0, err6 + } + i -= n6 + i = encodeVarintTx(dAtA, i, uint64(n6)) + i-- + dAtA[i] = 0x3a + } + if len(m.Statements) > 0 { + for iNdEx := len(m.Statements) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Statements[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if len(m.Resource) > 0 { + i -= len(m.Resource) + copy(dAtA[i:], m.Resource) + i = encodeVarintTx(dAtA, i, uint64(len(m.Resource))) 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))) + if m.Principal != nil { + { + size, err := m.Principal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0x12 } @@ -7235,7 +7038,7 @@ func (m *MsgCancelUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, e return len(dAtA) - i, nil } -func (m *MsgCancelUpdateObjectContentResponse) Marshal() (dAtA []byte, err error) { +func (m *MsgPutPolicyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -7245,1048 +7048,1478 @@ func (m *MsgCancelUpdateObjectContentResponse) Marshal() (dAtA []byte, err error return dAtA[:n], nil } -func (m *MsgCancelUpdateObjectContentResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *MsgPutPolicyResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelUpdateObjectContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *MsgPutPolicyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l + { + size := m.PolicyId.Size() + i -= size + if _, err := m.PolicyId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 return len(dAtA) - i, nil } -func encodeVarintTx(dAtA []byte, offset int, v uint64) int { - offset -= sovTx(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ +func (m *MsgDeletePolicy) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - dAtA[offset] = uint8(v) - return base + return dAtA[:n], nil } -func (m *MsgCreateBucket) Size() (n int) { - if m == nil { - return 0 - } + +func (m *MsgDeletePolicy) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDeletePolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Creator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.BucketName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if m.Visibility != 0 { - n += 1 + sovTx(uint64(m.Visibility)) - } - l = len(m.PaymentAddress) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.PrimarySpAddress) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.Resource) > 0 { + i -= len(m.Resource) + copy(dAtA[i:], m.Resource) + i = encodeVarintTx(dAtA, i, uint64(len(m.Resource))) + i-- + dAtA[i] = 0x1a } - if m.PrimarySpApproval != nil { - l = m.PrimarySpApproval.Size() - n += 1 + l + sovTx(uint64(l)) + if m.Principal != nil { + { + size, err := m.Principal.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 } - if m.ChargedReadQuota != 0 { - n += 1 + sovTx(uint64(m.ChargedReadQuota)) + 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 n + return len(dAtA) - i, nil } -func (m *MsgCreateBucketResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgDeletePolicyResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = m.BucketId.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return dAtA[:n], nil } -func (m *MsgDeleteBucket) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgDeletePolicyResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDeletePolicyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i 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)) + { + size := m.PolicyId.Size() + i -= size + if _, err := m.PolicyId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) } - return n + i-- + dAtA[i] = 0x22 + return len(dAtA) - i, nil } -func (m *MsgDeleteBucketResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgMirrorObject) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgDiscontinueBucket) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgMirrorObject) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMirrorObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i 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)) + if m.DestChainId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.DestChainId)) + i-- + dAtA[i] = 0x28 } - l = len(m.Reason) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + i-- + dAtA[i] = 0x22 } - return n + 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] = 0x1a + } + { + size := m.Id.Size() + i -= size + if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + 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 *MsgDiscontinueBucketResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgMirrorObjectResponse) 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 *MsgMirrorObjectResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMirrorObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgCreateObject) Size() (n int) { - if m == nil { - return 0 +func (m *MsgMirrorBucket) 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 *MsgMirrorBucket) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMirrorBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Creator) - 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.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if m.PayloadSize != 0 { - n += 1 + sovTx(uint64(m.PayloadSize)) - } - if m.Visibility != 0 { - n += 1 + sovTx(uint64(m.Visibility)) - } - l = len(m.ContentType) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.DestChainId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.DestChainId)) + i-- + dAtA[i] = 0x20 } - if m.PrimarySpApproval != nil { - l = m.PrimarySpApproval.Size() - n += 1 + l + sovTx(uint64(l)) + 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] = 0x1a } - if len(m.ExpectChecksums) > 0 { - for _, b := range m.ExpectChecksums { - l = len(b) - n += 1 + l + sovTx(uint64(l)) + { + size := m.Id.Size() + i -= size + if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil { + return 0, err } + i = encodeVarintTx(dAtA, i, uint64(size)) } - if m.RedundancyType != 0 { - n += 1 + sovTx(uint64(m.RedundancyType)) + 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 n + return len(dAtA) - i, nil } -func (m *MsgCreateObjectResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgUpdateObjectInfoResponse) 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 *MsgUpdateObjectInfoResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateObjectInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = m.ObjectId.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return len(dAtA) - i, nil } -func (m *MsgSealObject) Size() (n int) { - if m == nil { - return 0 +func (m *MsgUpdateObjectInfo) 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 *MsgUpdateObjectInfo) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateObjectInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i 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)) + if m.Visibility != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) + i-- + dAtA[i] = 0x20 } - l = len(m.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + i-- + dAtA[i] = 0x1a } - if m.GlobalVirtualGroupId != 0 { - n += 1 + sovTx(uint64(m.GlobalVirtualGroupId)) + 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 } - l = len(m.SecondarySpBlsAggSignatures) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + 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 n + return len(dAtA) - i, nil } -func (m *MsgSealObjectResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgMirrorBucketResponse) 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 *MsgMirrorBucketResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMirrorBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgRejectSealObject) Size() (n int) { - if m == nil { - return 0 +func (m *MsgMirrorGroup) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - 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.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n + return dAtA[:n], nil } -func (m *MsgRejectSealObjectResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgMirrorGroup) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCopyObject) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgMirrorGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.SrcBucketName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.DstBucketName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.DestChainId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.DestChainId)) + i-- + dAtA[i] = 0x20 } - l = len(m.SrcObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.GroupName) > 0 { + i -= len(m.GroupName) + copy(dAtA[i:], m.GroupName) + i = encodeVarintTx(dAtA, i, uint64(len(m.GroupName))) + i-- + dAtA[i] = 0x1a } - l = len(m.DstObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + { + size := m.Id.Size() + i -= size + if _, err := m.Id.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) } - if m.DstPrimarySpApproval != nil { - l = m.DstPrimarySpApproval.Size() - n += 1 + l + sovTx(uint64(l)) + 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 n + return len(dAtA) - i, nil } -func (m *MsgCopyObjectResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgMirrorGroupResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = m.ObjectId.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return dAtA[:n], nil } -func (m *MsgDeleteObject) 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.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n +func (m *MsgMirrorGroupResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgDeleteObjectResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgMirrorGroupResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgDiscontinueObject) Size() (n int) { - if m == nil { - return 0 +func (m *MsgUpdateParams) 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 *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i 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)) - } - if len(m.ObjectIds) > 0 { - for _, e := range m.ObjectIds { - l = e.Size() - n += 1 + l + sovTx(uint64(l)) + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) } - l = len(m.Reason) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + i-- + dAtA[i] = 0x12 + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa } - return n + return len(dAtA) - i, nil } -func (m *MsgDiscontinueObjectResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgCreateGroup) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Creator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.GroupName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.Extra) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n +func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCreateGroupResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = m.GroupId.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return len(dAtA) - i, nil } -func (m *MsgDeleteGroup) 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.GroupName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) +func (m *MsgMigrateBucket) 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 n + return dAtA[:n], nil } -func (m *MsgDeleteGroupResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgMigrateBucket) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateGroupMember) Size() (n int) { - if m == nil { - return 0 - } - var l int +func (m *MsgMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.GroupOwner) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.DstPrimarySpApproval != nil { + { + size, err := m.DstPrimarySpApproval.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 } - l = len(m.GroupName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.DstPrimarySpId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.DstPrimarySpId)) + i-- + dAtA[i] = 0x18 } - if len(m.MembersToAdd) > 0 { - for _, e := range m.MembersToAdd { - l = e.Size() - n += 1 + l + sovTx(uint64(l)) - } + 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.MembersToDelete) > 0 { - for _, s := range m.MembersToDelete { - l = len(s) - n += 1 + l + sovTx(uint64(l)) - } + 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 n + return len(dAtA) - i, nil } -func (m *MsgUpdateGroupMemberResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgMigrateBucketResponse) 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 *MsgMigrateBucketResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgRenewGroupMember) Size() (n int) { - if m == nil { - return 0 +func (m *MsgCompleteMigrateBucket) 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 *MsgCompleteMigrateBucket) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCompleteMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.GvgMappings) > 0 { + for iNdEx := len(m.GvgMappings) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.GvgMappings[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } } - l = len(m.GroupOwner) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.GlobalVirtualGroupFamilyId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.GlobalVirtualGroupFamilyId)) + i-- + dAtA[i] = 0x18 } - l = len(m.GroupName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + 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.Members) > 0 { - for _, e := range m.Members { - l = e.Size() - n += 1 + l + sovTx(uint64(l)) - } + 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 n + return len(dAtA) - i, nil } -func (m *MsgRenewGroupMemberResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgCompleteMigrateBucketResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgGroupMember) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgCompleteMigrateBucketResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCompleteMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Member) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if m.ExpirationTime != nil { - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime) - n += 1 + l + sovTx(uint64(l)) - } - return n + return len(dAtA) - i, nil } -func (m *MsgUpdateGroupExtra) Size() (n int) { - if m == nil { - return 0 +func (m *MsgCancelMigrateBucket) 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 *MsgCancelMigrateBucket) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCancelMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.GroupOwner) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.GroupName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + 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 } - l = len(m.Extra) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + 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 n + return len(dAtA) - i, nil } -func (m *MsgUpdateGroupExtraResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgCancelMigrateBucketResponse) 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 *MsgCancelMigrateBucketResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCancelMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgLeaveGroup) Size() (n int) { - if m == nil { - return 0 +func (m *MsgRejectMigrateBucket) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = len(m.Member) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.GroupOwner) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.GroupName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n + return dAtA[:n], nil } -func (m *MsgLeaveGroupResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgRejectMigrateBucket) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateBucketInfo) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgRejectMigrateBucket) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i 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)) - } - if m.ChargedReadQuota != nil { - l = m.ChargedReadQuota.Size() - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.PaymentAddress) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + 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 m.Visibility != 0 { - n += 1 + sovTx(uint64(m.Visibility)) + 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 n + return len(dAtA) - i, nil } -func (m *MsgUpdateBucketInfoResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgRejectMigrateBucketResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgCancelCreateObject) 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.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n +func (m *MsgRejectMigrateBucketResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCancelCreateObjectResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgRejectMigrateBucketResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgPutPolicy) 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)) - } - if m.Principal != nil { - l = m.Principal.Size() - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.Resource) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if len(m.Statements) > 0 { - for _, e := range m.Statements { - l = e.Size() - n += 1 + l + sovTx(uint64(l)) - } - } - if m.ExpirationTime != nil { - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime) - n += 1 + l + sovTx(uint64(l)) +func (m *MsgSetTag) 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 n + return dAtA[:n], nil } -func (m *MsgPutPolicyResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.PolicyId.Size() - n += 1 + l + sovTx(uint64(l)) - return n +func (m *MsgSetTag) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgDeletePolicy) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgSetTag) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.Tags != nil { + { + size, err := m.Tags.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a } - if m.Principal != nil { - l = m.Principal.Size() - n += 1 + l + sovTx(uint64(l)) + if len(m.Resource) > 0 { + i -= len(m.Resource) + copy(dAtA[i:], m.Resource) + i = encodeVarintTx(dAtA, i, uint64(len(m.Resource))) + i-- + dAtA[i] = 0x12 } - l = len(m.Resource) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + 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 n + return len(dAtA) - i, nil } -func (m *MsgDeletePolicyResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgSetTagResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = m.PolicyId.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return dAtA[:n], nil } -func (m *MsgMirrorObject) 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 = m.Id.Size() - n += 1 + l + sovTx(uint64(l)) - l = len(m.BucketName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = len(m.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if m.DestChainId != 0 { - n += 1 + sovTx(uint64(m.DestChainId)) - } - return n +func (m *MsgSetTagResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMirrorObjectResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgSetTagResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgMirrorBucket) Size() (n int) { - if m == nil { - return 0 +func (m *MsgUpdateObjectContent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = m.Id.Size() - n += 1 + l + sovTx(uint64(l)) - l = len(m.BucketName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if m.DestChainId != 0 { - n += 1 + sovTx(uint64(m.DestChainId)) - } - return n + return dAtA[:n], nil } -func (m *MsgUpdateObjectInfoResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgUpdateObjectContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgUpdateObjectInfo) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ExpectChecksums) > 0 { + for iNdEx := len(m.ExpectChecksums) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ExpectChecksums[iNdEx]) + copy(dAtA[i:], m.ExpectChecksums[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExpectChecksums[iNdEx]))) + i-- + dAtA[i] = 0x32 + } } - l = len(m.BucketName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ContentType) > 0 { + i -= len(m.ContentType) + copy(dAtA[i:], m.ContentType) + i = encodeVarintTx(dAtA, i, uint64(len(m.ContentType))) + i-- + dAtA[i] = 0x2a } - l = len(m.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.PayloadSize != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.PayloadSize)) + i-- + dAtA[i] = 0x20 } - if m.Visibility != 0 { - n += 1 + sovTx(uint64(m.Visibility)) + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + i-- + dAtA[i] = 0x1a } - return n + 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 *MsgMirrorBucketResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgUpdateObjectContentResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgMirrorGroup) 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 = m.Id.Size() - n += 1 + l + sovTx(uint64(l)) - l = len(m.GroupName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if m.DestChainId != 0 { - n += 1 + sovTx(uint64(m.DestChainId)) - } - return n +func (m *MsgUpdateObjectContentResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMirrorGroupResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgUpdateObjectContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgUpdateParams) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Authority) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) +func (m *MsgCancelUpdateObjectContent) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - l = m.Params.Size() - n += 1 + l + sovTx(uint64(l)) - return n + return dAtA[:n], nil } -func (m *MsgUpdateParamsResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgCancelUpdateObjectContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgMigrateBucket) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgCancelUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i 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)) + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + i-- + dAtA[i] = 0x1a } - if m.DstPrimarySpId != 0 { - n += 1 + sovTx(uint64(m.DstPrimarySpId)) + 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 m.DstPrimarySpApproval != nil { - l = m.DstPrimarySpApproval.Size() - n += 1 + l + sovTx(uint64(l)) + 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 n + return len(dAtA) - i, nil } -func (m *MsgMigrateBucketResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgCancelUpdateObjectContentResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - var l int - _ = l - return n + return dAtA[:n], nil } -func (m *MsgCompleteMigrateBucket) 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)) - } - if m.GlobalVirtualGroupFamilyId != 0 { - n += 1 + sovTx(uint64(m.GlobalVirtualGroupFamilyId)) - } - if len(m.GvgMappings) > 0 { - for _, e := range m.GvgMappings { - l = e.Size() - n += 1 + l + sovTx(uint64(l)) - } - } - return n +func (m *MsgCancelUpdateObjectContentResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgCompleteMigrateBucketResponse) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgCancelUpdateObjectContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgCancelMigrateBucket) Size() (n int) { - if m == nil { - return 0 +func (m *MsgDelegateCreateObject) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - 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)) - } - return n + return dAtA[:n], nil } -func (m *MsgCancelMigrateBucketResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n +func (m *MsgDelegateCreateObject) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MsgRejectMigrateBucket) Size() (n int) { - if m == nil { - return 0 - } +func (m *MsgDelegateCreateObject) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if m.RedundancyType != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.RedundancyType)) + i-- + dAtA[i] = 0x48 } - l = len(m.BucketName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ExpectChecksums) > 0 { + for iNdEx := len(m.ExpectChecksums) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ExpectChecksums[iNdEx]) + copy(dAtA[i:], m.ExpectChecksums[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExpectChecksums[iNdEx]))) + i-- + dAtA[i] = 0x42 + } } - return n + if m.Visibility != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Visibility)) + i-- + dAtA[i] = 0x38 + } + if len(m.ContentType) > 0 { + i -= len(m.ContentType) + copy(dAtA[i:], m.ContentType) + i = encodeVarintTx(dAtA, i, uint64(len(m.ContentType))) + i-- + dAtA[i] = 0x32 + } + if m.PayloadSize != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.PayloadSize)) + i-- + dAtA[i] = 0x28 + } + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + i-- + dAtA[i] = 0x22 + } + 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] = 0x1a + } + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + 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 *MsgRejectMigrateBucketResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgDelegateCreateObjectResponse) 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 *MsgDelegateCreateObjectResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDelegateCreateObjectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + { + size := m.ObjectId.Size() + i -= size + if _, err := m.ObjectId.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil } -func (m *MsgSetTag) Size() (n int) { - if m == nil { - return 0 +func (m *MsgDelegateUpdateObjectContent) 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 *MsgDelegateUpdateObjectContent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDelegateUpdateObjectContent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - l = len(m.Operator) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ExpectChecksums) > 0 { + for iNdEx := len(m.ExpectChecksums) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.ExpectChecksums[iNdEx]) + copy(dAtA[i:], m.ExpectChecksums[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.ExpectChecksums[iNdEx]))) + i-- + dAtA[i] = 0x3a + } } - l = len(m.Resource) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + if len(m.ContentType) > 0 { + i -= len(m.ContentType) + copy(dAtA[i:], m.ContentType) + i = encodeVarintTx(dAtA, i, uint64(len(m.ContentType))) + i-- + dAtA[i] = 0x32 } - if m.Tags != nil { - l = m.Tags.Size() - n += 1 + l + sovTx(uint64(l)) + if m.PayloadSize != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.PayloadSize)) + i-- + dAtA[i] = 0x28 } - return n + if len(m.ObjectName) > 0 { + i -= len(m.ObjectName) + copy(dAtA[i:], m.ObjectName) + i = encodeVarintTx(dAtA, i, uint64(len(m.ObjectName))) + i-- + dAtA[i] = 0x22 + } + 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] = 0x1a + } + if len(m.Updater) > 0 { + i -= len(m.Updater) + copy(dAtA[i:], m.Updater) + i = encodeVarintTx(dAtA, i, uint64(len(m.Updater))) + 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 *MsgSetTagResponse) Size() (n int) { - if m == nil { - return 0 +func (m *MsgDelegateUpdateObjectContentResponse) 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 *MsgDelegateUpdateObjectContentResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDelegateUpdateObjectContentResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i var l int _ = l - return n + return len(dAtA) - i, nil } -func (m *MsgUpdateObjectContent) Size() (n int) { - if m == nil { - return 0 +func (m *MsgToggleSPAsDelegatedAgent) 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 *MsgToggleSPAsDelegatedAgent) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgToggleSPAsDelegatedAgent) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i 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)) + 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 } - l = len(m.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) + 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 } - if m.PayloadSize != 0 { - n += 1 + sovTx(uint64(m.PayloadSize)) + return len(dAtA) - i, nil +} + +func (m *MsgToggleSPAsDelegatedAgentResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err } - l = len(m.ContentType) + return dAtA[:n], nil +} + +func (m *MsgToggleSPAsDelegatedAgentResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgToggleSPAsDelegatedAgentResponse) 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 + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgCreateBucket) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.BucketName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Visibility != 0 { + n += 1 + sovTx(uint64(m.Visibility)) + } + l = len(m.PaymentAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.PrimarySpAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.PrimarySpApproval != nil { + l = m.PrimarySpApproval.Size() + n += 1 + l + sovTx(uint64(l)) + } + if m.ChargedReadQuota != 0 { + n += 1 + sovTx(uint64(m.ChargedReadQuota)) + } + return n +} + +func (m *MsgCreateBucketResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.BucketId.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgDeleteBucket) 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)) + } + return n +} + +func (m *MsgDeleteBucketResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgDiscontinueBucket) 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.Reason) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgDiscontinueBucketResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCreateObject) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.PayloadSize != 0 { + n += 1 + sovTx(uint64(m.PayloadSize)) + } + if m.Visibility != 0 { + n += 1 + sovTx(uint64(m.Visibility)) + } + l = len(m.ContentType) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.PrimarySpApproval != nil { + l = m.PrimarySpApproval.Size() + n += 1 + l + sovTx(uint64(l)) + } + if len(m.ExpectChecksums) > 0 { + for _, b := range m.ExpectChecksums { + l = len(b) + n += 1 + l + sovTx(uint64(l)) + } + } + if m.RedundancyType != 0 { + n += 1 + sovTx(uint64(m.RedundancyType)) + } + return n +} + +func (m *MsgCreateObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectId.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgSealObject) 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.GlobalVirtualGroupId != 0 { + n += 1 + sovTx(uint64(m.GlobalVirtualGroupId)) + } + l = len(m.SecondarySpBlsAggSignatures) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgSealObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgSealObjectV2) 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.GlobalVirtualGroupId != 0 { + n += 1 + sovTx(uint64(m.GlobalVirtualGroupId)) + } + l = len(m.SecondarySpBlsAggSignatures) if l > 0 { n += 1 + l + sovTx(uint64(l)) } @@ -8296,55 +8529,2027 @@ func (m *MsgUpdateObjectContent) Size() (n int) { n += 1 + l + sovTx(uint64(l)) } } - return n -} - -func (m *MsgUpdateObjectContentResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *MsgCancelUpdateObjectContent) 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.ObjectName) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n -} + return n +} + +func (m *MsgSealObjectV2Response) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgRejectSealObject) 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgRejectSealObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCopyObject) 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.SrcBucketName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.DstBucketName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.SrcObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.DstObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.DstPrimarySpApproval != nil { + l = m.DstPrimarySpApproval.Size() + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgCopyObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectId.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgDeleteObject) 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgDeleteObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgDiscontinueObject) 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)) + } + if len(m.ObjectIds) > 0 { + for _, e := range m.ObjectIds { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + l = len(m.Reason) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgDiscontinueObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCreateGroup) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GroupName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Extra) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgCreateGroupResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.GroupId.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgDeleteGroup) 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.GroupName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgDeleteGroupResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateGroupMember) 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.GroupOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GroupName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.MembersToAdd) > 0 { + for _, e := range m.MembersToAdd { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + if len(m.MembersToDelete) > 0 { + for _, s := range m.MembersToDelete { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgUpdateGroupMemberResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgRenewGroupMember) 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.GroupOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GroupName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Members) > 0 { + for _, e := range m.Members { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgRenewGroupMemberResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgGroupMember) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Member) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.ExpirationTime != nil { + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime) + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgUpdateGroupExtra) 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.GroupOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GroupName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Extra) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgUpdateGroupExtraResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgLeaveGroup) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Member) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GroupOwner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.GroupName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgLeaveGroupResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateBucketInfo) 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)) + } + if m.ChargedReadQuota != nil { + l = m.ChargedReadQuota.Size() + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.PaymentAddress) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Visibility != 0 { + n += 1 + sovTx(uint64(m.Visibility)) + } + return n +} + +func (m *MsgUpdateBucketInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCancelCreateObject) 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgCancelCreateObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgPutPolicy) 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)) + } + if m.Principal != nil { + l = m.Principal.Size() + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Resource) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Statements) > 0 { + for _, e := range m.Statements { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + if m.ExpirationTime != nil { + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.ExpirationTime) + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgPutPolicyResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.PolicyId.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgDeletePolicy) 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)) + } + if m.Principal != nil { + l = m.Principal.Size() + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Resource) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgDeletePolicyResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.PolicyId.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgMirrorObject) 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 = m.Id.Size() + n += 1 + l + sovTx(uint64(l)) + l = len(m.BucketName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.DestChainId != 0 { + n += 1 + sovTx(uint64(m.DestChainId)) + } + return n +} + +func (m *MsgMirrorObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgMirrorBucket) 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 = m.Id.Size() + n += 1 + l + sovTx(uint64(l)) + l = len(m.BucketName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.DestChainId != 0 { + n += 1 + sovTx(uint64(m.DestChainId)) + } + return n +} + +func (m *MsgUpdateObjectInfoResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateObjectInfo) 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Visibility != 0 { + n += 1 + sovTx(uint64(m.Visibility)) + } + return n +} + +func (m *MsgMirrorBucketResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgMirrorGroup) 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 = m.Id.Size() + n += 1 + l + sovTx(uint64(l)) + l = len(m.GroupName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.DestChainId != 0 { + n += 1 + sovTx(uint64(m.DestChainId)) + } + return n +} + +func (m *MsgMirrorGroupResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Params.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgUpdateParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgMigrateBucket) 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)) + } + if m.DstPrimarySpId != 0 { + n += 1 + sovTx(uint64(m.DstPrimarySpId)) + } + if m.DstPrimarySpApproval != nil { + l = m.DstPrimarySpApproval.Size() + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgMigrateBucketResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCompleteMigrateBucket) 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)) + } + if m.GlobalVirtualGroupFamilyId != 0 { + n += 1 + sovTx(uint64(m.GlobalVirtualGroupFamilyId)) + } + if len(m.GvgMappings) > 0 { + for _, e := range m.GvgMappings { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgCompleteMigrateBucketResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCancelMigrateBucket) 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)) + } + return n +} + +func (m *MsgCancelMigrateBucketResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgRejectMigrateBucket) 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)) + } + return n +} + +func (m *MsgRejectMigrateBucketResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgSetTag) 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.Resource) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Tags != nil { + l = m.Tags.Size() + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgSetTagResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgUpdateObjectContent) 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.PayloadSize != 0 { + n += 1 + sovTx(uint64(m.PayloadSize)) + } + l = len(m.ContentType) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.ExpectChecksums) > 0 { + for _, b := range m.ExpectChecksums { + l = len(b) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgUpdateObjectContentResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCancelUpdateObjectContent) 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgCancelUpdateObjectContentResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgDelegateCreateObject) 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.Creator) + 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.PayloadSize != 0 { + n += 1 + sovTx(uint64(m.PayloadSize)) + } + l = len(m.ContentType) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Visibility != 0 { + n += 1 + sovTx(uint64(m.Visibility)) + } + if len(m.ExpectChecksums) > 0 { + for _, b := range m.ExpectChecksums { + l = len(b) + n += 1 + l + sovTx(uint64(l)) + } + } + if m.RedundancyType != 0 { + n += 1 + sovTx(uint64(m.RedundancyType)) + } + return n +} + +func (m *MsgDelegateCreateObjectResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ObjectId.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgDelegateUpdateObjectContent) 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.Updater) + 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.ObjectName) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.PayloadSize != 0 { + n += 1 + sovTx(uint64(m.PayloadSize)) + } + l = len(m.ContentType) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.ExpectChecksums) > 0 { + for _, b := range m.ExpectChecksums { + l = len(b) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgDelegateUpdateObjectContentResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgToggleSPAsDelegatedAgent) 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)) + } + return n +} + +func (m *MsgToggleSPAsDelegatedAgentResponse) 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 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgCreateBucket) 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: MsgCreateBucket: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateBucket: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = 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 != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) + } + m.Visibility = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Visibility |= VisibilityType(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 PrimarySpAddress", 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.PrimarySpAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrimarySpApproval", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PrimarySpApproval == nil { + m.PrimarySpApproval = &common.Approval{} + } + if err := m.PrimarySpApproval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ChargedReadQuota", wireType) + } + m.ChargedReadQuota = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ChargedReadQuota |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 *MsgCreateBucketResponse) 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: MsgCreateBucketResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketId", 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.BucketId.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 *MsgDeleteBucket) 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: MsgDeleteBucket: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDeleteBucket: 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 + 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 *MsgDeleteBucketResponse) 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: MsgDeleteBucketResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDeleteBucketResponse: 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 (m *MsgDiscontinueBucket) 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: MsgDiscontinueBucket: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDiscontinueBucket: 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 Reason", 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.Reason = string(dAtA[iNdEx:postIndex]) + 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 *MsgDiscontinueBucketResponse) 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: MsgDiscontinueBucketResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDiscontinueBucketResponse: 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 (m *MsgCreateObject) 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: MsgCreateObject: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateObject: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = 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 ObjectName", 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.ObjectName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PayloadSize", wireType) + } + m.PayloadSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PayloadSize |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) + } + m.Visibility = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Visibility |= VisibilityType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContentType", 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.ContentType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PrimarySpApproval", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.PrimarySpApproval == nil { + m.PrimarySpApproval = &common.Approval{} + } + if err := m.PrimarySpApproval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpectChecksums", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExpectChecksums = append(m.ExpectChecksums, make([]byte, postIndex-iNdEx)) + copy(m.ExpectChecksums[len(m.ExpectChecksums)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RedundancyType", wireType) + } + m.RedundancyType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RedundancyType |= RedundancyType(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 + } + } -func (m *MsgCancelUpdateObjectContentResponse) Size() (n int) { - if m == nil { - return 0 + if iNdEx > l { + return io.ErrUnexpectedEOF } - var l int - _ = l - return n -} - -func sovTx(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozTx(x uint64) (n int) { - return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) + return nil } -func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { +func (m *MsgCreateObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -8367,15 +10572,15 @@ func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCreateBucket: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCreateObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCreateBucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCreateObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -8403,11 +10608,63 @@ func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Creator = string(dAtA[iNdEx:postIndex]) + if err := m.ObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex - case 2: + 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 *MsgSealObject) 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: MsgSealObject: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgSealObject: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -8435,30 +10692,11 @@ func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BucketName = string(dAtA[iNdEx:postIndex]) + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) - } - m.Visibility = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Visibility |= VisibilityType(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PaymentAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -8486,11 +10724,11 @@ func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PaymentAddress = string(dAtA[iNdEx:postIndex]) + m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrimarySpAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -8518,13 +10756,13 @@ func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PrimarySpAddress = string(dAtA[iNdEx:postIndex]) + m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrimarySpApproval", wireType) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupId", wireType) } - var msglen int + m.GlobalVirtualGroupId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -8534,33 +10772,16 @@ func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.GlobalVirtualGroupId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.PrimarySpApproval == nil { - m.PrimarySpApproval = &common.Approval{} - } - if err := m.PrimarySpApproval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ChargedReadQuota", wireType) + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SecondarySpBlsAggSignatures", wireType) } - m.ChargedReadQuota = 0 + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -8570,11 +10791,26 @@ func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ChargedReadQuota |= uint64(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SecondarySpBlsAggSignatures = append(m.SecondarySpBlsAggSignatures[:0], dAtA[iNdEx:postIndex]...) + if m.SecondarySpBlsAggSignatures == nil { + m.SecondarySpBlsAggSignatures = []byte{} + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -8596,7 +10832,7 @@ func (m *MsgCreateBucket) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCreateBucketResponse) Unmarshal(dAtA []byte) error { +func (m *MsgSealObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -8619,46 +10855,12 @@ func (m *MsgCreateBucketResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCreateBucketResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSealObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCreateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BucketId", 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.BucketId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex + return fmt.Errorf("proto: MsgSealObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -8680,7 +10882,7 @@ func (m *MsgCreateBucketResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDeleteBucket) Unmarshal(dAtA []byte) error { +func (m *MsgSealObjectV2) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -8703,10 +10905,10 @@ func (m *MsgDeleteBucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDeleteBucket: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSealObjectV2: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDeleteBucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSealObjectV2: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -8773,6 +10975,123 @@ func (m *MsgDeleteBucket) Unmarshal(dAtA []byte) error { } m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", 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.ObjectName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupId", wireType) + } + m.GlobalVirtualGroupId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GlobalVirtualGroupId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SecondarySpBlsAggSignatures", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SecondarySpBlsAggSignatures = append(m.SecondarySpBlsAggSignatures[:0], dAtA[iNdEx:postIndex]...) + if m.SecondarySpBlsAggSignatures == nil { + m.SecondarySpBlsAggSignatures = []byte{} + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpectChecksums", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExpectChecksums = append(m.ExpectChecksums, make([]byte, postIndex-iNdEx)) + copy(m.ExpectChecksums[len(m.ExpectChecksums)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -8794,7 +11113,7 @@ func (m *MsgDeleteBucket) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDeleteBucketResponse) Unmarshal(dAtA []byte) error { +func (m *MsgSealObjectV2Response) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -8817,10 +11136,10 @@ func (m *MsgDeleteBucketResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDeleteBucketResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSealObjectV2Response: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDeleteBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSealObjectV2Response: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -8844,7 +11163,7 @@ func (m *MsgDeleteBucketResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDiscontinueBucket) Unmarshal(dAtA []byte) error { +func (m *MsgRejectSealObject) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -8867,10 +11186,10 @@ func (m *MsgDiscontinueBucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDiscontinueBucket: wiretype end group for non-group") + return fmt.Errorf("proto: MsgRejectSealObject: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDiscontinueBucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgRejectSealObject: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -8939,7 +11258,7 @@ func (m *MsgDiscontinueBucket) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -8967,7 +11286,7 @@ func (m *MsgDiscontinueBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Reason = string(dAtA[iNdEx:postIndex]) + m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -8990,7 +11309,7 @@ func (m *MsgDiscontinueBucket) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDiscontinueBucketResponse) Unmarshal(dAtA []byte) error { +func (m *MsgRejectSealObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9013,10 +11332,10 @@ func (m *MsgDiscontinueBucketResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDiscontinueBucketResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgRejectSealObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDiscontinueBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgRejectSealObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -9040,7 +11359,7 @@ func (m *MsgDiscontinueBucketResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { +func (m *MsgCopyObject) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9063,15 +11382,15 @@ func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCreateObject: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCopyObject: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCreateObject: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCopyObject: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -9099,11 +11418,11 @@ func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Creator = string(dAtA[iNdEx:postIndex]) + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SrcBucketName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -9131,11 +11450,11 @@ func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BucketName = string(dAtA[iNdEx:postIndex]) + m.SrcBucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DstBucketName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -9163,49 +11482,11 @@ func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ObjectName = string(dAtA[iNdEx:postIndex]) + m.DstBucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PayloadSize", wireType) - } - m.PayloadSize = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.PayloadSize |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) - } - m.Visibility = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Visibility |= VisibilityType(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SrcObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -9233,13 +11514,13 @@ func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ContentType = string(dAtA[iNdEx:postIndex]) + m.SrcObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 7: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PrimarySpApproval", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DstObjectName", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -9249,33 +11530,29 @@ func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if m.PrimarySpApproval == nil { - m.PrimarySpApproval = &common.Approval{} - } - if err := m.PrimarySpApproval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.DstObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 8: + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExpectChecksums", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field DstPrimarySpApproval", wireType) } - var byteLen int + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -9285,43 +11562,28 @@ func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { + if msglen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + byteLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.ExpectChecksums = append(m.ExpectChecksums, make([]byte, postIndex-iNdEx)) - copy(m.ExpectChecksums[len(m.ExpectChecksums)-1], dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field RedundancyType", wireType) - } - m.RedundancyType = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.RedundancyType |= RedundancyType(b&0x7F) << shift - if b < 0x80 { - break - } + if m.DstPrimarySpApproval == nil { + m.DstPrimarySpApproval = &common.Approval{} + } + if err := m.DstPrimarySpApproval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -9343,7 +11605,7 @@ func (m *MsgCreateObject) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCreateObjectResponse) Unmarshal(dAtA []byte) error { +func (m *MsgCopyObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9366,10 +11628,10 @@ func (m *MsgCreateObjectResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCreateObjectResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCopyObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCreateObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCopyObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -9427,7 +11689,7 @@ func (m *MsgCreateObjectResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSealObject) Unmarshal(dAtA []byte) error { +func (m *MsgDeleteObject) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9450,10 +11712,10 @@ func (m *MsgSealObject) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSealObject: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDeleteObject: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSealObject: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDeleteObject: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -9552,59 +11814,6 @@ func (m *MsgSealObject) Unmarshal(dAtA []byte) error { } m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupId", wireType) - } - m.GlobalVirtualGroupId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.GlobalVirtualGroupId |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SecondarySpBlsAggSignatures", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SecondarySpBlsAggSignatures = append(m.SecondarySpBlsAggSignatures[:0], dAtA[iNdEx:postIndex]...) - if m.SecondarySpBlsAggSignatures == nil { - m.SecondarySpBlsAggSignatures = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -9626,7 +11835,7 @@ func (m *MsgSealObject) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSealObjectResponse) Unmarshal(dAtA []byte) error { +func (m *MsgDeleteObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9649,10 +11858,10 @@ func (m *MsgSealObjectResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSealObjectResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDeleteObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSealObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDeleteObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -9676,7 +11885,7 @@ func (m *MsgSealObjectResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgRejectSealObject) Unmarshal(dAtA []byte) error { +func (m *MsgDiscontinueObject) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9699,10 +11908,10 @@ func (m *MsgRejectSealObject) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgRejectSealObject: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDiscontinueObject: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRejectSealObject: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDiscontinueObject: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -9771,7 +11980,7 @@ func (m *MsgRejectSealObject) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectIds", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -9799,7 +12008,43 @@ func (m *MsgRejectSealObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ObjectName = string(dAtA[iNdEx:postIndex]) + var v Uint + m.ObjectIds = append(m.ObjectIds, v) + if err := m.ObjectIds[len(m.ObjectIds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", 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.Reason = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -9822,7 +12067,7 @@ func (m *MsgRejectSealObject) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgRejectSealObjectResponse) Unmarshal(dAtA []byte) error { +func (m *MsgDiscontinueObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9845,10 +12090,10 @@ func (m *MsgRejectSealObjectResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgRejectSealObjectResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDiscontinueObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRejectSealObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDiscontinueObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -9872,7 +12117,7 @@ func (m *MsgRejectSealObjectResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCopyObject) Unmarshal(dAtA []byte) error { +func (m *MsgCreateGroup) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9895,15 +12140,15 @@ func (m *MsgCopyObject) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCopyObject: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCreateGroup: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCopyObject: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCreateGroup: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -9931,11 +12176,11 @@ func (m *MsgCopyObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Operator = string(dAtA[iNdEx:postIndex]) + m.Creator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SrcBucketName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -9963,75 +12208,11 @@ func (m *MsgCopyObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SrcBucketName = string(dAtA[iNdEx:postIndex]) + m.GroupName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DstBucketName", 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.DstBucketName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SrcObjectName", 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.SrcObjectName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DstObjectName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10059,43 +12240,7 @@ func (m *MsgCopyObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.DstObjectName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DstPrimarySpApproval", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.DstPrimarySpApproval == nil { - m.DstPrimarySpApproval = &common.Approval{} - } - if err := m.DstPrimarySpApproval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Extra = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -10118,7 +12263,7 @@ func (m *MsgCopyObject) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCopyObjectResponse) Unmarshal(dAtA []byte) error { +func (m *MsgCreateGroupResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10141,15 +12286,15 @@ func (m *MsgCopyObjectResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCopyObjectResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCreateGroupResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCopyObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCreateGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10177,7 +12322,7 @@ func (m *MsgCopyObjectResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.GroupId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -10202,7 +12347,7 @@ func (m *MsgCopyObjectResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDeleteObject) Unmarshal(dAtA []byte) error { +func (m *MsgDeleteGroup) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10225,10 +12370,10 @@ func (m *MsgDeleteObject) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDeleteObject: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDeleteGroup: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDeleteObject: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDeleteGroup: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10265,39 +12410,7 @@ func (m *MsgDeleteObject) Unmarshal(dAtA []byte) error { 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 ObjectName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10325,7 +12438,7 @@ func (m *MsgDeleteObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ObjectName = string(dAtA[iNdEx:postIndex]) + m.GroupName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -10348,7 +12461,7 @@ func (m *MsgDeleteObject) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDeleteObjectResponse) Unmarshal(dAtA []byte) error { +func (m *MsgDeleteGroupResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10371,10 +12484,10 @@ func (m *MsgDeleteObjectResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDeleteObjectResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDeleteGroupResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDeleteObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDeleteGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -10398,7 +12511,7 @@ func (m *MsgDeleteObjectResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDiscontinueObject) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateGroupMember) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10421,10 +12534,10 @@ func (m *MsgDiscontinueObject) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDiscontinueObject: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateGroupMember: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDiscontinueObject: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateGroupMember: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10461,7 +12574,7 @@ func (m *MsgDiscontinueObject) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GroupOwner", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10489,11 +12602,11 @@ func (m *MsgDiscontinueObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BucketName = string(dAtA[iNdEx:postIndex]) + m.GroupOwner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectIds", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10521,15 +12634,45 @@ func (m *MsgDiscontinueObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - var v Uint - m.ObjectIds = append(m.ObjectIds, v) - if err := m.ObjectIds[len(m.ObjectIds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.GroupName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MembersToAdd", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MembersToAdd = append(m.MembersToAdd, &MsgGroupMember{}) + if err := m.MembersToAdd[len(m.MembersToAdd)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MembersToDelete", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10557,7 +12700,7 @@ func (m *MsgDiscontinueObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Reason = string(dAtA[iNdEx:postIndex]) + m.MembersToDelete = append(m.MembersToDelete, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex default: iNdEx = preIndex @@ -10580,7 +12723,7 @@ func (m *MsgDiscontinueObject) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDiscontinueObjectResponse) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateGroupMemberResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10603,10 +12746,10 @@ func (m *MsgDiscontinueObjectResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDiscontinueObjectResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateGroupMemberResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDiscontinueObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateGroupMemberResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -10630,7 +12773,7 @@ func (m *MsgDiscontinueObjectResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCreateGroup) Unmarshal(dAtA []byte) error { +func (m *MsgRenewGroupMember) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10653,15 +12796,15 @@ func (m *MsgCreateGroup) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCreateGroup: wiretype end group for non-group") + return fmt.Errorf("proto: MsgRenewGroupMember: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCreateGroup: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgRenewGroupMember: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10689,11 +12832,11 @@ func (m *MsgCreateGroup) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Creator = string(dAtA[iNdEx:postIndex]) + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GroupOwner", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10721,11 +12864,11 @@ func (m *MsgCreateGroup) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.GroupName = string(dAtA[iNdEx:postIndex]) + m.GroupOwner = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10753,7 +12896,41 @@ func (m *MsgCreateGroup) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Extra = string(dAtA[iNdEx:postIndex]) + m.GroupName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Members = append(m.Members, &MsgGroupMember{}) + if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -10776,7 +12953,7 @@ func (m *MsgCreateGroup) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCreateGroupResponse) Unmarshal(dAtA []byte) error { +func (m *MsgRenewGroupMemberResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10799,46 +12976,12 @@ func (m *MsgCreateGroupResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCreateGroupResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgRenewGroupMemberResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCreateGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgRenewGroupMemberResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GroupId", 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.GroupId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -10860,7 +13003,7 @@ func (m *MsgCreateGroupResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDeleteGroup) Unmarshal(dAtA []byte) error { +func (m *MsgGroupMember) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10883,15 +13026,15 @@ func (m *MsgDeleteGroup) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDeleteGroup: wiretype end group for non-group") + return fmt.Errorf("proto: MsgGroupMember: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDeleteGroup: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgGroupMember: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -10919,13 +13062,13 @@ func (m *MsgDeleteGroup) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Operator = string(dAtA[iNdEx:postIndex]) + m.Member = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -10935,74 +13078,28 @@ func (m *MsgDeleteGroup) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.GroupName = string(dAtA[iNdEx:postIndex]) - 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 *MsgDeleteGroupResponse) 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 + if m.ExpirationTime == nil { + m.ExpirationTime = new(time.Time) } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.ExpirationTime, dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgDeleteGroupResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDeleteGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -11024,7 +13121,7 @@ func (m *MsgDeleteGroupResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateGroupMember) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateGroupExtra) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11047,10 +13144,10 @@ func (m *MsgUpdateGroupMember) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateGroupMember: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateGroupExtra: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateGroupMember: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateGroupExtra: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -11151,41 +13248,7 @@ func (m *MsgUpdateGroupMember) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MembersToAdd", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.MembersToAdd = append(m.MembersToAdd, &MsgGroupMember{}) - if err := m.MembersToAdd[len(m.MembersToAdd)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MembersToDelete", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -11213,7 +13276,7 @@ func (m *MsgUpdateGroupMember) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.MembersToDelete = append(m.MembersToDelete, string(dAtA[iNdEx:postIndex])) + m.Extra = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -11236,7 +13299,7 @@ func (m *MsgUpdateGroupMember) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateGroupMemberResponse) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateGroupExtraResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11259,10 +13322,10 @@ func (m *MsgUpdateGroupMemberResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateGroupMemberResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateGroupExtraResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateGroupMemberResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateGroupExtraResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -11286,7 +13349,7 @@ func (m *MsgUpdateGroupMemberResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgRenewGroupMember) Unmarshal(dAtA []byte) error { +func (m *MsgLeaveGroup) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11309,15 +13372,15 @@ func (m *MsgRenewGroupMember) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgRenewGroupMember: wiretype end group for non-group") + return fmt.Errorf("proto: MsgLeaveGroup: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRenewGroupMember: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgLeaveGroup: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -11345,7 +13408,7 @@ func (m *MsgRenewGroupMember) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Operator = string(dAtA[iNdEx:postIndex]) + m.Member = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -11411,40 +13474,6 @@ func (m *MsgRenewGroupMember) Unmarshal(dAtA []byte) error { } m.GroupName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Members = append(m.Members, &MsgGroupMember{}) - if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -11466,7 +13495,7 @@ func (m *MsgRenewGroupMember) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgRenewGroupMemberResponse) Unmarshal(dAtA []byte) error { +func (m *MsgLeaveGroupResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11489,10 +13518,10 @@ func (m *MsgRenewGroupMemberResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgRenewGroupMemberResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgLeaveGroupResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRenewGroupMemberResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgLeaveGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -11516,7 +13545,7 @@ func (m *MsgRenewGroupMemberResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgGroupMember) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateBucketInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11539,15 +13568,15 @@ func (m *MsgGroupMember) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgGroupMember: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateBucketInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgGroupMember: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateBucketInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -11575,11 +13604,43 @@ func (m *MsgGroupMember) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Member = string(dAtA[iNdEx:postIndex]) + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType) + 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 ChargedReadQuota", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -11603,16 +13664,117 @@ func (m *MsgGroupMember) Unmarshal(dAtA []byte) error { if postIndex < 0 { return ErrInvalidLengthTx } - if postIndex > l { + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ChargedReadQuota == nil { + m.ChargedReadQuota = &common.UInt64Value{} + } + if err := m.ChargedReadQuota.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) + } + m.Visibility = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Visibility |= VisibilityType(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 *MsgUpdateBucketInfoResponse) 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 } - if m.ExpirationTime == nil { - m.ExpirationTime = new(time.Time) - } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.ExpirationTime, dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateBucketInfoResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateBucketInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -11634,7 +13796,7 @@ func (m *MsgGroupMember) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateGroupExtra) Unmarshal(dAtA []byte) error { +func (m *MsgCancelCreateObject) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11657,10 +13819,10 @@ func (m *MsgUpdateGroupExtra) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateGroupExtra: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCancelCreateObject: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateGroupExtra: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCancelCreateObject: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -11697,7 +13859,7 @@ func (m *MsgUpdateGroupExtra) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GroupOwner", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -11725,43 +13887,11 @@ func (m *MsgUpdateGroupExtra) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.GroupOwner = string(dAtA[iNdEx:postIndex]) + m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GroupName", 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.GroupName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Extra", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -11789,7 +13919,7 @@ func (m *MsgUpdateGroupExtra) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Extra = string(dAtA[iNdEx:postIndex]) + m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -11812,7 +13942,7 @@ func (m *MsgUpdateGroupExtra) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateGroupExtraResponse) Unmarshal(dAtA []byte) error { +func (m *MsgCancelCreateObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11835,10 +13965,10 @@ func (m *MsgUpdateGroupExtraResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateGroupExtraResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCancelCreateObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateGroupExtraResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCancelCreateObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -11862,7 +13992,7 @@ func (m *MsgUpdateGroupExtraResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgLeaveGroup) Unmarshal(dAtA []byte) error { +func (m *MsgPutPolicy) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -11885,15 +14015,15 @@ func (m *MsgLeaveGroup) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgLeaveGroup: wiretype end group for non-group") + return fmt.Errorf("proto: MsgPutPolicy: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgLeaveGroup: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgPutPolicy: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -11921,13 +14051,13 @@ func (m *MsgLeaveGroup) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Member = string(dAtA[iNdEx:postIndex]) + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GroupOwner", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Principal", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -11937,27 +14067,31 @@ func (m *MsgLeaveGroup) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.GroupOwner = string(dAtA[iNdEx:postIndex]) + if m.Principal == nil { + m.Principal = &types.Principal{} + } + if err := m.Principal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -11985,58 +14119,78 @@ func (m *MsgLeaveGroup) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.GroupName = string(dAtA[iNdEx:postIndex]) + m.Resource = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Statements", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { return ErrInvalidLengthTx } - if (iNdEx + skippy) > l { + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MsgLeaveGroupResponse) 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 + m.Statements = append(m.Statements, &types.Statement{}) + if err := m.Statements[len(m.Statements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - if iNdEx >= l { + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if m.ExpirationTime == nil { + m.ExpirationTime = new(time.Time) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgLeaveGroupResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgLeaveGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.ExpirationTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -12058,7 +14212,7 @@ func (m *MsgLeaveGroupResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateBucketInfo) Unmarshal(dAtA []byte) error { +func (m *MsgPutPolicyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12081,15 +14235,15 @@ func (m *MsgUpdateBucketInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateBucketInfo: wiretype end group for non-group") + return fmt.Errorf("proto: MsgPutPolicyResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateBucketInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgPutPolicyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PolicyId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12114,14 +14268,66 @@ func (m *MsgUpdateBucketInfo) Unmarshal(dAtA []byte) error { if postIndex < 0 { return ErrInvalidLengthTx } - if postIndex > l { + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.PolicyId.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 *MsgDeletePolicy) 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 } - m.Operator = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: + 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: MsgDeletePolicy: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDeletePolicy: 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) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12149,11 +14355,11 @@ func (m *MsgUpdateBucketInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BucketName = string(dAtA[iNdEx:postIndex]) + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ChargedReadQuota", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Principal", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -12180,16 +14386,16 @@ func (m *MsgUpdateBucketInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ChargedReadQuota == nil { - m.ChargedReadQuota = &common.UInt64Value{} + if m.Principal == nil { + m.Principal = &types.Principal{} } - if err := m.ChargedReadQuota.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Principal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PaymentAddress", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12217,27 +14423,8 @@ func (m *MsgUpdateBucketInfo) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PaymentAddress = string(dAtA[iNdEx:postIndex]) + m.Resource = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) - } - m.Visibility = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Visibility |= VisibilityType(b&0x7F) << shift - if b < 0x80 { - break - } - } default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -12259,7 +14446,7 @@ func (m *MsgUpdateBucketInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateBucketInfoResponse) Unmarshal(dAtA []byte) error { +func (m *MsgDeletePolicyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12282,12 +14469,46 @@ func (m *MsgUpdateBucketInfoResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateBucketInfoResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDeletePolicyResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateBucketInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDeletePolicyResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PolicyId", 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.PolicyId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -12309,7 +14530,7 @@ func (m *MsgUpdateBucketInfoResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCancelCreateObject) Unmarshal(dAtA []byte) error { +func (m *MsgMirrorObject) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12332,10 +14553,10 @@ func (m *MsgCancelCreateObject) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCancelCreateObject: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMirrorObject: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelCreateObject: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgMirrorObject: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -12371,6 +14592,40 @@ func (m *MsgCancelCreateObject) Unmarshal(dAtA []byte) error { m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } @@ -12402,7 +14657,7 @@ func (m *MsgCancelCreateObject) Unmarshal(dAtA []byte) error { } m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } @@ -12434,6 +14689,25 @@ func (m *MsgCancelCreateObject) Unmarshal(dAtA []byte) error { } m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DestChainId", wireType) + } + m.DestChainId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DestChainId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -12455,7 +14729,7 @@ func (m *MsgCancelCreateObject) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCancelCreateObjectResponse) Unmarshal(dAtA []byte) error { +func (m *MsgMirrorObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12478,10 +14752,10 @@ func (m *MsgCancelCreateObjectResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCancelCreateObjectResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMirrorObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelCreateObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgMirrorObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -12505,7 +14779,7 @@ func (m *MsgCancelCreateObjectResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgPutPolicy) Unmarshal(dAtA []byte) error { +func (m *MsgMirrorBucket) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12528,10 +14802,10 @@ func (m *MsgPutPolicy) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgPutPolicy: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMirrorBucket: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgPutPolicy: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgMirrorBucket: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -12568,9 +14842,9 @@ func (m *MsgPutPolicy) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Principal", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -12580,31 +14854,29 @@ func (m *MsgPutPolicy) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Principal == nil { - m.Principal = &types.Principal{} - } - if err := m.Principal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12632,47 +14904,13 @@ func (m *MsgPutPolicy) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Resource = string(dAtA[iNdEx:postIndex]) + m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Statements", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Statements = append(m.Statements, &types.Statement{}) - if err := m.Statements[len(m.Statements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExpirationTime", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DestChainId", wireType) } - var msglen int + m.DestChainId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -12682,28 +14920,11 @@ func (m *MsgPutPolicy) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.DestChainId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ExpirationTime == nil { - m.ExpirationTime = new(time.Time) - } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.ExpirationTime, dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -12725,7 +14946,7 @@ func (m *MsgPutPolicy) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgPutPolicyResponse) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateObjectInfoResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12748,46 +14969,12 @@ func (m *MsgPutPolicyResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgPutPolicyResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateObjectInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgPutPolicyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateObjectInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PolicyId", 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.PolicyId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -12809,7 +14996,7 @@ func (m *MsgPutPolicyResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDeletePolicy) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateObjectInfo) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12832,10 +15019,10 @@ func (m *MsgDeletePolicy) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDeletePolicy: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateObjectInfo: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDeletePolicy: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateObjectInfo: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -12872,9 +15059,9 @@ func (m *MsgDeletePolicy) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Principal", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -12884,31 +15071,27 @@ func (m *MsgDeletePolicy) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Principal == nil { - m.Principal = &types.Principal{} - } - if err := m.Principal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -12936,8 +15119,27 @@ func (m *MsgDeletePolicy) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Resource = string(dAtA[iNdEx:postIndex]) + m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) + } + m.Visibility = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Visibility |= VisibilityType(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -12959,7 +15161,7 @@ func (m *MsgDeletePolicy) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgDeletePolicyResponse) Unmarshal(dAtA []byte) error { +func (m *MsgMirrorBucketResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -12982,46 +15184,12 @@ func (m *MsgDeletePolicyResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgDeletePolicyResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMirrorBucketResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDeletePolicyResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgMirrorBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PolicyId", 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.PolicyId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -13043,7 +15211,7 @@ func (m *MsgDeletePolicyResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMirrorObject) Unmarshal(dAtA []byte) error { +func (m *MsgMirrorGroup) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13066,10 +15234,10 @@ func (m *MsgMirrorObject) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMirrorObject: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMirrorGroup: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMirrorObject: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgMirrorGroup: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -13140,7 +15308,7 @@ func (m *MsgMirrorObject) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13168,11 +15336,130 @@ func (m *MsgMirrorObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BucketName = string(dAtA[iNdEx:postIndex]) + m.GroupName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DestChainId", wireType) + } + m.DestChainId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DestChainId |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 *MsgMirrorGroupResponse) 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: MsgMirrorGroupResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgMirrorGroupResponse: 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 (m *MsgUpdateParams) 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: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13200,13 +15487,13 @@ func (m *MsgMirrorObject) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.ObjectName = string(dAtA[iNdEx:postIndex]) + m.Authority = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DestChainId", wireType) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) } - m.DestChainId = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -13216,11 +15503,25 @@ func (m *MsgMirrorObject) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.DestChainId |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -13242,7 +15543,7 @@ func (m *MsgMirrorObject) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMirrorObjectResponse) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13265,10 +15566,10 @@ func (m *MsgMirrorObjectResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMirrorObjectResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMirrorObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -13292,7 +15593,7 @@ func (m *MsgMirrorObjectResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMirrorBucket) Unmarshal(dAtA []byte) error { +func (m *MsgMigrateBucket) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13315,10 +15616,10 @@ func (m *MsgMirrorBucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMirrorBucket: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMigrateBucket: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMirrorBucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgMigrateBucket: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -13355,7 +15656,7 @@ func (m *MsgMirrorBucket) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13383,15 +15684,13 @@ func (m *MsgMirrorBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DstPrimarySpId", wireType) } - var stringLen uint64 + m.DstPrimarySpId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -13401,29 +15700,16 @@ func (m *MsgMirrorBucket) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.DstPrimarySpId |= uint32(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 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DestChainId", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DstPrimarySpApproval", wireType) } - m.DestChainId = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -13433,11 +15719,28 @@ func (m *MsgMirrorBucket) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.DestChainId |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DstPrimarySpApproval == nil { + m.DstPrimarySpApproval = &common.Approval{} + } + if err := m.DstPrimarySpApproval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -13459,7 +15762,7 @@ func (m *MsgMirrorBucket) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateObjectInfoResponse) Unmarshal(dAtA []byte) error { +func (m *MsgMigrateBucketResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13482,10 +15785,10 @@ func (m *MsgUpdateObjectInfoResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateObjectInfoResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMigrateBucketResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateObjectInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgMigrateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -13509,7 +15812,7 @@ func (m *MsgUpdateObjectInfoResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateObjectInfo) Unmarshal(dAtA []byte) error { +func (m *MsgCompleteMigrateBucket) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13532,10 +15835,10 @@ func (m *MsgUpdateObjectInfo) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateObjectInfo: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCompleteMigrateBucket: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateObjectInfo: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCompleteMigrateBucket: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -13603,10 +15906,10 @@ func (m *MsgUpdateObjectInfo) Unmarshal(dAtA []byte) error { m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupFamilyId", wireType) } - var stringLen uint64 + m.GlobalVirtualGroupFamilyId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -13616,29 +15919,16 @@ func (m *MsgUpdateObjectInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + m.GlobalVirtualGroupFamilyId |= uint32(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.ObjectName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GvgMappings", wireType) } - m.Visibility = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -13648,11 +15938,26 @@ func (m *MsgUpdateObjectInfo) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Visibility |= VisibilityType(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.GvgMappings = append(m.GvgMappings, &GVGMapping{}) + if err := m.GvgMappings[len(m.GvgMappings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -13674,7 +15979,7 @@ func (m *MsgUpdateObjectInfo) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMirrorBucketResponse) Unmarshal(dAtA []byte) error { +func (m *MsgCompleteMigrateBucketResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13697,10 +16002,10 @@ func (m *MsgMirrorBucketResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMirrorBucketResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCompleteMigrateBucketResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMirrorBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCompleteMigrateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -13724,7 +16029,7 @@ func (m *MsgMirrorBucketResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMirrorGroup) Unmarshal(dAtA []byte) error { +func (m *MsgCancelMigrateBucket) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13747,10 +16052,10 @@ func (m *MsgMirrorGroup) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMirrorGroup: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCancelMigrateBucket: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMirrorGroup: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCancelMigrateBucket: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -13787,41 +16092,7 @@ func (m *MsgMirrorGroup) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -13849,27 +16120,8 @@ func (m *MsgMirrorGroup) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.GroupName = string(dAtA[iNdEx:postIndex]) + m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DestChainId", wireType) - } - m.DestChainId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DestChainId |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -13891,7 +16143,7 @@ func (m *MsgMirrorGroup) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMirrorGroupResponse) Unmarshal(dAtA []byte) error { +func (m *MsgCancelMigrateBucketResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13914,10 +16166,10 @@ func (m *MsgMirrorGroupResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMirrorGroupResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCancelMigrateBucketResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMirrorGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCancelMigrateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -13941,7 +16193,7 @@ func (m *MsgMirrorGroupResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { +func (m *MsgRejectMigrateBucket) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -13964,15 +16216,15 @@ func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + return fmt.Errorf("proto: MsgRejectMigrateBucket: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgRejectMigrateBucket: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14000,13 +16252,13 @@ func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Authority = string(dAtA[iNdEx:postIndex]) + m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -14016,24 +16268,23 @@ func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -14056,7 +16307,7 @@ func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { +func (m *MsgRejectMigrateBucketResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14079,10 +16330,10 @@ func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgRejectMigrateBucketResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgRejectMigrateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -14106,7 +16357,7 @@ func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMigrateBucket) Unmarshal(dAtA []byte) error { +func (m *MsgSetTag) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14129,10 +16380,10 @@ func (m *MsgMigrateBucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMigrateBucket: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSetTag: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMigrateBucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSetTag: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -14169,7 +16420,7 @@ func (m *MsgMigrateBucket) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14197,30 +16448,11 @@ func (m *MsgMigrateBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BucketName = string(dAtA[iNdEx:postIndex]) + m.Resource = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DstPrimarySpId", wireType) - } - m.DstPrimarySpId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DstPrimarySpId |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DstPrimarySpApproval", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -14247,10 +16479,10 @@ func (m *MsgMigrateBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.DstPrimarySpApproval == nil { - m.DstPrimarySpApproval = &common.Approval{} + if m.Tags == nil { + m.Tags = &ResourceTags{} } - if err := m.DstPrimarySpApproval.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Tags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -14275,7 +16507,7 @@ func (m *MsgMigrateBucket) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMigrateBucketResponse) Unmarshal(dAtA []byte) error { +func (m *MsgSetTagResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14298,10 +16530,10 @@ func (m *MsgMigrateBucketResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMigrateBucketResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSetTagResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMigrateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSetTagResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -14325,7 +16557,7 @@ func (m *MsgMigrateBucketResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCompleteMigrateBucket) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14348,10 +16580,10 @@ func (m *MsgCompleteMigrateBucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCompleteMigrateBucket: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateObjectContent: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCompleteMigrateBucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateObjectContent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -14419,10 +16651,10 @@ func (m *MsgCompleteMigrateBucket) Unmarshal(dAtA []byte) error { m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field GlobalVirtualGroupFamilyId", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } - m.GlobalVirtualGroupFamilyId = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -14432,16 +16664,48 @@ func (m *MsgCompleteMigrateBucket) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.GlobalVirtualGroupFamilyId |= uint32(b&0x7F) << shift + 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.ObjectName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PayloadSize", wireType) + } + m.PayloadSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PayloadSize |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field GvgMappings", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -14451,25 +16715,55 @@ func (m *MsgCompleteMigrateBucket) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.GvgMappings = append(m.GvgMappings, &GVGMapping{}) - if err := m.GvgMappings[len(m.GvgMappings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.ContentType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExpectChecksums", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF } + m.ExpectChecksums = append(m.ExpectChecksums, make([]byte, postIndex-iNdEx)) + copy(m.ExpectChecksums[len(m.ExpectChecksums)-1], dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -14492,7 +16786,7 @@ func (m *MsgCompleteMigrateBucket) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCompleteMigrateBucketResponse) Unmarshal(dAtA []byte) error { +func (m *MsgUpdateObjectContentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14515,10 +16809,10 @@ func (m *MsgCompleteMigrateBucketResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCompleteMigrateBucketResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgUpdateObjectContentResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCompleteMigrateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgUpdateObjectContentResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -14542,7 +16836,7 @@ func (m *MsgCompleteMigrateBucketResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCancelMigrateBucket) Unmarshal(dAtA []byte) error { +func (m *MsgCancelUpdateObjectContent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14565,10 +16859,10 @@ func (m *MsgCancelMigrateBucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCancelMigrateBucket: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCancelUpdateObjectContent: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelMigrateBucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCancelUpdateObjectContent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -14635,6 +16929,38 @@ func (m *MsgCancelMigrateBucket) Unmarshal(dAtA []byte) error { } m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", 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.ObjectName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -14656,7 +16982,7 @@ func (m *MsgCancelMigrateBucket) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCancelMigrateBucketResponse) Unmarshal(dAtA []byte) error { +func (m *MsgCancelUpdateObjectContentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14679,10 +17005,10 @@ func (m *MsgCancelMigrateBucketResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCancelMigrateBucketResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgCancelUpdateObjectContentResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelMigrateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgCancelUpdateObjectContentResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -14706,7 +17032,7 @@ func (m *MsgCancelMigrateBucketResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgRejectMigrateBucket) Unmarshal(dAtA []byte) error { +func (m *MsgDelegateCreateObject) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -14729,10 +17055,10 @@ func (m *MsgRejectMigrateBucket) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgRejectMigrateBucket: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDelegateCreateObject: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRejectMigrateBucket: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDelegateCreateObject: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -14769,7 +17095,7 @@ func (m *MsgRejectMigrateBucket) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14797,111 +17123,43 @@ func (m *MsgRejectMigrateBucket) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.BucketName = string(dAtA[iNdEx:postIndex]) + m.Creator = string(dAtA[iNdEx:postIndex]) 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 *MsgRejectMigrateBucketResponse) 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 + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: MsgRejectMigrateBucketResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgRejectMigrateBucketResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err + 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 + } } - if (skippy < 0) || (iNdEx+skippy) < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthTx } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *MsgSetTag) 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 + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx } - if iNdEx >= l { + if postIndex > 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: MsgSetTag: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSetTag: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + m.BucketName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14929,11 +17187,30 @@ func (m *MsgSetTag) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Operator = string(dAtA[iNdEx:postIndex]) + m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PayloadSize", wireType) + } + m.PayloadSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.PayloadSize |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -14961,13 +17238,32 @@ func (m *MsgSetTag) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Resource = string(dAtA[iNdEx:postIndex]) + m.ContentType = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Visibility", wireType) + } + m.Visibility = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Visibility |= VisibilityType(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ExpectChecksums", wireType) } - var msglen int + var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -14977,28 +17273,43 @@ func (m *MsgSetTag) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + if byteLen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + msglen + postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - if m.Tags == nil { - m.Tags = &ResourceTags{} + m.ExpectChecksums = append(m.ExpectChecksums, make([]byte, postIndex-iNdEx)) + copy(m.ExpectChecksums[len(m.ExpectChecksums)-1], dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RedundancyType", wireType) } - if err := m.Tags.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + m.RedundancyType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.RedundancyType |= RedundancyType(b&0x7F) << shift + if b < 0x80 { + break + } } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -15020,7 +17331,7 @@ func (m *MsgSetTag) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgSetTagResponse) Unmarshal(dAtA []byte) error { +func (m *MsgDelegateCreateObjectResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15043,12 +17354,46 @@ func (m *MsgSetTagResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgSetTagResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDelegateCreateObjectResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgSetTagResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDelegateCreateObjectResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ObjectId", 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.ObjectId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -15070,7 +17415,7 @@ func (m *MsgSetTagResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { +func (m *MsgDelegateUpdateObjectContent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15093,10 +17438,10 @@ func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateObjectContent: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDelegateUpdateObjectContent: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateObjectContent: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDelegateUpdateObjectContent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -15132,6 +17477,38 @@ func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { m.Operator = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Updater", 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.Updater = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field BucketName", wireType) } @@ -15163,7 +17540,7 @@ func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { } m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", wireType) } @@ -15195,7 +17572,7 @@ func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { } m.ObjectName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field PayloadSize", wireType) } @@ -15214,7 +17591,7 @@ func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { break } } - case 5: + case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContentType", wireType) } @@ -15246,7 +17623,7 @@ func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { } m.ContentType = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 6: + case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ExpectChecksums", wireType) } @@ -15299,7 +17676,7 @@ func (m *MsgUpdateObjectContent) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgUpdateObjectContentResponse) Unmarshal(dAtA []byte) error { +func (m *MsgDelegateUpdateObjectContentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15322,10 +17699,10 @@ func (m *MsgUpdateObjectContentResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgUpdateObjectContentResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgDelegateUpdateObjectContentResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgUpdateObjectContentResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgDelegateUpdateObjectContentResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -15349,7 +17726,7 @@ func (m *MsgUpdateObjectContentResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCancelUpdateObjectContent) Unmarshal(dAtA []byte) error { +func (m *MsgToggleSPAsDelegatedAgent) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15372,10 +17749,10 @@ func (m *MsgCancelUpdateObjectContent) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCancelUpdateObjectContent: wiretype end group for non-group") + return fmt.Errorf("proto: MsgToggleSPAsDelegatedAgent: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelUpdateObjectContent: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgToggleSPAsDelegatedAgent: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -15442,38 +17819,6 @@ func (m *MsgCancelUpdateObjectContent) Unmarshal(dAtA []byte) error { } m.BucketName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ObjectName", 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.ObjectName = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTx(dAtA[iNdEx:]) @@ -15495,7 +17840,7 @@ func (m *MsgCancelUpdateObjectContent) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCancelUpdateObjectContentResponse) Unmarshal(dAtA []byte) error { +func (m *MsgToggleSPAsDelegatedAgentResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -15518,10 +17863,10 @@ func (m *MsgCancelUpdateObjectContentResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCancelUpdateObjectContentResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgToggleSPAsDelegatedAgentResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelUpdateObjectContentResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgToggleSPAsDelegatedAgentResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: diff --git a/x/storage/types/types.pb.go b/x/storage/types/types.pb.go index 85c398f04..743b79003 100644 --- a/x/storage/types/types.pb.go +++ b/x/storage/types/types.pb.go @@ -51,6 +51,9 @@ type BucketInfo struct { BucketStatus BucketStatus `protobuf:"varint,10,opt,name=bucket_status,json=bucketStatus,proto3,enum=greenfield.storage.BucketStatus" json:"bucket_status,omitempty"` // tags defines a list of tags the bucket has Tags *ResourceTags `protobuf:"bytes,11,opt,name=tags,proto3" json:"tags,omitempty"` + // sp_as_delegated_agent_disabled indicates that whether bucket owner disable SP as the upload agent. + // when a bucket is created, by default, this is false, means SP is allowed to create object for delegator + SpAsDelegatedAgentDisabled bool `protobuf:"varint,12,opt,name=sp_as_delegated_agent_disabled,json=spAsDelegatedAgentDisabled,proto3" json:"sp_as_delegated_agent_disabled,omitempty"` } func (m *BucketInfo) Reset() { *m = BucketInfo{} } @@ -156,6 +159,13 @@ func (m *BucketInfo) GetTags() *ResourceTags { return nil } +func (m *BucketInfo) GetSpAsDelegatedAgentDisabled() bool { + if m != nil { + return m.SpAsDelegatedAgentDisabled + } + return false +} + type InternalBucketInfo struct { // the time of the payment price, used to calculate the charge rate of the bucket PriceTime int64 `protobuf:"varint,1,opt,name=price_time,json=priceTime,proto3" json:"price_time,omitempty"` @@ -1175,93 +1185,96 @@ func init() { func init() { proto.RegisterFile("greenfield/storage/types.proto", fileDescriptor_bf95fa2efdc74d97) } var fileDescriptor_bf95fa2efdc74d97 = []byte{ - // 1370 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xdf, 0x6e, 0x13, 0x47, - 0x17, 0xcf, 0x7a, 0xed, 0x24, 0x3e, 0xce, 0x3f, 0x86, 0xe8, 0x63, 0x09, 0xc2, 0x31, 0xd6, 0xf7, - 0x7d, 0xb2, 0xda, 0xc6, 0x16, 0x01, 0xd1, 0xaa, 0x42, 0x45, 0x71, 0xa1, 0xc8, 0x6a, 0x69, 0xd5, - 0x4d, 0xa0, 0x52, 0x6f, 0x56, 0xe3, 0xdd, 0xc9, 0x66, 0xca, 0xee, 0x8e, 0x3b, 0x33, 0x1b, 0x62, - 0xa4, 0xbe, 0x40, 0xaf, 0x7a, 0xd1, 0x57, 0xe8, 0x0b, 0x54, 0x3c, 0x04, 0xaa, 0x54, 0x09, 0x71, - 0x55, 0xf5, 0x22, 0xaa, 0xe0, 0x0d, 0x7a, 0xd1, 0xeb, 0x6a, 0x67, 0xc6, 0x66, 0xfd, 0x27, 0x38, - 0x41, 0x70, 0xb7, 0x73, 0xe6, 0x77, 0x66, 0xce, 0xbf, 0xdf, 0x39, 0xb3, 0x50, 0x0d, 0x39, 0x21, - 0xc9, 0x3e, 0x25, 0x51, 0xd0, 0x12, 0x92, 0x71, 0x1c, 0x92, 0x96, 0xec, 0xf7, 0x88, 0x68, 0xf6, - 0x38, 0x93, 0x0c, 0xa1, 0x57, 0xfb, 0x4d, 0xb3, 0xbf, 0x51, 0xf5, 0x99, 0x88, 0x99, 0x68, 0x75, - 0xb1, 0x20, 0xad, 0xc3, 0xab, 0x5d, 0x22, 0xf1, 0xd5, 0x96, 0xcf, 0x68, 0xa2, 0x75, 0x36, 0x2e, - 0xea, 0x7d, 0x4f, 0xad, 0x5a, 0x7a, 0x61, 0xb6, 0xd6, 0x43, 0x16, 0x32, 0x2d, 0xcf, 0xbe, 0x8c, - 0xf4, 0x4a, 0xce, 0x88, 0x1e, 0xee, 0xc7, 0x24, 0x91, 0x2d, 0x96, 0x4a, 0x6f, 0x3f, 0x62, 0x8f, - 0x0c, 0xe4, 0xff, 0x53, 0x20, 0x42, 0x72, 0x82, 0x63, 0x8f, 0x13, 0x9f, 0xf1, 0xc0, 0xe0, 0x36, - 0xa7, 0xf8, 0xe3, 0xb3, 0x38, 0x66, 0xc6, 0xb8, 0xfa, 0x71, 0x11, 0xa0, 0x9d, 0xfa, 0x0f, 0x89, - 0xec, 0x24, 0xfb, 0x0c, 0x35, 0xa1, 0xc4, 0x1e, 0x25, 0x84, 0x3b, 0x56, 0xcd, 0x6a, 0x94, 0xdb, - 0xce, 0xf3, 0x27, 0x5b, 0xeb, 0xc6, 0xe2, 0x9d, 0x20, 0xe0, 0x44, 0x88, 0x5d, 0xc9, 0x69, 0x12, - 0xba, 0x1a, 0x86, 0x36, 0xa1, 0xd2, 0x55, 0xda, 0x5e, 0x82, 0x63, 0xe2, 0x14, 0x32, 0x2d, 0x17, - 0xb4, 0xe8, 0x4b, 0x1c, 0x13, 0xd4, 0x06, 0x38, 0xa4, 0x82, 0x76, 0x69, 0x44, 0x65, 0xdf, 0xb1, - 0x6b, 0x56, 0x63, 0x65, 0xbb, 0xde, 0x9c, 0x8c, 0x62, 0xf3, 0xc1, 0x10, 0xb5, 0xd7, 0xef, 0x11, - 0x37, 0xa7, 0x85, 0xde, 0x87, 0x02, 0x0d, 0x9c, 0xa2, 0xb2, 0xe8, 0xd2, 0xd3, 0xe3, 0xcd, 0xb9, - 0x3f, 0x8f, 0x37, 0x8b, 0xf7, 0x69, 0x22, 0x9f, 0x3f, 0xd9, 0xaa, 0x18, 0xeb, 0xb2, 0xa5, 0x5b, - 0xa0, 0x01, 0xba, 0x05, 0x15, 0xc1, 0x52, 0xee, 0x13, 0x2f, 0xcb, 0x9b, 0x53, 0x52, 0x37, 0x56, - 0xa7, 0xdd, 0xb8, 0xab, 0x60, 0xfa, 0x36, 0x31, 0xfc, 0x46, 0x97, 0xa0, 0xec, 0x73, 0x82, 0x25, - 0xf1, 0xb0, 0x74, 0xe6, 0x6b, 0x56, 0xc3, 0x76, 0x17, 0xb5, 0x60, 0x47, 0xa2, 0x1d, 0x58, 0x35, - 0xe1, 0xf6, 0xb0, 0x8e, 0x87, 0xb3, 0x30, 0x23, 0x52, 0x2b, 0x46, 0xc1, 0x48, 0x51, 0x1b, 0xaa, - 0x61, 0xc4, 0xba, 0x38, 0xf2, 0x0e, 0x29, 0x97, 0x29, 0x8e, 0xbc, 0x90, 0xb3, 0xb4, 0xe7, 0xed, - 0xe3, 0x98, 0x46, 0x7d, 0x8f, 0x06, 0xce, 0x62, 0xcd, 0x6a, 0x2c, 0xbb, 0x1b, 0x1a, 0xf5, 0x40, - 0x83, 0xee, 0x66, 0x98, 0xcf, 0x14, 0xa4, 0x13, 0xa0, 0x0f, 0x00, 0xf9, 0x07, 0x98, 0x87, 0x24, - 0xf0, 0x38, 0xc1, 0x81, 0xf7, 0x7d, 0xca, 0x24, 0x76, 0xca, 0x35, 0xab, 0x51, 0x74, 0xd7, 0xcc, - 0x8e, 0x4b, 0x70, 0xf0, 0x75, 0x26, 0x47, 0x77, 0x60, 0xd9, 0x24, 0x49, 0x48, 0x2c, 0x53, 0xe1, - 0x80, 0x0a, 0x4a, 0x6d, 0x5a, 0x50, 0x74, 0x2d, 0xec, 0x2a, 0x9c, 0xbb, 0xd4, 0xcd, 0xad, 0xd0, - 0x75, 0x28, 0x4a, 0x1c, 0x0a, 0xa7, 0x52, 0xb3, 0x1a, 0x95, 0xe9, 0xda, 0x2e, 0x31, 0x81, 0xc4, - 0xa1, 0x70, 0x15, 0xba, 0xfe, 0x8f, 0x05, 0xa8, 0x93, 0x48, 0xc2, 0x13, 0x1c, 0xe5, 0x0a, 0xed, - 0x32, 0x40, 0x8f, 0xd3, 0x2c, 0x4b, 0x34, 0x26, 0xaa, 0xda, 0x6c, 0xb7, 0xac, 0x24, 0x7b, 0x34, - 0x26, 0xe8, 0x3d, 0x38, 0x27, 0x99, 0xc4, 0x91, 0xa7, 0x9d, 0xf1, 0x04, 0x7d, 0xac, 0xab, 0xab, - 0xe8, 0xae, 0xaa, 0x8d, 0x4f, 0x95, 0x7c, 0x97, 0x3e, 0x26, 0xe8, 0x1b, 0x58, 0x8f, 0x98, 0x3f, - 0x1e, 0x4f, 0xe1, 0xd8, 0x35, 0xbb, 0x51, 0xd9, 0xfe, 0xdf, 0x34, 0x3b, 0xbf, 0xc8, 0xf0, 0xf9, - 0xc8, 0xba, 0x28, 0x1a, 0x17, 0x09, 0x74, 0x13, 0x2e, 0x25, 0xe4, 0x48, 0x7a, 0x53, 0x4e, 0xf7, - 0x4c, 0x41, 0x2e, 0xbb, 0x17, 0x32, 0xc8, 0xc4, 0x79, 0x9d, 0xa0, 0xfe, 0xe3, 0x02, 0xc0, 0x57, - 0xdd, 0xef, 0x88, 0xff, 0x66, 0xcc, 0xda, 0x86, 0x05, 0x55, 0x75, 0x8c, 0x6b, 0x56, 0xbd, 0x46, - 0x63, 0x00, 0x1c, 0x67, 0xa3, 0x3d, 0xc1, 0xc6, 0x4d, 0xa8, 0x30, 0x65, 0x92, 0x06, 0x14, 0x35, - 0x40, 0x8b, 0x14, 0x40, 0x53, 0xad, 0x74, 0x3a, 0xaa, 0x5d, 0x83, 0xff, 0x9c, 0x10, 0x9a, 0x79, - 0x15, 0x9a, 0xf3, 0xd1, 0x64, 0x58, 0xd0, 0x15, 0x58, 0xea, 0xe1, 0x7e, 0xc4, 0x70, 0xa0, 0x93, - 0xba, 0xa0, 0x92, 0x5a, 0x31, 0x32, 0x95, 0xd0, 0xd1, 0x9e, 0xb1, 0xf8, 0x46, 0x3d, 0xe3, 0x0a, - 0x2c, 0xf9, 0x2c, 0x91, 0x19, 0x51, 0x55, 0x1f, 0x28, 0x2b, 0x57, 0x2b, 0x46, 0x36, 0x49, 0x74, - 0x18, 0x23, 0xfa, 0x1d, 0x58, 0x36, 0x91, 0x32, 0x9c, 0xa9, 0x9c, 0xcc, 0x19, 0x9d, 0xe5, 0x01, - 0x67, 0x58, 0x6e, 0x85, 0x3e, 0x87, 0x55, 0x4e, 0x82, 0x34, 0x09, 0x70, 0xe2, 0xf7, 0xb5, 0x25, - 0x4b, 0x27, 0xfb, 0xe3, 0x0e, 0xa1, 0xca, 0x9f, 0x15, 0x3e, 0xb2, 0x1e, 0x6f, 0x6d, 0xcb, 0x67, - 0x6e, 0x6d, 0x2d, 0x28, 0xfb, 0x07, 0xc4, 0x7f, 0x28, 0xd2, 0x58, 0x38, 0x2b, 0x35, 0xbb, 0xb1, - 0xd4, 0x3e, 0xf7, 0xf7, 0xf1, 0xe6, 0xb2, 0xe4, 0x98, 0x4a, 0xf1, 0x71, 0x9d, 0xc5, 0x54, 0xd6, - 0xdd, 0x57, 0x98, 0x21, 0xe5, 0x57, 0xcf, 0x42, 0xf9, 0xac, 0xca, 0xa8, 0xf0, 0xd2, 0x5e, 0x80, - 0x25, 0x4d, 0x42, 0x67, 0xad, 0x66, 0x35, 0x16, 0x5d, 0xa0, 0xe2, 0xbe, 0x91, 0x64, 0xe4, 0x57, - 0xbb, 0x24, 0xc8, 0x42, 0x7f, 0x4e, 0x93, 0xdf, 0x48, 0x76, 0x24, 0xfa, 0xf0, 0xd5, 0x76, 0xb7, - 0xef, 0xa0, 0x19, 0xd5, 0x3f, 0x50, 0x6c, 0xf7, 0x91, 0x03, 0x0b, 0x87, 0x84, 0x0b, 0xca, 0x12, - 0xe7, 0xbc, 0x3a, 0x74, 0xb0, 0xac, 0xff, 0x5c, 0x80, 0xb2, 0xae, 0xc0, 0x37, 0xe1, 0xe2, 0x65, - 0x00, 0x5d, 0xda, 0xb9, 0x21, 0x57, 0x56, 0x12, 0x45, 0x9a, 0xb1, 0xbc, 0xd8, 0x67, 0xce, 0xcb, - 0x99, 0x06, 0xdc, 0x3a, 0x94, 0xc8, 0x91, 0xe4, 0x58, 0xb3, 0xd4, 0xd5, 0x8b, 0x61, 0xa6, 0xe6, - 0xcf, 0xd4, 0x9c, 0x6f, 0x42, 0x69, 0x2f, 0xcb, 0x7d, 0xe6, 0xa1, 0x2a, 0x02, 0xed, 0x81, 0xa5, - 0x3d, 0x54, 0x12, 0x65, 0xe0, 0x3a, 0x94, 0x0e, 0x71, 0x94, 0x0e, 0x7c, 0xd7, 0x8b, 0xfa, 0xef, - 0x16, 0xac, 0xe8, 0x96, 0x7e, 0x8f, 0x48, 0x7c, 0x1b, 0x4b, 0x8c, 0x6a, 0x50, 0x09, 0x88, 0xf0, - 0x39, 0xed, 0xc9, 0x2c, 0x0b, 0xfa, 0xa0, 0xbc, 0x28, 0x23, 0x26, 0x39, 0xd2, 0xe3, 0xc0, 0x4b, - 0x79, 0x64, 0x4e, 0xac, 0x0c, 0x64, 0xf7, 0x79, 0x34, 0xbb, 0x8d, 0xad, 0x43, 0x89, 0xc6, 0x38, - 0x1c, 0x34, 0x30, 0xbd, 0x40, 0xb7, 0x00, 0xb0, 0x94, 0x9c, 0x76, 0x53, 0x49, 0x84, 0x53, 0x52, - 0xdd, 0xff, 0xe2, 0xb4, 0x40, 0x28, 0x97, 0xdb, 0xc5, 0x2c, 0xd0, 0x6e, 0x4e, 0x45, 0xf9, 0xa3, - 0xb9, 0xfc, 0xd6, 0xfd, 0xc9, 0x77, 0x5d, 0x7b, 0xa2, 0xeb, 0xbe, 0x23, 0x7f, 0x7e, 0xb3, 0x60, - 0x59, 0x15, 0xfd, 0xdb, 0x75, 0x67, 0x94, 0x0d, 0xf6, 0x38, 0x1b, 0xde, 0x91, 0x33, 0xdb, 0x60, - 0x77, 0x02, 0x61, 0xa8, 0x62, 0xd5, 0xec, 0x53, 0x50, 0xa5, 0xfe, 0xab, 0x05, 0x70, 0x9b, 0x44, - 0x44, 0x12, 0x45, 0xfb, 0x1b, 0x60, 0x8a, 0xc8, 0xa3, 0x81, 0x50, 0xce, 0x57, 0xb6, 0x2f, 0x4c, - 0xb3, 0xa1, 0x13, 0x08, 0xb7, 0xac, 0xa1, 0xd9, 0x9d, 0x37, 0xc0, 0x24, 0x4b, 0xe9, 0x15, 0x66, - 0xe8, 0x69, 0x68, 0xa6, 0x77, 0x1d, 0xca, 0x83, 0x89, 0x28, 0x54, 0x9c, 0x5e, 0xa3, 0xb6, 0x18, - 0xea, 0xf9, 0x28, 0xea, 0xcf, 0x2d, 0x38, 0x7f, 0x8f, 0x86, 0x1c, 0x67, 0xf9, 0xc8, 0xbd, 0x98, - 0x36, 0xa0, 0x2c, 0xb8, 0xef, 0x09, 0x35, 0x60, 0x2d, 0x35, 0x60, 0x17, 0x04, 0xf7, 0x77, 0xb3, - 0xa1, 0xda, 0x81, 0x7a, 0xb6, 0x37, 0xe3, 0x5d, 0x59, 0x50, 0x4a, 0x97, 0x05, 0xf7, 0xef, 0x9e, - 0xfc, 0xb4, 0xdc, 0x80, 0x72, 0x20, 0xa4, 0xb9, 0xc6, 0xd6, 0xd7, 0x04, 0x42, 0xaa, 0x6b, 0x3e, - 0x82, 0xf2, 0x30, 0x80, 0xa7, 0x69, 0x57, 0x8b, 0x83, 0x18, 0xd6, 0x7f, 0x80, 0xa5, 0x7c, 0xfb, - 0x41, 0x9f, 0x98, 0x76, 0x65, 0xa9, 0x42, 0xf8, 0xef, 0xac, 0x76, 0xd5, 0xdc, 0xc3, 0xa1, 0xa9, - 0x09, 0xa5, 0xb7, 0xb1, 0x05, 0xf6, 0x1e, 0x0e, 0xd1, 0x1a, 0xd8, 0x0f, 0x49, 0xdf, 0xd4, 0x71, - 0xf6, 0x79, 0x42, 0xa7, 0xfa, 0xa5, 0x00, 0x6b, 0xbb, 0x07, 0x38, 0x60, 0x8f, 0x72, 0x2f, 0xb2, - 0xeb, 0xb0, 0xc8, 0x7a, 0x84, 0xab, 0x27, 0xd6, 0xac, 0x41, 0x30, 0x44, 0x9a, 0x02, 0x2c, 0x9c, - 0xae, 0x57, 0x8f, 0xbf, 0x42, 0xec, 0xc9, 0x57, 0xc8, 0xf8, 0x7b, 0xa8, 0x38, 0xf9, 0x1e, 0x1a, - 0x19, 0xdb, 0xa5, 0x53, 0x8c, 0xed, 0xd1, 0xf9, 0x3a, 0x3f, 0x3e, 0x5f, 0x73, 0x63, 0x72, 0x61, - 0x64, 0x4c, 0xb6, 0x3b, 0x4f, 0x5f, 0x54, 0xad, 0x67, 0x2f, 0xaa, 0xd6, 0x5f, 0x2f, 0xaa, 0xd6, - 0x4f, 0x2f, 0xab, 0x73, 0xcf, 0x5e, 0x56, 0xe7, 0xfe, 0x78, 0x59, 0x9d, 0xfb, 0xb6, 0x15, 0x52, - 0x79, 0x90, 0x76, 0x9b, 0x3e, 0x8b, 0x5b, 0xdd, 0xa4, 0xbb, 0xe5, 0x1f, 0x60, 0x9a, 0xb4, 0x72, - 0x7f, 0x97, 0x47, 0xa3, 0xff, 0xcb, 0xdd, 0x79, 0xf5, 0x7f, 0x79, 0xed, 0xdf, 0x00, 0x00, 0x00, - 0xff, 0xff, 0x69, 0x04, 0x1f, 0x0c, 0x52, 0x0f, 0x00, 0x00, + // 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, } func (m *BucketInfo) Marshal() (dAtA []byte, err error) { @@ -1284,6 +1297,16 @@ func (m *BucketInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.SpAsDelegatedAgentDisabled { + i-- + if m.SpAsDelegatedAgentDisabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + } if m.Tags != nil { { size, err := m.Tags.MarshalToSizedBuffer(dAtA[:i]) @@ -2216,6 +2239,9 @@ func (m *BucketInfo) Size() (n int) { l = m.Tags.Size() n += 1 + l + sovTypes(uint64(l)) } + if m.SpAsDelegatedAgentDisabled { + n += 2 + } return n } @@ -2895,6 +2921,26 @@ func (m *BucketInfo) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SpAsDelegatedAgentDisabled", 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.SpAsDelegatedAgentDisabled = bool(v != 0) default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:])