From 4ae8206714c84a4619a38e2e4f9e85ed0717243e Mon Sep 17 00:00:00 2001 From: Dheeraj Dubey Date: Wed, 21 Jun 2023 12:54:17 +0530 Subject: [PATCH 1/2] add icq --- app/app.go | 63 +- app/upgrades/mainnet/v12/constants.go | 15 + app/upgrades/mainnet/v12/upgrades.go | 29 + go.mod | 2 + go.sum | 4 + x/auction/v2types/auction.pb.go | 1513 +++++++++++++ x/auction/v2types/bid.pb.go | 2354 ++++++++++++++++++++ x/auction/v2types/genesis.pb.go | 320 +++ x/auction/v2types/gov.pb.go | 427 ++++ x/auction/v2types/params.pb.go | 263 +++ x/auction/v2types/query.pb.go | 530 +++++ x/auction/v2types/query.pb.gw.go | 153 ++ x/auction/v2types/tx.pb.go | 1968 +++++++++++++++++ x/liquidation/v2types/genesis.pb.go | 322 +++ x/liquidation/v2types/gov.pb.go | 407 ++++ x/liquidation/v2types/liquidate.pb.go | 2867 +++++++++++++++++++++++++ x/liquidation/v2types/params.pb.go | 302 +++ x/liquidation/v2types/query.pb.go | 530 +++++ x/liquidation/v2types/query.pb.gw.go | 153 ++ x/liquidation/v2types/tx.pb.go | 1598 ++++++++++++++ 20 files changed, 13799 insertions(+), 21 deletions(-) create mode 100644 app/upgrades/mainnet/v12/constants.go create mode 100644 app/upgrades/mainnet/v12/upgrades.go create mode 100644 x/auction/v2types/auction.pb.go create mode 100644 x/auction/v2types/bid.pb.go create mode 100644 x/auction/v2types/genesis.pb.go create mode 100644 x/auction/v2types/gov.pb.go create mode 100644 x/auction/v2types/params.pb.go create mode 100644 x/auction/v2types/query.pb.go create mode 100644 x/auction/v2types/query.pb.gw.go create mode 100644 x/auction/v2types/tx.pb.go create mode 100644 x/liquidation/v2types/genesis.pb.go create mode 100644 x/liquidation/v2types/gov.pb.go create mode 100644 x/liquidation/v2types/liquidate.pb.go create mode 100644 x/liquidation/v2types/params.pb.go create mode 100644 x/liquidation/v2types/query.pb.go create mode 100644 x/liquidation/v2types/query.pb.gw.go create mode 100644 x/liquidation/v2types/tx.pb.go diff --git a/app/app.go b/app/app.go index 65d08d77f..4128ed2dc 100644 --- a/app/app.go +++ b/app/app.go @@ -175,10 +175,13 @@ import ( liquiditykeeper "github.com/comdex-official/comdex/x/liquidity/keeper" liquiditytypes "github.com/comdex-official/comdex/x/liquidity/types" + icq "github.com/cosmos/ibc-apps/modules/async-icq/v4" + icqkeeper "github.com/cosmos/ibc-apps/modules/async-icq/v4/keeper" + icqtypes "github.com/cosmos/ibc-apps/modules/async-icq/v4/types" + cwasm "github.com/comdex-official/comdex/app/wasm" - mv11 "github.com/comdex-official/comdex/app/upgrades/mainnet/v11" - tv11_4 "github.com/comdex-official/comdex/app/upgrades/testnet/v11_4" + mv12 "github.com/comdex-official/comdex/app/upgrades/mainnet/v12" ) const ( @@ -339,6 +342,7 @@ type App struct { ScopedIBCOracleKeeper capabilitykeeper.ScopedKeeper ScopedBandoracleKeeper capabilitykeeper.ScopedKeeper ScopedICAHostKeeper capabilitykeeper.ScopedKeeper + ScopedICQKeeper capabilitykeeper.ScopedKeeper BandoracleKeeper bandoraclemodulekeeper.Keeper AssetKeeper assetkeeper.Keeper @@ -364,6 +368,7 @@ type App struct { Ics20WasmHooks *ibchooks.WasmHooks HooksICS4Wrapper ibchooks.ICS4Middleware PacketForwardKeeper *packetforwardkeeper.Keeper + ICQKeeper *icqkeeper.Keeper WasmKeeper wasm.Keeper ContractKeeper *wasmkeeper.PermissionedKeeper @@ -401,7 +406,7 @@ func New( markettypes.StoreKey, bandoraclemoduletypes.StoreKey, lockertypes.StoreKey, wasm.StoreKey, authzkeeper.StoreKey, auctiontypes.StoreKey, tokenminttypes.StoreKey, rewardstypes.StoreKey, feegrant.StoreKey, liquiditytypes.StoreKey, esmtypes.ModuleName, lendtypes.StoreKey, - ibchookstypes.StoreKey, packetforwardtypes.StoreKey, + ibchookstypes.StoreKey, icqtypes.StoreKey, packetforwardtypes.StoreKey, ) ) @@ -456,6 +461,7 @@ func New( app.ParamsKeeper.Subspace(liquiditytypes.ModuleName) app.ParamsKeeper.Subspace(rewardstypes.ModuleName) app.ParamsKeeper.Subspace(ibcratelimittypes.ModuleName) + app.ParamsKeeper.Subspace(icqtypes.ModuleName) app.ParamsKeeper.Subspace(packetforwardtypes.ModuleName).WithKeyTable(packetforwardtypes.ParamKeyTable()) // set the BaseApp's parameter store @@ -480,6 +486,7 @@ func New( scopedWasmKeeper = app.CapabilityKeeper.ScopeToModule(wasm.ModuleName) scopedICAHostKeeper = app.CapabilityKeeper.ScopeToModule(icahosttypes.SubModuleName) scopedBandoracleKeeper = app.CapabilityKeeper.ScopeToModule(bandoraclemoduletypes.ModuleName) + scopedICQKeeper = app.CapabilityKeeper.ScopeToModule(icqtypes.ModuleName) ) // add keepers @@ -758,6 +765,24 @@ func New( &app.LendKeeper, ) + // ICQ Keeper + icqKeeper := icqkeeper.NewKeeper( + appCodec, + app.keys[icqtypes.StoreKey], + app.GetSubspace(icqtypes.ModuleName), + app.IbcKeeper.ChannelKeeper, // may be replaced with middleware + app.IbcKeeper.ChannelKeeper, + &app.IbcKeeper.PortKeeper, + app.ScopedICQKeeper, + app.GRPCQueryRouter(), + ) + app.ICQKeeper = &icqKeeper + + // Create Async ICQ module + icqModule := icq.NewIBCModule(*app.ICQKeeper) + + // Note: the sealing is done after creating wasmd and wiring that up + wasmDir := filepath.Join(homePath, "wasm") wasmConfig, err := wasm.ReadWasmConfig(appOptions) if err != nil { @@ -833,6 +858,7 @@ func New( ibcRouter.AddRoute(bandoraclemoduletypes.ModuleName, bandOracleIBCModule) ibcRouter.AddRoute(wasm.ModuleName, wasm.NewIBCHandler(app.WasmKeeper, app.IbcKeeper.ChannelKeeper, app.IbcKeeper.ChannelKeeper)) ibcRouter.AddRoute(icahosttypes.SubModuleName, icaHostIBCModule) + ibcRouter.AddRoute(icqtypes.ModuleName, icqModule) app.IbcKeeper.SetRouter(ibcRouter) // Create evidence Keeper for to register the IBC light client misbehaviour evidence route app.EvidenceKeeper = *evidencekeeper.NewKeeper( @@ -887,6 +913,7 @@ func New( rewards.NewAppModule(app.cdc, app.Rewardskeeper, app.AccountKeeper, app.BankKeeper), ibcratelimitmodule.NewAppModule(*app.RateLimitingICS4Wrapper), ibchooks.NewAppModule(app.AccountKeeper), + icq.NewAppModule(*app.ICQKeeper), packetforward.NewAppModule(app.PacketForwardKeeper), ) @@ -930,6 +957,7 @@ func New( esmtypes.ModuleName, ibcratelimittypes.ModuleName, ibchookstypes.ModuleName, + icqtypes.ModuleName, packetforwardtypes.ModuleName, ) @@ -969,6 +997,7 @@ func New( esmtypes.ModuleName, ibcratelimittypes.ModuleName, ibchookstypes.ModuleName, + icqtypes.ModuleName, packetforwardtypes.ModuleName, ) @@ -1012,6 +1041,7 @@ func New( crisistypes.ModuleName, ibcratelimittypes.ModuleName, ibchookstypes.ModuleName, + icqtypes.ModuleName, packetforwardtypes.ModuleName, ) @@ -1082,6 +1112,7 @@ func New( app.ScopedIBCOracleKeeper = scopedIBCOracleKeeper app.ScopedICAHostKeeper = scopedICAHostKeeper app.ScopedBandoracleKeeper = scopedBandoracleKeeper + app.ScopedICQKeeper = scopedICQKeeper app.ScopedWasmKeeper = scopedWasmKeeper return app @@ -1338,6 +1369,7 @@ func (a *App) ModuleAccountsPermissions() map[string][]string { rewardstypes.ModuleName: {authtypes.Minter, authtypes.Burner}, icatypes.ModuleName: nil, assettypes.ModuleName: nil, + icqtypes.ModuleName: nil, } } @@ -1350,18 +1382,10 @@ func (a *App) registerUpgradeHandlers() { panic(err) } - switch { - case upgradeInfo.Name == tv11_4.UpgradeName: - a.UpgradeKeeper.SetUpgradeHandler( - tv11_4.UpgradeName, - tv11_4.CreateUpgradeHandlerV114(a.mm, a.configurator, a.AssetKeeper), - ) - case upgradeInfo.Name == mv11.UpgradeName: - a.UpgradeKeeper.SetUpgradeHandler( - mv11.UpgradeName, - mv11.CreateUpgradeHandlerV11(a.mm, a.configurator, a.LiquidityKeeper, a.AssetKeeper, a.BankKeeper, a.AccountKeeper, a.Rewardskeeper, a.ICAHostKeeper), - ) - } + a.UpgradeKeeper.SetUpgradeHandler( + mv12.UpgradeName, + mv12.CreateUpgradeHandlerV12(a.mm, a.configurator, a.ICQKeeper), + ) var storeUpgrades *storetypes.StoreUpgrades @@ -1375,13 +1399,10 @@ func (a *App) registerUpgradeHandlers() { func upgradeHandlers(upgradeInfo storetypes.UpgradeInfo, a *App, storeUpgrades *storetypes.StoreUpgrades) *storetypes.StoreUpgrades { switch { - case upgradeInfo.Name == tv11_4.UpgradeName && !a.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height): - storeUpgrades = &storetypes.StoreUpgrades{ - Added: []string{ibchookstypes.StoreKey, packetforwardtypes.StoreKey}, - } - case upgradeInfo.Name == mv11.UpgradeName && !a.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height): + + case upgradeInfo.Name == mv12.UpgradeName && !a.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height): storeUpgrades = &storetypes.StoreUpgrades{ - Added: []string{ibchookstypes.StoreKey, packetforwardtypes.StoreKey}, + Added: []string{icqtypes.StoreKey}, } } return storeUpgrades diff --git a/app/upgrades/mainnet/v12/constants.go b/app/upgrades/mainnet/v12/constants.go new file mode 100644 index 000000000..9ba6229ba --- /dev/null +++ b/app/upgrades/mainnet/v12/constants.go @@ -0,0 +1,15 @@ +package v12 + +const ( + UpgradeName = "v12.0.0" + UpgradeHeight = "" + UpgradeInfo = `'{ + "binaries": { + "darwin/arm64":"", + "darwin/x86_64":"", + "linux/arm64":"", + "linux/x86_64":"", + "windows/x86_64":"" + } + }'` +) diff --git a/app/upgrades/mainnet/v12/upgrades.go b/app/upgrades/mainnet/v12/upgrades.go new file mode 100644 index 000000000..c7fce2cfc --- /dev/null +++ b/app/upgrades/mainnet/v12/upgrades.go @@ -0,0 +1,29 @@ +package v12 + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/module" + upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types" + icqkeeper "github.com/cosmos/ibc-apps/modules/async-icq/v4/keeper" + icqtypes "github.com/cosmos/ibc-apps/modules/async-icq/v4/types" +) + +func CreateUpgradeHandlerV12( + mm *module.Manager, + configurator module.Configurator, + icqkeeper *icqkeeper.Keeper, +) upgradetypes.UpgradeHandler { + return func(ctx sdk.Context, _ upgradetypes.Plan, fromVM module.VersionMap) (module.VersionMap, error) { + ctx.Logger().Info("Applying main net upgrade - v.12.0.0") + + icqparams := icqtypes.DefaultParams() + icqparams.AllowQueries = append(icqparams.AllowQueries, "/cosmwasm.wasm.v1.Query/SmartContractState") + icqkeeper.SetParams(ctx, icqparams) + + vm, err := mm.RunMigrations(ctx, configurator, fromVM) + if err != nil { + return nil, err + } + return vm, err + } +} diff --git a/go.mod b/go.mod index 3ec8a1490..dc472050e 100644 --- a/go.mod +++ b/go.mod @@ -7,6 +7,7 @@ require ( github.com/CosmWasm/wasmvm v1.2.1 github.com/bandprotocol/bandchain-packet v0.0.3 github.com/cosmos/cosmos-sdk v0.46.11 + github.com/cosmos/ibc-apps/modules/async-icq/v4 v4.0.0-20230524151648-c02fa46c2860 github.com/gogo/protobuf v1.3.3 github.com/golang/protobuf v1.5.3 github.com/gorilla/mux v1.8.0 @@ -38,6 +39,7 @@ require ( require ( 4d63.com/gocheckcompilerdirectives v1.2.1 // indirect 4d63.com/gochecknoglobals v0.2.1 // indirect + cosmossdk.io/errors v1.0.0-beta.7 // indirect filippo.io/edwards25519 v1.0.0-rc.1 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect github.com/99designs/keyring v1.2.1 // indirect diff --git a/go.sum b/go.sum index a60917bd1..fbe2a8a67 100644 --- a/go.sum +++ b/go.sum @@ -198,6 +198,8 @@ contrib.go.opencensus.io/exporter/stackdriver v0.12.1/go.mod h1:iwB6wGarfphGGe/e contrib.go.opencensus.io/exporter/stackdriver v0.13.4/go.mod h1:aXENhDJ1Y4lIg4EUaVTwzvYETVNZk10Pu26tevFKLUc= contrib.go.opencensus.io/integrations/ocsql v0.1.4/go.mod h1:8DsSdjz3F+APR+0z0WkU1aRorQCFfRxvqjUUPMbF3fE= contrib.go.opencensus.io/resource v0.1.1/go.mod h1:F361eGI91LCmW1I/Saf+rX0+OFcigGlFvXwEGEnkRLA= +cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= +cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= filippo.io/edwards25519 v1.0.0-beta.2/go.mod h1:X+pm78QAUPtFLi1z9PYIlS/bdDnvbCOGKtZ+ACWEf7o= filippo.io/edwards25519 v1.0.0-rc.1 h1:m0VOOB23frXZvAOK44usCgLWvtsxIoMCTBGJZlpmGfU= @@ -767,6 +769,8 @@ github.com/cosmos/gorocksdb v1.2.0/go.mod h1:aaKvKItm514hKfNJpUJXnnOWeBnk2GL4+Qw github.com/cosmos/iavl v0.19.3/go.mod h1:X9PKD3J0iFxdmgNLa7b2LYWdsGd90ToV5cAONApkEPw= github.com/cosmos/iavl v0.19.4 h1:t82sN+Y0WeqxDLJRSpNd8YFX5URIrT+p8n6oJbJ2Dok= github.com/cosmos/iavl v0.19.4/go.mod h1:X9PKD3J0iFxdmgNLa7b2LYWdsGd90ToV5cAONApkEPw= +github.com/cosmos/ibc-apps/modules/async-icq/v4 v4.0.0-20230524151648-c02fa46c2860 h1:25/KpA4WJqdFjKFsa3VEL0ctWRovkEsqIn2phCAi9v0= +github.com/cosmos/ibc-apps/modules/async-icq/v4 v4.0.0-20230524151648-c02fa46c2860/go.mod h1:X/dLZ6QxTImzno7qvD6huLhh6ZZBcRt2URn4YCLcXFY= github.com/cosmos/ibc-go v1.0.0/go.mod h1:2wHKQUa+BLJMEyN635KrHfmTTwSNHBtXcqdY8JWGuXA= github.com/cosmos/ibc-go/v4 v4.4.2 h1:PG4Yy0/bw6Hvmha3RZbc53KYzaCwuB07Ot4GLyzcBvo= github.com/cosmos/ibc-go/v4 v4.4.2/go.mod h1:j/kD2JCIaV5ozvJvaEkWhLxM2zva7/KTM++EtKFYcB8= diff --git a/x/auction/v2types/auction.pb.go b/x/auction/v2types/auction.pb.go new file mode 100644 index 000000000..a7d9a9dc1 --- /dev/null +++ b/x/auction/v2types/auction.pb.go @@ -0,0 +1,1513 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/auction/v2/auction.proto + +package v2types + +import ( + fmt "fmt" + v2types "github.com/comdex-official/comdex/x/liquidation/v2types" + _ "github.com/cosmos/cosmos-sdk/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type AuctionHistorical struct { + AuctionId uint64 `protobuf:"varint,1,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty" yaml:"auction_id"` + AuctionHistorical *Auction `protobuf:"bytes,2,opt,name=auction_historical,json=auctionHistorical,proto3" json:"auction_historical,omitempty" yaml:"auction_historical"` + LockedVault *v2types.LockedVault `protobuf:"bytes,3,opt,name=locked_vault,json=lockedVault,proto3" json:"locked_vault,omitempty" yaml:"locked_vault"` +} + +func (m *AuctionHistorical) Reset() { *m = AuctionHistorical{} } +func (m *AuctionHistorical) String() string { return proto.CompactTextString(m) } +func (*AuctionHistorical) ProtoMessage() {} +func (*AuctionHistorical) Descriptor() ([]byte, []int) { + return fileDescriptor_18605748e24be228, []int{0} +} +func (m *AuctionHistorical) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AuctionHistorical) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AuctionHistorical.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 *AuctionHistorical) XXX_Merge(src proto.Message) { + xxx_messageInfo_AuctionHistorical.Merge(m, src) +} +func (m *AuctionHistorical) XXX_Size() int { + return m.Size() +} +func (m *AuctionHistorical) XXX_DiscardUnknown() { + xxx_messageInfo_AuctionHistorical.DiscardUnknown(m) +} + +var xxx_messageInfo_AuctionHistorical proto.InternalMessageInfo + +func (m *AuctionHistorical) GetAuctionId() uint64 { + if m != nil { + return m.AuctionId + } + return 0 +} + +func (m *AuctionHistorical) GetAuctionHistorical() *Auction { + if m != nil { + return m.AuctionHistorical + } + return nil +} + +func (m *AuctionHistorical) GetLockedVault() *v2types.LockedVault { + if m != nil { + return m.LockedVault + } + return nil +} + +type Auction struct { + AuctionId uint64 `protobuf:"varint,1,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty" yaml:"auction_id"` + CollateralToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,2,opt,name=collateral_token,json=collateralToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_token" yaml:"collateral_token"` + DebtToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=debt_token,json=debtToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token" yaml:"inflow_token_target_amount"` + ActiveBiddingId uint64 `protobuf:"varint,4,opt,name=active_bidding_id,json=activeBiddingId,proto3" json:"active_bidding_id,omitempty" yaml:"active_bidding_id"` + BiddingIds []*BidOwnerMapping `protobuf:"bytes,5,rep,name=bidding_ids,json=biddingIds,proto3" json:"bidding_ids,omitempty" yaml:"bidding_ids"` + // price indicator only for dutch auctions + CollateralTokenAuctionPrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=collateral_token_auction_price,json=collateralTokenAuctionPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"collateral_token_auction_price" yaml:"outflow_token_auction_price"` + CollateralTokenOraclePrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=collateral_token_oracle_price,json=collateralTokenOraclePrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"collateral_token_oracle_price" yaml:"outflow_token_oracle_price"` + DebtTokenOraclePrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,9,opt,name=debt_token_oracle_price,json=debtTokenOraclePrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"debt_token_oracle_price" yaml:"inflow_token_oracle_price"` + LockedVaultId uint64 `protobuf:"varint,10,opt,name=locked_vault_id,json=lockedVaultId,proto3" json:"locked_vault_id,omitempty" yaml:"locked_vault_id"` + StartTime time.Time `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time" yaml:"start_time"` + EndTime time.Time `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time" yaml:"end_time"` + AppId uint64 `protobuf:"varint,13,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` + AuctionType bool `protobuf:"varint,14,opt,name=auction_type,json=auctionType,proto3" json:"auction_type,omitempty" yaml:"auction_type"` + CollateralAssetId uint64 `protobuf:"varint,15,opt,name=collateral_asset_id,json=collateralAssetId,proto3" json:"collateral_asset_id,omitempty" yaml:"collateral_asset_id"` + DebtAssetId uint64 `protobuf:"varint,16,opt,name=debt_asset_id,json=debtAssetId,proto3" json:"debt_asset_id,omitempty" yaml:"debt_asset_id"` + BonusAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,17,opt,name=bonus_amount,json=bonusAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonus_amount" yaml:"bonus_amount"` +} + +func (m *Auction) Reset() { *m = Auction{} } +func (m *Auction) String() string { return proto.CompactTextString(m) } +func (*Auction) ProtoMessage() {} +func (*Auction) Descriptor() ([]byte, []int) { + return fileDescriptor_18605748e24be228, []int{1} +} +func (m *Auction) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Auction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Auction.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 *Auction) XXX_Merge(src proto.Message) { + xxx_messageInfo_Auction.Merge(m, src) +} +func (m *Auction) XXX_Size() int { + return m.Size() +} +func (m *Auction) XXX_DiscardUnknown() { + xxx_messageInfo_Auction.DiscardUnknown(m) +} + +var xxx_messageInfo_Auction proto.InternalMessageInfo + +func (m *Auction) GetAuctionId() uint64 { + if m != nil { + return m.AuctionId + } + return 0 +} + +func (m *Auction) GetCollateralToken() github_com_cosmos_cosmos_sdk_types.Coin { + if m != nil { + return m.CollateralToken + } + return github_com_cosmos_cosmos_sdk_types.Coin{} +} + +func (m *Auction) GetDebtToken() github_com_cosmos_cosmos_sdk_types.Coin { + if m != nil { + return m.DebtToken + } + return github_com_cosmos_cosmos_sdk_types.Coin{} +} + +func (m *Auction) GetActiveBiddingId() uint64 { + if m != nil { + return m.ActiveBiddingId + } + return 0 +} + +func (m *Auction) GetBiddingIds() []*BidOwnerMapping { + if m != nil { + return m.BiddingIds + } + return nil +} + +func (m *Auction) GetLockedVaultId() uint64 { + if m != nil { + return m.LockedVaultId + } + return 0 +} + +func (m *Auction) GetStartTime() time.Time { + if m != nil { + return m.StartTime + } + return time.Time{} +} + +func (m *Auction) GetEndTime() time.Time { + if m != nil { + return m.EndTime + } + return time.Time{} +} + +func (m *Auction) GetAppId() uint64 { + if m != nil { + return m.AppId + } + return 0 +} + +func (m *Auction) GetAuctionType() bool { + if m != nil { + return m.AuctionType + } + return false +} + +func (m *Auction) GetCollateralAssetId() uint64 { + if m != nil { + return m.CollateralAssetId + } + return 0 +} + +func (m *Auction) GetDebtAssetId() uint64 { + if m != nil { + return m.DebtAssetId + } + return 0 +} + +type BidOwnerMapping struct { + BidId uint64 `protobuf:"varint,1,opt,name=bid_id,json=bidId,proto3" json:"bid_id,omitempty"` + BidOwner string `protobuf:"bytes,2,opt,name=bid_owner,json=bidOwner,proto3" json:"bid_owner,omitempty"` +} + +func (m *BidOwnerMapping) Reset() { *m = BidOwnerMapping{} } +func (m *BidOwnerMapping) String() string { return proto.CompactTextString(m) } +func (*BidOwnerMapping) ProtoMessage() {} +func (*BidOwnerMapping) Descriptor() ([]byte, []int) { + return fileDescriptor_18605748e24be228, []int{2} +} +func (m *BidOwnerMapping) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BidOwnerMapping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BidOwnerMapping.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 *BidOwnerMapping) XXX_Merge(src proto.Message) { + xxx_messageInfo_BidOwnerMapping.Merge(m, src) +} +func (m *BidOwnerMapping) XXX_Size() int { + return m.Size() +} +func (m *BidOwnerMapping) XXX_DiscardUnknown() { + xxx_messageInfo_BidOwnerMapping.DiscardUnknown(m) +} + +var xxx_messageInfo_BidOwnerMapping proto.InternalMessageInfo + +func (m *BidOwnerMapping) GetBidId() uint64 { + if m != nil { + return m.BidId + } + return 0 +} + +func (m *BidOwnerMapping) GetBidOwner() string { + if m != nil { + return m.BidOwner + } + return "" +} + +func init() { + proto.RegisterType((*AuctionHistorical)(nil), "comdex.auction.v2.AuctionHistorical") + proto.RegisterType((*Auction)(nil), "comdex.auction.v2.Auction") + proto.RegisterType((*BidOwnerMapping)(nil), "comdex.auction.v2.bidOwnerMapping") +} + +func init() { proto.RegisterFile("comdex/auction/v2/auction.proto", fileDescriptor_18605748e24be228) } + +var fileDescriptor_18605748e24be228 = []byte{ + // 939 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcb, 0x6e, 0xdb, 0x46, + 0x17, 0x36, 0xe3, 0xf8, 0xa2, 0x91, 0xfc, 0x2b, 0x62, 0x9c, 0x98, 0x91, 0x7f, 0x8b, 0xca, 0x00, + 0x4d, 0xb5, 0x09, 0x89, 0x38, 0x5d, 0x15, 0xdd, 0x98, 0x6d, 0x80, 0xa8, 0x68, 0x9a, 0x62, 0x6a, + 0x14, 0x45, 0x0b, 0x54, 0x18, 0x72, 0xc6, 0xf2, 0xc0, 0x14, 0x87, 0x15, 0x47, 0x4a, 0xfd, 0x08, + 0xdd, 0x14, 0x06, 0x0a, 0x14, 0xe8, 0x2b, 0xf4, 0x49, 0xb2, 0xcc, 0xb2, 0xe8, 0x82, 0x2d, 0xec, + 0x37, 0xe0, 0xb2, 0xab, 0x62, 0x2e, 0x34, 0x29, 0x29, 0x40, 0xea, 0xae, 0xc4, 0x73, 0xfb, 0xce, + 0x37, 0x67, 0x3e, 0x1e, 0x0a, 0xb8, 0x11, 0x9f, 0x10, 0xfa, 0x83, 0x8f, 0x67, 0x91, 0x60, 0x3c, + 0xf1, 0xe7, 0x87, 0xe5, 0xa3, 0x97, 0x4e, 0xb9, 0xe0, 0x76, 0x47, 0x27, 0x78, 0xa5, 0x77, 0x7e, + 0xd8, 0xdd, 0x1d, 0xf3, 0x31, 0x57, 0x51, 0x5f, 0x3e, 0xe9, 0xc4, 0xae, 0x3b, 0xe6, 0x7c, 0x1c, + 0x53, 0x5f, 0x59, 0xe1, 0xec, 0xc4, 0x17, 0x6c, 0x42, 0x33, 0x81, 0x27, 0xa9, 0x49, 0xe8, 0x45, + 0x3c, 0x9b, 0xf0, 0xcc, 0x0f, 0x71, 0x46, 0xfd, 0xf9, 0x93, 0x90, 0x0a, 0xfc, 0xc4, 0x8f, 0x38, + 0x33, 0x9d, 0xba, 0xef, 0x19, 0x2a, 0x31, 0xfb, 0x7e, 0xc6, 0x08, 0x2e, 0xe9, 0x94, 0x26, 0xd5, + 0x69, 0xf0, 0xe7, 0x5b, 0xa0, 0x73, 0xa4, 0xc9, 0x3c, 0x67, 0x99, 0xe0, 0x53, 0x16, 0xe1, 0xd8, + 0xfe, 0x00, 0x00, 0xc3, 0x70, 0xc4, 0x88, 0x63, 0xf5, 0xad, 0xc1, 0xed, 0xe0, 0x5e, 0x91, 0xbb, + 0x9d, 0x73, 0x3c, 0x89, 0x3f, 0x84, 0x55, 0x0c, 0xa2, 0x86, 0x31, 0x86, 0xc4, 0x3e, 0x05, 0x76, + 0x19, 0x39, 0xbd, 0xc6, 0x72, 0x6e, 0xf5, 0xad, 0x41, 0xf3, 0xb0, 0xeb, 0xad, 0x9c, 0xdc, 0x33, + 0x7d, 0x83, 0x83, 0x22, 0x77, 0x1f, 0x2c, 0x22, 0x57, 0xf5, 0x10, 0x75, 0xf0, 0x0a, 0xbf, 0xef, + 0x40, 0x2b, 0xe6, 0xd1, 0x19, 0x25, 0xa3, 0x39, 0x9e, 0xc5, 0xc2, 0x59, 0x57, 0x3d, 0x60, 0xd9, + 0xa3, 0x76, 0x66, 0xd9, 0xe7, 0x33, 0x95, 0xfa, 0x95, 0xcc, 0x0c, 0xf6, 0x8a, 0xdc, 0xbd, 0xab, + 0x7b, 0xd5, 0x11, 0x20, 0x6a, 0xc6, 0x55, 0x16, 0xfc, 0xad, 0x05, 0xb6, 0x0c, 0xbb, 0xff, 0x38, + 0x8b, 0x0b, 0x0b, 0xdc, 0x89, 0x78, 0x1c, 0x63, 0x41, 0xa7, 0x38, 0x1e, 0x09, 0x7e, 0x46, 0x13, + 0x33, 0x8a, 0x07, 0x9e, 0xbe, 0x3a, 0x4f, 0x5e, 0x9d, 0x67, 0xae, 0xce, 0xfb, 0x98, 0xb3, 0x24, + 0xf8, 0xf4, 0x75, 0xee, 0xae, 0x15, 0xb9, 0xbb, 0xa7, 0xb1, 0x97, 0x01, 0xe0, 0xdf, 0xb9, 0xfb, + 0xfe, 0x98, 0x89, 0xd3, 0x59, 0x28, 0x8f, 0xea, 0x1b, 0x09, 0xe8, 0x9f, 0xc7, 0x19, 0x39, 0xf3, + 0xc5, 0x79, 0x4a, 0x33, 0x85, 0x85, 0xda, 0x55, 0xf5, 0xb1, 0x2c, 0xb6, 0x7f, 0xb2, 0x00, 0x20, + 0x34, 0x14, 0x86, 0xcc, 0xfa, 0xbb, 0xc8, 0x1c, 0x1b, 0x32, 0x0f, 0x35, 0x19, 0x96, 0x9c, 0xc4, + 0xfc, 0x95, 0x2e, 0x1e, 0x09, 0x3c, 0x1d, 0x53, 0x31, 0xc2, 0x13, 0x3e, 0x4b, 0xc4, 0x8d, 0x68, + 0x35, 0x24, 0x05, 0x4d, 0xe8, 0x39, 0xe8, 0xe0, 0x48, 0xb0, 0x39, 0x1d, 0x85, 0x8c, 0x10, 0x96, + 0x8c, 0xe5, 0x80, 0x6f, 0xab, 0x01, 0xff, 0xbf, 0xc8, 0x5d, 0xc7, 0x0c, 0x78, 0x39, 0x05, 0xa2, + 0xb6, 0xf6, 0x05, 0xda, 0x35, 0x24, 0xf6, 0xb7, 0xa0, 0x59, 0xc5, 0x33, 0x67, 0xa3, 0xbf, 0x5e, + 0x97, 0x43, 0x4d, 0x72, 0x21, 0x23, 0x2f, 0x5f, 0x25, 0x74, 0xfa, 0x02, 0xa7, 0x29, 0x4b, 0xc6, + 0xc1, 0xfd, 0x22, 0x77, 0x6d, 0xdd, 0xa7, 0x06, 0x00, 0x11, 0x08, 0x4b, 0xec, 0xcc, 0xfe, 0xd5, + 0x02, 0xbd, 0xe5, 0x9b, 0x18, 0x95, 0xd7, 0x9e, 0x4e, 0x59, 0x44, 0x9d, 0xad, 0xbe, 0x35, 0x68, + 0xe8, 0x81, 0xfd, 0x91, 0xbb, 0x8f, 0xfe, 0xc5, 0x2c, 0x3e, 0xa1, 0x51, 0x91, 0xbb, 0x50, 0xb7, + 0xe6, 0x33, 0x51, 0x9b, 0xed, 0x02, 0x34, 0x44, 0xfb, 0x4b, 0xf7, 0x68, 0x74, 0xf9, 0x85, 0x8c, + 0xda, 0xbf, 0x58, 0xe0, 0x60, 0x85, 0x1b, 0x9f, 0xe2, 0x28, 0xa6, 0x86, 0xda, 0xb6, 0xa2, 0xf6, + 0xe5, 0x8d, 0xa9, 0x3d, 0x7c, 0x1b, 0xb5, 0x3a, 0x32, 0x44, 0xdd, 0x25, 0x66, 0x2f, 0x55, 0x54, + 0x13, 0xfb, 0xd1, 0x02, 0x7b, 0x95, 0xd8, 0x16, 0x29, 0x35, 0x14, 0x25, 0x74, 0x63, 0x4a, 0xfd, + 0xb7, 0x08, 0x71, 0x91, 0xd1, 0xee, 0xb5, 0xb8, 0xea, 0x5c, 0x02, 0xd0, 0xae, 0xbf, 0xeb, 0x52, + 0x65, 0x40, 0xa9, 0xac, 0x5b, 0xe4, 0xee, 0xfd, 0xd5, 0x65, 0xa0, 0x34, 0xb6, 0x53, 0xdb, 0x07, + 0x43, 0x62, 0x7f, 0x0d, 0x40, 0x26, 0xf0, 0x54, 0x8c, 0xe4, 0x1e, 0x76, 0x9a, 0x66, 0xa7, 0xe9, + 0x25, 0xed, 0x95, 0x4b, 0xda, 0x3b, 0x2e, 0x97, 0x74, 0x70, 0x60, 0x5e, 0x1e, 0xb3, 0x25, 0xaa, + 0x5a, 0x78, 0xf1, 0xa7, 0x6b, 0xa1, 0x86, 0x72, 0xc8, 0x74, 0x1b, 0x81, 0x6d, 0x9a, 0x10, 0x8d, + 0xdb, 0x7a, 0x27, 0xee, 0xbe, 0xc1, 0x6d, 0x6b, 0xdc, 0xb2, 0x52, 0xa3, 0x6e, 0xd1, 0x84, 0x28, + 0xcc, 0x01, 0xd8, 0xc4, 0x69, 0x2a, 0x0f, 0xba, 0xa3, 0x0e, 0xda, 0x29, 0x72, 0x77, 0xc7, 0xbc, + 0x4e, 0xca, 0x0f, 0xd1, 0x06, 0x4e, 0xd3, 0x21, 0xb1, 0x87, 0xa0, 0x55, 0xea, 0x4d, 0x8e, 0xda, + 0xf9, 0x5f, 0xdf, 0x1a, 0x6c, 0x07, 0x8f, 0x2e, 0x73, 0xb7, 0x69, 0x84, 0x76, 0x7c, 0x9e, 0xd2, + 0x6a, 0x69, 0xd6, 0x93, 0x21, 0x6a, 0xe2, 0x2a, 0xc7, 0xfe, 0x1c, 0xdc, 0xad, 0x49, 0x11, 0x67, + 0x19, 0x55, 0xa3, 0x6e, 0x2b, 0x06, 0xbd, 0x22, 0x77, 0xbb, 0x2b, 0x5b, 0xad, 0x4c, 0x82, 0xa8, + 0x53, 0x79, 0x8f, 0xa4, 0x73, 0x48, 0xec, 0x8f, 0xc0, 0x8e, 0x52, 0xd0, 0x35, 0xd2, 0x1d, 0x85, + 0xe4, 0x14, 0xb9, 0xbb, 0xab, 0x91, 0x16, 0xc2, 0x10, 0x35, 0xa5, 0x5d, 0x56, 0x9f, 0x82, 0x56, + 0xc8, 0x93, 0x59, 0x66, 0x76, 0x94, 0xd3, 0x51, 0xa2, 0x7b, 0x76, 0x03, 0xd1, 0x0d, 0x13, 0x51, + 0x9d, 0xbb, 0x8e, 0x05, 0x51, 0x53, 0x99, 0x47, 0xda, 0x7a, 0x06, 0xda, 0x4b, 0x6b, 0xc5, 0xbe, + 0x07, 0x36, 0x43, 0x46, 0xae, 0xbf, 0x17, 0x68, 0x23, 0x64, 0x64, 0x48, 0xec, 0x7d, 0xd0, 0x90, + 0x6e, 0x2e, 0x53, 0xd5, 0xc7, 0xa0, 0x81, 0xb6, 0xcb, 0xd2, 0xe0, 0xc5, 0xeb, 0xcb, 0x9e, 0xf5, + 0xe6, 0xb2, 0x67, 0xfd, 0x75, 0xd9, 0xb3, 0x2e, 0xae, 0x7a, 0x6b, 0x6f, 0xae, 0x7a, 0x6b, 0xbf, + 0x5f, 0xf5, 0xd6, 0xbe, 0x79, 0xba, 0x40, 0x56, 0xae, 0xb4, 0xc7, 0xfc, 0xe4, 0x84, 0x45, 0x0c, + 0xc7, 0xc6, 0xf6, 0xeb, 0x7f, 0x39, 0x14, 0xfb, 0x70, 0x53, 0x89, 0xe7, 0xe9, 0x3f, 0x01, 0x00, + 0x00, 0xff, 0xff, 0xd6, 0xaa, 0xe3, 0xd9, 0x93, 0x08, 0x00, 0x00, +} + +func (m *AuctionHistorical) 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 *AuctionHistorical) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AuctionHistorical) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.LockedVault != nil { + { + size, err := m.LockedVault.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.AuctionHistorical != nil { + { + size, err := m.AuctionHistorical.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.AuctionId != 0 { + i = encodeVarintAuction(dAtA, i, uint64(m.AuctionId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *Auction) 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 *Auction) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Auction) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.BonusAmount.Size() + i -= size + if _, err := m.BonusAmount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + if m.DebtAssetId != 0 { + i = encodeVarintAuction(dAtA, i, uint64(m.DebtAssetId)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x80 + } + if m.CollateralAssetId != 0 { + i = encodeVarintAuction(dAtA, i, uint64(m.CollateralAssetId)) + i-- + dAtA[i] = 0x78 + } + if m.AuctionType { + i-- + if m.AuctionType { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x70 + } + if m.AppId != 0 { + i = encodeVarintAuction(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x68 + } + n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) + if err3 != nil { + return 0, err3 + } + i -= n3 + i = encodeVarintAuction(dAtA, i, uint64(n3)) + i-- + dAtA[i] = 0x62 + n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) + if err4 != nil { + return 0, err4 + } + i -= n4 + i = encodeVarintAuction(dAtA, i, uint64(n4)) + i-- + dAtA[i] = 0x5a + if m.LockedVaultId != 0 { + i = encodeVarintAuction(dAtA, i, uint64(m.LockedVaultId)) + i-- + dAtA[i] = 0x50 + } + { + size := m.DebtTokenOraclePrice.Size() + i -= size + if _, err := m.DebtTokenOraclePrice.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + { + size := m.CollateralTokenOraclePrice.Size() + i -= size + if _, err := m.CollateralTokenOraclePrice.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + { + size := m.CollateralTokenAuctionPrice.Size() + i -= size + if _, err := m.CollateralTokenAuctionPrice.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + if len(m.BiddingIds) > 0 { + for iNdEx := len(m.BiddingIds) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.BiddingIds[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + } + if m.ActiveBiddingId != 0 { + i = encodeVarintAuction(dAtA, i, uint64(m.ActiveBiddingId)) + i-- + dAtA[i] = 0x20 + } + { + size, err := m.DebtToken.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size, err := m.CollateralToken.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintAuction(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if m.AuctionId != 0 { + i = encodeVarintAuction(dAtA, i, uint64(m.AuctionId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *BidOwnerMapping) 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 *BidOwnerMapping) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BidOwnerMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.BidOwner) > 0 { + i -= len(m.BidOwner) + copy(dAtA[i:], m.BidOwner) + i = encodeVarintAuction(dAtA, i, uint64(len(m.BidOwner))) + i-- + dAtA[i] = 0x12 + } + if m.BidId != 0 { + i = encodeVarintAuction(dAtA, i, uint64(m.BidId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintAuction(dAtA []byte, offset int, v uint64) int { + offset -= sovAuction(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *AuctionHistorical) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AuctionId != 0 { + n += 1 + sovAuction(uint64(m.AuctionId)) + } + if m.AuctionHistorical != nil { + l = m.AuctionHistorical.Size() + n += 1 + l + sovAuction(uint64(l)) + } + if m.LockedVault != nil { + l = m.LockedVault.Size() + n += 1 + l + sovAuction(uint64(l)) + } + return n +} + +func (m *Auction) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AuctionId != 0 { + n += 1 + sovAuction(uint64(m.AuctionId)) + } + l = m.CollateralToken.Size() + n += 1 + l + sovAuction(uint64(l)) + l = m.DebtToken.Size() + n += 1 + l + sovAuction(uint64(l)) + if m.ActiveBiddingId != 0 { + n += 1 + sovAuction(uint64(m.ActiveBiddingId)) + } + if len(m.BiddingIds) > 0 { + for _, e := range m.BiddingIds { + l = e.Size() + n += 1 + l + sovAuction(uint64(l)) + } + } + l = m.CollateralTokenAuctionPrice.Size() + n += 1 + l + sovAuction(uint64(l)) + l = m.CollateralTokenOraclePrice.Size() + n += 1 + l + sovAuction(uint64(l)) + l = m.DebtTokenOraclePrice.Size() + n += 1 + l + sovAuction(uint64(l)) + if m.LockedVaultId != 0 { + n += 1 + sovAuction(uint64(m.LockedVaultId)) + } + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) + n += 1 + l + sovAuction(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) + n += 1 + l + sovAuction(uint64(l)) + if m.AppId != 0 { + n += 1 + sovAuction(uint64(m.AppId)) + } + if m.AuctionType { + n += 2 + } + if m.CollateralAssetId != 0 { + n += 1 + sovAuction(uint64(m.CollateralAssetId)) + } + if m.DebtAssetId != 0 { + n += 2 + sovAuction(uint64(m.DebtAssetId)) + } + l = m.BonusAmount.Size() + n += 2 + l + sovAuction(uint64(l)) + return n +} + +func (m *BidOwnerMapping) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BidId != 0 { + n += 1 + sovAuction(uint64(m.BidId)) + } + l = len(m.BidOwner) + if l > 0 { + n += 1 + l + sovAuction(uint64(l)) + } + return n +} + +func sovAuction(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozAuction(x uint64) (n int) { + return sovAuction(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *AuctionHistorical) 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 ErrIntOverflowAuction + } + 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: AuctionHistorical: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuctionHistorical: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType) + } + m.AuctionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AuctionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionHistorical", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.AuctionHistorical == nil { + m.AuctionHistorical = &Auction{} + } + if err := m.AuctionHistorical.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LockedVault", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.LockedVault == nil { + m.LockedVault = &v2types.LockedVault{} + } + if err := m.LockedVault.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuction(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAuction + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Auction) 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 ErrIntOverflowAuction + } + 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: Auction: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Auction: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType) + } + m.AuctionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AuctionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralToken", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CollateralToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtToken", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DebtToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ActiveBiddingId", wireType) + } + m.ActiveBiddingId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ActiveBiddingId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BiddingIds", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BiddingIds = append(m.BiddingIds, &BidOwnerMapping{}) + if err := m.BiddingIds[len(m.BiddingIds)-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 CollateralTokenAuctionPrice", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + 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 ErrInvalidLengthAuction + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CollateralTokenAuctionPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenOraclePrice", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + 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 ErrInvalidLengthAuction + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CollateralTokenOraclePrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenOraclePrice", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + 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 ErrInvalidLengthAuction + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DebtTokenOraclePrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LockedVaultId", wireType) + } + m.LockedVaultId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LockedVaultId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthAuction + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionType", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AuctionType = bool(v != 0) + case 15: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralAssetId", wireType) + } + m.CollateralAssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CollateralAssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 16: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtAssetId", wireType) + } + m.DebtAssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebtAssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BonusAmount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + 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 ErrInvalidLengthAuction + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.BonusAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuction(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAuction + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *BidOwnerMapping) 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 ErrIntOverflowAuction + } + 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: bidOwnerMapping: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: bidOwnerMapping: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BidId", wireType) + } + m.BidId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BidId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BidOwner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowAuction + } + 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 ErrInvalidLengthAuction + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthAuction + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BidOwner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipAuction(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthAuction + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipAuction(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowAuction + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowAuction + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowAuction + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthAuction + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupAuction + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthAuction + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthAuction = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowAuction = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupAuction = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/auction/v2types/bid.pb.go b/x/auction/v2types/bid.pb.go new file mode 100644 index 000000000..aa505654f --- /dev/null +++ b/x/auction/v2types/bid.pb.go @@ -0,0 +1,2354 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/auction/v2/bid.proto + +package v2types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-sdk/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Bid struct { + BiddingId uint64 `protobuf:"varint,1,opt,name=bidding_id,json=biddingId,proto3" json:"bidding_id,omitempty" yaml:"bidding_id"` + AuctionId uint64 `protobuf:"varint,2,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty" yaml:"auction_id"` + CollateralTokenAmount github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=collateral_token_amount,json=collateralTokenAmount,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_token_amount" yaml:"outflow_token_amount"` + DebtTokenAmount github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,4,opt,name=debt_token_amount,json=debtTokenAmount,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token_amount" yaml:"inflow_token_amount"` + BidderAddress string `protobuf:"bytes,5,opt,name=bidder_address,json=bidderAddress,proto3" json:"bidder_address,omitempty" yaml:"bidder"` + BiddingTimestamp time.Time `protobuf:"bytes,6,opt,name=bidding_timestamp,json=biddingTimestamp,proto3,stdtime" json:"bidding_timestamp" yaml:"bidding_timestamp"` + AppId uint64 `protobuf:"varint,7,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` + BidType string `protobuf:"bytes,8,opt,name=bid_type,json=bidType,proto3" json:"bid_type,omitempty" yaml:"bid_type"` +} + +func (m *Bid) Reset() { *m = Bid{} } +func (m *Bid) String() string { return proto.CompactTextString(m) } +func (*Bid) ProtoMessage() {} +func (*Bid) Descriptor() ([]byte, []int) { + return fileDescriptor_627413fbf33ef9e3, []int{0} +} +func (m *Bid) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Bid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Bid.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 *Bid) XXX_Merge(src proto.Message) { + xxx_messageInfo_Bid.Merge(m, src) +} +func (m *Bid) XXX_Size() int { + return m.Size() +} +func (m *Bid) XXX_DiscardUnknown() { + xxx_messageInfo_Bid.DiscardUnknown(m) +} + +var xxx_messageInfo_Bid proto.InternalMessageInfo + +func (m *Bid) GetBiddingId() uint64 { + if m != nil { + return m.BiddingId + } + return 0 +} + +func (m *Bid) GetAuctionId() uint64 { + if m != nil { + return m.AuctionId + } + return 0 +} + +func (m *Bid) GetCollateralTokenAmount() github_com_cosmos_cosmos_sdk_types.Coin { + if m != nil { + return m.CollateralTokenAmount + } + return github_com_cosmos_cosmos_sdk_types.Coin{} +} + +func (m *Bid) GetDebtTokenAmount() github_com_cosmos_cosmos_sdk_types.Coin { + if m != nil { + return m.DebtTokenAmount + } + return github_com_cosmos_cosmos_sdk_types.Coin{} +} + +func (m *Bid) GetBidderAddress() string { + if m != nil { + return m.BidderAddress + } + return "" +} + +func (m *Bid) GetBiddingTimestamp() time.Time { + if m != nil { + return m.BiddingTimestamp + } + return time.Time{} +} + +func (m *Bid) GetAppId() uint64 { + if m != nil { + return m.AppId + } + return 0 +} + +func (m *Bid) GetBidType() string { + if m != nil { + return m.BidType + } + return "" +} + +type LimitOrderBid struct { + LimitOrderBiddingId uint64 `protobuf:"varint,1,opt,name=limit_order_bidding_id,json=limitOrderBiddingId,proto3" json:"limit_order_bidding_id,omitempty" yaml:"limit_order_bidding_id"` + BidderAddress string `protobuf:"bytes,2,opt,name=bidder_address,json=bidderAddress,proto3" json:"bidder_address,omitempty" yaml:"bidder"` + CollateralTokenId uint64 `protobuf:"varint,3,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty" yaml:"collateral_token_id"` + PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` + DebtTokenId uint64 `protobuf:"varint,5,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty" yaml:"debt_token_id"` + DebtToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,6,opt,name=debt_token,json=debtToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token" yaml:"debt_token"` + BiddingId []uint64 `protobuf:"varint,7,rep,packed,name=bidding_id,json=biddingId,proto3" json:"bidding_id,omitempty" yaml:"bidding_id"` +} + +func (m *LimitOrderBid) Reset() { *m = LimitOrderBid{} } +func (m *LimitOrderBid) String() string { return proto.CompactTextString(m) } +func (*LimitOrderBid) ProtoMessage() {} +func (*LimitOrderBid) Descriptor() ([]byte, []int) { + return fileDescriptor_627413fbf33ef9e3, []int{1} +} +func (m *LimitOrderBid) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LimitOrderBid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LimitOrderBid.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 *LimitOrderBid) XXX_Merge(src proto.Message) { + xxx_messageInfo_LimitOrderBid.Merge(m, src) +} +func (m *LimitOrderBid) XXX_Size() int { + return m.Size() +} +func (m *LimitOrderBid) XXX_DiscardUnknown() { + xxx_messageInfo_LimitOrderBid.DiscardUnknown(m) +} + +var xxx_messageInfo_LimitOrderBid proto.InternalMessageInfo + +func (m *LimitOrderBid) GetLimitOrderBiddingId() uint64 { + if m != nil { + return m.LimitOrderBiddingId + } + return 0 +} + +func (m *LimitOrderBid) GetBidderAddress() string { + if m != nil { + return m.BidderAddress + } + return "" +} + +func (m *LimitOrderBid) GetCollateralTokenId() uint64 { + if m != nil { + return m.CollateralTokenId + } + return 0 +} + +func (m *LimitOrderBid) GetDebtTokenId() uint64 { + if m != nil { + return m.DebtTokenId + } + return 0 +} + +func (m *LimitOrderBid) GetDebtToken() github_com_cosmos_cosmos_sdk_types.Coin { + if m != nil { + return m.DebtToken + } + return github_com_cosmos_cosmos_sdk_types.Coin{} +} + +func (m *LimitOrderBid) GetBiddingId() []uint64 { + if m != nil { + return m.BiddingId + } + return nil +} + +type AuctionParams struct { + AuctionDurationSeconds uint64 `protobuf:"varint,1,opt,name=auction_duration_seconds,json=auctionDurationSeconds,proto3" json:"auction_duration_seconds,omitempty" yaml:"auction_duration_seconds"` + Step github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=step,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"step" yaml:"step"` + WithdrawalFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=withdrawal_fee,json=withdrawalFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"withdrawal_fee" yaml:"withdrawal_fee"` + ClosingFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=closing_fee,json=closingFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"closing_fee" yaml:"closing_fee"` + MinUsdValueLeft uint64 `protobuf:"varint,5,opt,name=min_usd_value_left,json=minUsdValueLeft,proto3" json:"min_usd_value_left,omitempty" yaml:"min_usd_value_left"` + BidFactor github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=bid_factor,json=bidFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"bid_factor" yaml:"bid_factor"` + //For external apps + LiquidationPenalty github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=liquidation_penalty,json=liquidationPenalty,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidation_penalty" yaml:"liquidation_penalty"` + AuctionBonus github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=auction_bonus,json=auctionBonus,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"auction_bonus" yaml:"auction_bonus"` +} + +func (m *AuctionParams) Reset() { *m = AuctionParams{} } +func (m *AuctionParams) String() string { return proto.CompactTextString(m) } +func (*AuctionParams) ProtoMessage() {} +func (*AuctionParams) Descriptor() ([]byte, []int) { + return fileDescriptor_627413fbf33ef9e3, []int{2} +} +func (m *AuctionParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AuctionParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AuctionParams.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 *AuctionParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_AuctionParams.Merge(m, src) +} +func (m *AuctionParams) XXX_Size() int { + return m.Size() +} +func (m *AuctionParams) XXX_DiscardUnknown() { + xxx_messageInfo_AuctionParams.DiscardUnknown(m) +} + +var xxx_messageInfo_AuctionParams proto.InternalMessageInfo + +func (m *AuctionParams) GetAuctionDurationSeconds() uint64 { + if m != nil { + return m.AuctionDurationSeconds + } + return 0 +} + +func (m *AuctionParams) GetMinUsdValueLeft() uint64 { + if m != nil { + return m.MinUsdValueLeft + } + return 0 +} + +type LimitOrderBidsForUser struct { + BidderAddress string `protobuf:"bytes,1,opt,name=bidder_address,json=bidderAddress,proto3" json:"bidder_address,omitempty" yaml:"bidder"` + LimitOrderBidKey []LimitOrderUserKey `protobuf:"bytes,2,rep,name=limit_order_bid_key,json=limitOrderBidKey,proto3" json:"limit_order_bid_key" yaml:"limit_order_bid_key"` +} + +func (m *LimitOrderBidsForUser) Reset() { *m = LimitOrderBidsForUser{} } +func (m *LimitOrderBidsForUser) String() string { return proto.CompactTextString(m) } +func (*LimitOrderBidsForUser) ProtoMessage() {} +func (*LimitOrderBidsForUser) Descriptor() ([]byte, []int) { + return fileDescriptor_627413fbf33ef9e3, []int{3} +} +func (m *LimitOrderBidsForUser) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LimitOrderBidsForUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LimitOrderBidsForUser.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 *LimitOrderBidsForUser) XXX_Merge(src proto.Message) { + xxx_messageInfo_LimitOrderBidsForUser.Merge(m, src) +} +func (m *LimitOrderBidsForUser) XXX_Size() int { + return m.Size() +} +func (m *LimitOrderBidsForUser) XXX_DiscardUnknown() { + xxx_messageInfo_LimitOrderBidsForUser.DiscardUnknown(m) +} + +var xxx_messageInfo_LimitOrderBidsForUser proto.InternalMessageInfo + +func (m *LimitOrderBidsForUser) GetBidderAddress() string { + if m != nil { + return m.BidderAddress + } + return "" +} + +func (m *LimitOrderBidsForUser) GetLimitOrderBidKey() []LimitOrderUserKey { + if m != nil { + return m.LimitOrderBidKey + } + return nil +} + +type LimitOrderUserKey struct { + DebtTokenId uint64 `protobuf:"varint,1,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty" yaml:"debt_token_id"` + CollateralTokenId uint64 `protobuf:"varint,2,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty" yaml:"collateral_token_id"` + PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` + LimitOrderBiddingId uint64 `protobuf:"varint,4,opt,name=limit_order_bidding_id,json=limitOrderBiddingId,proto3" json:"limit_order_bidding_id,omitempty" yaml:"limit_order_bidding_id"` +} + +func (m *LimitOrderUserKey) Reset() { *m = LimitOrderUserKey{} } +func (m *LimitOrderUserKey) String() string { return proto.CompactTextString(m) } +func (*LimitOrderUserKey) ProtoMessage() {} +func (*LimitOrderUserKey) Descriptor() ([]byte, []int) { + return fileDescriptor_627413fbf33ef9e3, []int{4} +} +func (m *LimitOrderUserKey) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LimitOrderUserKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LimitOrderUserKey.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 *LimitOrderUserKey) XXX_Merge(src proto.Message) { + xxx_messageInfo_LimitOrderUserKey.Merge(m, src) +} +func (m *LimitOrderUserKey) XXX_Size() int { + return m.Size() +} +func (m *LimitOrderUserKey) XXX_DiscardUnknown() { + xxx_messageInfo_LimitOrderUserKey.DiscardUnknown(m) +} + +var xxx_messageInfo_LimitOrderUserKey proto.InternalMessageInfo + +func (m *LimitOrderUserKey) GetDebtTokenId() uint64 { + if m != nil { + return m.DebtTokenId + } + return 0 +} + +func (m *LimitOrderUserKey) GetCollateralTokenId() uint64 { + if m != nil { + return m.CollateralTokenId + } + return 0 +} + +func (m *LimitOrderUserKey) GetLimitOrderBiddingId() uint64 { + if m != nil { + return m.LimitOrderBiddingId + } + return 0 +} + +type AuctionFeesCollectionFromLimitBidTx struct { + AssetId uint64 `protobuf:"varint,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty" yaml:"asset_id"` + Amount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount" yaml:"amount"` +} + +func (m *AuctionFeesCollectionFromLimitBidTx) Reset() { *m = AuctionFeesCollectionFromLimitBidTx{} } +func (m *AuctionFeesCollectionFromLimitBidTx) String() string { return proto.CompactTextString(m) } +func (*AuctionFeesCollectionFromLimitBidTx) ProtoMessage() {} +func (*AuctionFeesCollectionFromLimitBidTx) Descriptor() ([]byte, []int) { + return fileDescriptor_627413fbf33ef9e3, []int{5} +} +func (m *AuctionFeesCollectionFromLimitBidTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AuctionFeesCollectionFromLimitBidTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AuctionFeesCollectionFromLimitBidTx.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 *AuctionFeesCollectionFromLimitBidTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_AuctionFeesCollectionFromLimitBidTx.Merge(m, src) +} +func (m *AuctionFeesCollectionFromLimitBidTx) XXX_Size() int { + return m.Size() +} +func (m *AuctionFeesCollectionFromLimitBidTx) XXX_DiscardUnknown() { + xxx_messageInfo_AuctionFeesCollectionFromLimitBidTx.DiscardUnknown(m) +} + +var xxx_messageInfo_AuctionFeesCollectionFromLimitBidTx proto.InternalMessageInfo + +func (m *AuctionFeesCollectionFromLimitBidTx) GetAssetId() uint64 { + if m != nil { + return m.AssetId + } + return 0 +} + +func init() { + proto.RegisterType((*Bid)(nil), "comdex.auction.v2.Bid") + proto.RegisterType((*LimitOrderBid)(nil), "comdex.auction.v2.LimitOrderBid") + proto.RegisterType((*AuctionParams)(nil), "comdex.auction.v2.AuctionParams") + proto.RegisterType((*LimitOrderBidsForUser)(nil), "comdex.auction.v2.LimitOrderBidsForUser") + proto.RegisterType((*LimitOrderUserKey)(nil), "comdex.auction.v2.LimitOrderUserKey") + proto.RegisterType((*AuctionFeesCollectionFromLimitBidTx)(nil), "comdex.auction.v2.AuctionFeesCollectionFromLimitBidTx") +} + +func init() { proto.RegisterFile("comdex/auction/v2/bid.proto", fileDescriptor_627413fbf33ef9e3) } + +var fileDescriptor_627413fbf33ef9e3 = []byte{ + // 1115 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xc1, 0x6e, 0xdb, 0xb6, + 0x1f, 0x8e, 0x12, 0x27, 0xa9, 0x99, 0xbf, 0x9b, 0x58, 0x49, 0x5a, 0x37, 0x45, 0xad, 0xfc, 0xd9, + 0x62, 0xcb, 0xa5, 0x12, 0x9a, 0xee, 0x30, 0x0c, 0x1b, 0x86, 0x28, 0x81, 0x07, 0xaf, 0x69, 0xd7, + 0x69, 0x69, 0x07, 0x0c, 0x18, 0x04, 0x49, 0xa4, 0x5d, 0x22, 0x92, 0xe8, 0x89, 0x54, 0x52, 0x1f, + 0xb6, 0x67, 0xe8, 0x61, 0x2f, 0xb0, 0x17, 0xd8, 0x2e, 0x7b, 0x88, 0x62, 0xa7, 0x1e, 0x87, 0x0d, + 0xd0, 0x86, 0xe4, 0x01, 0x06, 0xf8, 0xb8, 0xd3, 0x20, 0x92, 0xb6, 0x2c, 0x3b, 0xdd, 0x62, 0x74, + 0x3b, 0x89, 0xfc, 0xfd, 0xc8, 0xef, 0xf7, 0x89, 0xfc, 0xf8, 0x91, 0xe0, 0x66, 0x40, 0x23, 0x84, + 0x9f, 0x5b, 0x5e, 0x1a, 0x70, 0x42, 0x63, 0xeb, 0x64, 0xd7, 0xf2, 0x09, 0x32, 0x7b, 0x09, 0xe5, + 0x54, 0xaf, 0xcb, 0xa4, 0xa9, 0x92, 0xe6, 0xc9, 0xee, 0xd6, 0x46, 0x97, 0x76, 0xa9, 0xc8, 0x5a, + 0x79, 0x4b, 0x0e, 0xdc, 0x32, 0xba, 0x94, 0x76, 0x43, 0x6c, 0x89, 0x9e, 0x9f, 0x76, 0x2c, 0x4e, + 0x22, 0xcc, 0xb8, 0x17, 0xf5, 0xd4, 0x80, 0x66, 0x40, 0x59, 0x44, 0x99, 0xe5, 0x7b, 0x0c, 0x5b, + 0x27, 0xf7, 0x7c, 0xcc, 0xbd, 0x7b, 0x56, 0x40, 0x49, 0x2c, 0xf3, 0xf0, 0x87, 0x45, 0xb0, 0x60, + 0x13, 0xa4, 0xbf, 0x03, 0x80, 0x4f, 0x10, 0x22, 0x71, 0xd7, 0x25, 0xa8, 0xa1, 0x6d, 0x6b, 0x3b, + 0x15, 0x7b, 0x73, 0x90, 0x19, 0xf5, 0xbe, 0x17, 0x85, 0xef, 0xc1, 0x22, 0x07, 0x9d, 0xaa, 0xea, + 0xb4, 0xc5, 0x2c, 0x45, 0x31, 0x9f, 0x35, 0x3f, 0x39, 0xab, 0xc8, 0x41, 0xa7, 0xaa, 0x3a, 0x6d, + 0xa4, 0x7f, 0xa7, 0x81, 0xeb, 0x01, 0x0d, 0x43, 0x8f, 0xe3, 0xc4, 0x0b, 0x5d, 0x4e, 0x8f, 0x71, + 0xec, 0x7a, 0x11, 0x4d, 0x63, 0xde, 0x58, 0xd8, 0xd6, 0x76, 0x56, 0x76, 0x6f, 0x98, 0x92, 0xb6, + 0x99, 0xd3, 0x36, 0x15, 0x6d, 0x73, 0x9f, 0x92, 0xd8, 0x7e, 0xf4, 0x32, 0x33, 0xe6, 0x06, 0x99, + 0x71, 0x53, 0x96, 0xa0, 0x29, 0xef, 0x84, 0xf4, 0xb4, 0x04, 0x02, 0xff, 0xcc, 0x8c, 0xb7, 0xbb, + 0x84, 0x3f, 0x4b, 0x7d, 0x33, 0xa0, 0x91, 0xa5, 0x96, 0x40, 0x7e, 0xee, 0x32, 0x74, 0x6c, 0xf1, + 0x7e, 0x0f, 0x33, 0x81, 0xe7, 0x6c, 0x16, 0x4c, 0x8e, 0x72, 0x8c, 0x3d, 0x01, 0xa1, 0x7f, 0xab, + 0x81, 0x3a, 0xc2, 0x3e, 0x2f, 0xb3, 0xab, 0xfc, 0x13, 0xbb, 0x87, 0x8a, 0xdd, 0x96, 0x64, 0x47, + 0xe2, 0x37, 0x23, 0xb7, 0x9a, 0x53, 0x18, 0xa7, 0xf5, 0x2e, 0xb8, 0x9a, 0xaf, 0x3e, 0x4e, 0x5c, + 0x0f, 0xa1, 0x04, 0x33, 0xd6, 0x58, 0xdc, 0xd6, 0x76, 0xaa, 0x76, 0x7d, 0x90, 0x19, 0xb5, 0x62, + 0xab, 0x70, 0x02, 0x9d, 0x9a, 0x6c, 0xec, 0xc9, 0x71, 0x7a, 0x04, 0xea, 0xc3, 0x4d, 0x1c, 0x69, + 0xa4, 0xb1, 0x24, 0xfe, 0x67, 0xcb, 0x94, 0x2a, 0x32, 0x87, 0x2a, 0x32, 0x8f, 0x86, 0x23, 0xec, + 0x3b, 0xea, 0x87, 0x1a, 0x65, 0x1d, 0x8c, 0x20, 0xe0, 0x8b, 0xdf, 0x0c, 0xcd, 0x59, 0x53, 0xf1, + 0xd1, 0x3c, 0x7d, 0x07, 0x2c, 0x79, 0xbd, 0x5e, 0xae, 0x8a, 0x65, 0xa1, 0x8a, 0x31, 0x82, 0x32, + 0x0e, 0x9d, 0x45, 0xaf, 0xd7, 0x6b, 0x23, 0xdd, 0x04, 0x57, 0x7c, 0x82, 0xdc, 0xfc, 0xaf, 0x1b, + 0x57, 0xc4, 0xcf, 0xac, 0x0f, 0x32, 0x63, 0x75, 0x54, 0x4f, 0x64, 0xa0, 0xb3, 0xec, 0x13, 0x74, + 0x94, 0xb7, 0x7e, 0xad, 0x80, 0xda, 0x21, 0x89, 0x08, 0xff, 0x24, 0x41, 0x38, 0xc9, 0xb5, 0xfb, + 0x14, 0x5c, 0x0b, 0xf3, 0x80, 0x4b, 0xf3, 0x88, 0x3b, 0xa5, 0xe3, 0xff, 0x0f, 0x32, 0xe3, 0x96, + 0xc4, 0xbb, 0x78, 0x1c, 0x74, 0xd6, 0xc3, 0x71, 0x44, 0xa5, 0xee, 0xe9, 0xc5, 0x9e, 0xbf, 0xe4, + 0x62, 0x3f, 0x02, 0xeb, 0x53, 0x02, 0x27, 0x48, 0x88, 0xbb, 0x62, 0x37, 0x0b, 0x7d, 0x5c, 0x30, + 0x08, 0x3a, 0xf5, 0x09, 0x45, 0xb6, 0x91, 0xce, 0xc1, 0x5a, 0x2f, 0xc1, 0x11, 0x49, 0x23, 0x17, + 0x11, 0x16, 0x8c, 0xb4, 0x58, 0xb5, 0xdb, 0xf9, 0xfe, 0xfc, 0x92, 0x19, 0x6f, 0x5d, 0x42, 0x52, + 0xed, 0x98, 0x0f, 0x32, 0xe3, 0xba, 0x2c, 0x3d, 0x89, 0x07, 0x9d, 0x55, 0x15, 0x3a, 0x50, 0x11, + 0xfd, 0x7d, 0x50, 0x1b, 0x3b, 0x02, 0x04, 0x09, 0xad, 0x55, 0xec, 0xc6, 0x20, 0x33, 0x36, 0x24, + 0x48, 0x29, 0x0d, 0x9d, 0x95, 0x91, 0x5c, 0xdb, 0x48, 0xff, 0x06, 0x80, 0x22, 0xad, 0x94, 0xf6, + 0x37, 0x27, 0xe7, 0x40, 0x09, 0xad, 0x3e, 0x89, 0x3c, 0xd3, 0x81, 0xa9, 0x8e, 0x18, 0x4c, 0x38, + 0xda, 0xf2, 0xf6, 0xc2, 0x65, 0x1c, 0x0d, 0xfe, 0xb8, 0x04, 0x6a, 0x7b, 0xd2, 0xa9, 0x1e, 0x7b, + 0x89, 0x17, 0x31, 0xfd, 0x4b, 0xd0, 0x18, 0xfa, 0x18, 0x4a, 0x13, 0x4f, 0x34, 0x18, 0x0e, 0x68, + 0x8c, 0x98, 0xd2, 0xd7, 0xed, 0x41, 0x66, 0x18, 0x65, 0xc7, 0x9b, 0x1c, 0x09, 0x9d, 0x6b, 0x2a, + 0x75, 0xa0, 0x32, 0x9f, 0xc9, 0x84, 0xfe, 0x29, 0xa8, 0x30, 0x8e, 0x7b, 0x4a, 0x5a, 0x1f, 0xcc, + 0xb0, 0x9d, 0x07, 0x38, 0x18, 0x64, 0xc6, 0x8a, 0x2c, 0x9c, 0x63, 0x40, 0x47, 0x40, 0xe9, 0x31, + 0xb8, 0x7a, 0x4a, 0xf8, 0x33, 0x94, 0x78, 0xa7, 0x5e, 0xe8, 0x76, 0x30, 0x16, 0xc2, 0xab, 0xda, + 0x1f, 0xcd, 0x0c, 0xbe, 0x29, 0xc1, 0xcb, 0x68, 0xd0, 0xa9, 0x15, 0x81, 0x16, 0xc6, 0x3a, 0x06, + 0x2b, 0x41, 0x48, 0x59, 0xbe, 0x9a, 0x79, 0x31, 0x29, 0xcc, 0x83, 0x99, 0x8b, 0xe9, 0xea, 0x4c, + 0x14, 0x50, 0xd0, 0x01, 0xaa, 0x97, 0x97, 0xf9, 0x18, 0xe8, 0x11, 0x89, 0xdd, 0x94, 0x21, 0xf7, + 0xc4, 0x0b, 0x53, 0xec, 0x86, 0xb8, 0xc3, 0x95, 0x26, 0x6f, 0x0d, 0x32, 0xe3, 0x86, 0x9c, 0x3f, + 0x3d, 0x06, 0x3a, 0xab, 0x11, 0x89, 0x9f, 0x30, 0xf4, 0x34, 0x0f, 0x1d, 0xe2, 0x0e, 0xd7, 0x7d, + 0x21, 0x0e, 0xb7, 0xe3, 0x05, 0x9c, 0x26, 0x42, 0x9c, 0x55, 0x7b, 0x7f, 0x66, 0xc6, 0x85, 0x94, + 0x14, 0x92, 0x94, 0x52, 0x4b, 0xb4, 0xf5, 0xaf, 0xc1, 0x7a, 0x48, 0xbe, 0x4a, 0x09, 0x92, 0x4a, + 0xe8, 0xe1, 0xd8, 0x0b, 0x79, 0x5f, 0xf8, 0x61, 0xd5, 0x3e, 0x9c, 0xb9, 0xd8, 0xd6, 0xd0, 0xc1, + 0xa6, 0x20, 0xa1, 0xa3, 0x8f, 0x45, 0x1f, 0xcb, 0xa0, 0x7e, 0x0c, 0x6a, 0x43, 0x35, 0xfa, 0x34, + 0x4e, 0x99, 0x32, 0xd7, 0xd6, 0xcc, 0x85, 0x37, 0xca, 0xd2, 0x16, 0x60, 0xd0, 0xf9, 0x9f, 0xea, + 0xdb, 0xa2, 0xfb, 0x93, 0x06, 0x36, 0x4b, 0xa6, 0xcc, 0x5a, 0x34, 0x79, 0xc2, 0x70, 0x72, 0x81, + 0x89, 0x6a, 0x97, 0x34, 0xd1, 0x53, 0xb0, 0x3e, 0x61, 0xd7, 0xee, 0x31, 0xee, 0x37, 0xe6, 0xb7, + 0x17, 0x76, 0x56, 0x76, 0xef, 0x98, 0x53, 0x4f, 0x24, 0xb3, 0x20, 0x90, 0x57, 0x7e, 0x80, 0xfb, + 0x36, 0x2c, 0x5f, 0xc7, 0x17, 0xc0, 0x41, 0x67, 0xad, 0x64, 0xfd, 0x0f, 0x70, 0x1f, 0xfe, 0x31, + 0x0f, 0xea, 0x53, 0x58, 0xd3, 0x6e, 0xa8, 0xcd, 0xe2, 0x86, 0xaf, 0xb9, 0x11, 0xe6, 0xff, 0xcd, + 0x1b, 0x61, 0xe1, 0x3f, 0xbf, 0x11, 0x5e, 0x7f, 0xd3, 0x56, 0xde, 0xe4, 0xa6, 0x85, 0xdf, 0x6b, + 0xe0, 0xb6, 0x72, 0xdd, 0x16, 0xc6, 0x6c, 0x9f, 0x86, 0x21, 0x96, 0xbd, 0x84, 0x46, 0x62, 0x2b, + 0x6c, 0x82, 0x8e, 0x9e, 0xe7, 0x6f, 0x05, 0x8f, 0x31, 0xcc, 0x8b, 0xe5, 0x1f, 0x7b, 0x2b, 0x0c, + 0x33, 0xd0, 0x59, 0x16, 0xcd, 0x36, 0xd2, 0x3f, 0x07, 0x4b, 0xea, 0xe5, 0x26, 0xed, 0xf5, 0xc3, + 0x99, 0xd7, 0x66, 0xf8, 0x66, 0x91, 0x6f, 0x37, 0x47, 0xc1, 0xd9, 0x0f, 0x5f, 0x9e, 0x35, 0xb5, + 0x57, 0x67, 0x4d, 0xed, 0xf7, 0xb3, 0xa6, 0xf6, 0xe2, 0xbc, 0x39, 0xf7, 0xea, 0xbc, 0x39, 0xf7, + 0xf3, 0x79, 0x73, 0xee, 0x8b, 0xfb, 0x25, 0xe8, 0x5c, 0xa2, 0x77, 0x69, 0xa7, 0x43, 0x02, 0xe2, + 0x85, 0xaa, 0x6f, 0x8d, 0x3f, 0xfa, 0x45, 0x2d, 0x7f, 0x49, 0xbc, 0xbc, 0xee, 0xff, 0x15, 0x00, + 0x00, 0xff, 0xff, 0x4d, 0xea, 0x17, 0xec, 0x15, 0x0c, 0x00, 0x00, +} + +func (m *Bid) 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 *Bid) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Bid) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.BidType) > 0 { + i -= len(m.BidType) + copy(dAtA[i:], m.BidType) + i = encodeVarintBid(dAtA, i, uint64(len(m.BidType))) + i-- + dAtA[i] = 0x42 + } + if m.AppId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x38 + } + n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.BiddingTimestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.BiddingTimestamp):]) + if err1 != nil { + return 0, err1 + } + i -= n1 + i = encodeVarintBid(dAtA, i, uint64(n1)) + i-- + dAtA[i] = 0x32 + if len(m.BidderAddress) > 0 { + i -= len(m.BidderAddress) + copy(dAtA[i:], m.BidderAddress) + i = encodeVarintBid(dAtA, i, uint64(len(m.BidderAddress))) + i-- + dAtA[i] = 0x2a + } + { + size, err := m.DebtTokenAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size, err := m.CollateralTokenAmount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.AuctionId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.AuctionId)) + i-- + dAtA[i] = 0x10 + } + if m.BiddingId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.BiddingId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *LimitOrderBid) 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 *LimitOrderBid) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LimitOrderBid) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.BiddingId) > 0 { + dAtA5 := make([]byte, len(m.BiddingId)*10) + var j4 int + for _, num := range m.BiddingId { + for num >= 1<<7 { + dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j4++ + } + dAtA5[j4] = uint8(num) + j4++ + } + i -= j4 + copy(dAtA[i:], dAtA5[:j4]) + i = encodeVarintBid(dAtA, i, uint64(j4)) + i-- + dAtA[i] = 0x3a + } + { + size, err := m.DebtToken.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + if m.DebtTokenId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.DebtTokenId)) + i-- + dAtA[i] = 0x28 + } + { + size := m.PremiumDiscount.Size() + i -= size + if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + if m.CollateralTokenId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.CollateralTokenId)) + i-- + dAtA[i] = 0x18 + } + if len(m.BidderAddress) > 0 { + i -= len(m.BidderAddress) + copy(dAtA[i:], m.BidderAddress) + i = encodeVarintBid(dAtA, i, uint64(len(m.BidderAddress))) + i-- + dAtA[i] = 0x12 + } + if m.LimitOrderBiddingId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.LimitOrderBiddingId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AuctionParams) 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 *AuctionParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AuctionParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.AuctionBonus.Size() + i -= size + if _, err := m.AuctionBonus.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + { + size := m.LiquidationPenalty.Size() + i -= size + if _, err := m.LiquidationPenalty.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + { + size := m.BidFactor.Size() + i -= size + if _, err := m.BidFactor.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + if m.MinUsdValueLeft != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.MinUsdValueLeft)) + i-- + dAtA[i] = 0x28 + } + { + size := m.ClosingFee.Size() + i -= size + if _, err := m.ClosingFee.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + { + size := m.WithdrawalFee.Size() + i -= size + if _, err := m.WithdrawalFee.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size := m.Step.Size() + i -= size + if _, err := m.Step.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if m.AuctionDurationSeconds != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.AuctionDurationSeconds)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *LimitOrderBidsForUser) 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 *LimitOrderBidsForUser) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LimitOrderBidsForUser) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.LimitOrderBidKey) > 0 { + for iNdEx := len(m.LimitOrderBidKey) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.LimitOrderBidKey[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.BidderAddress) > 0 { + i -= len(m.BidderAddress) + copy(dAtA[i:], m.BidderAddress) + i = encodeVarintBid(dAtA, i, uint64(len(m.BidderAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LimitOrderUserKey) 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 *LimitOrderUserKey) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LimitOrderUserKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.LimitOrderBiddingId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.LimitOrderBiddingId)) + i-- + dAtA[i] = 0x20 + } + { + size := m.PremiumDiscount.Size() + i -= size + if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.CollateralTokenId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.CollateralTokenId)) + i-- + dAtA[i] = 0x10 + } + if m.DebtTokenId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.DebtTokenId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AuctionFeesCollectionFromLimitBidTx) 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 *AuctionFeesCollectionFromLimitBidTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AuctionFeesCollectionFromLimitBidTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Amount.Size() + i -= size + if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintBid(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if m.AssetId != 0 { + i = encodeVarintBid(dAtA, i, uint64(m.AssetId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintBid(dAtA []byte, offset int, v uint64) int { + offset -= sovBid(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Bid) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.BiddingId != 0 { + n += 1 + sovBid(uint64(m.BiddingId)) + } + if m.AuctionId != 0 { + n += 1 + sovBid(uint64(m.AuctionId)) + } + l = m.CollateralTokenAmount.Size() + n += 1 + l + sovBid(uint64(l)) + l = m.DebtTokenAmount.Size() + n += 1 + l + sovBid(uint64(l)) + l = len(m.BidderAddress) + if l > 0 { + n += 1 + l + sovBid(uint64(l)) + } + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.BiddingTimestamp) + n += 1 + l + sovBid(uint64(l)) + if m.AppId != 0 { + n += 1 + sovBid(uint64(m.AppId)) + } + l = len(m.BidType) + if l > 0 { + n += 1 + l + sovBid(uint64(l)) + } + return n +} + +func (m *LimitOrderBid) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LimitOrderBiddingId != 0 { + n += 1 + sovBid(uint64(m.LimitOrderBiddingId)) + } + l = len(m.BidderAddress) + if l > 0 { + n += 1 + l + sovBid(uint64(l)) + } + if m.CollateralTokenId != 0 { + n += 1 + sovBid(uint64(m.CollateralTokenId)) + } + l = m.PremiumDiscount.Size() + n += 1 + l + sovBid(uint64(l)) + if m.DebtTokenId != 0 { + n += 1 + sovBid(uint64(m.DebtTokenId)) + } + l = m.DebtToken.Size() + n += 1 + l + sovBid(uint64(l)) + if len(m.BiddingId) > 0 { + l = 0 + for _, e := range m.BiddingId { + l += sovBid(uint64(e)) + } + n += 1 + sovBid(uint64(l)) + l + } + return n +} + +func (m *AuctionParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AuctionDurationSeconds != 0 { + n += 1 + sovBid(uint64(m.AuctionDurationSeconds)) + } + l = m.Step.Size() + n += 1 + l + sovBid(uint64(l)) + l = m.WithdrawalFee.Size() + n += 1 + l + sovBid(uint64(l)) + l = m.ClosingFee.Size() + n += 1 + l + sovBid(uint64(l)) + if m.MinUsdValueLeft != 0 { + n += 1 + sovBid(uint64(m.MinUsdValueLeft)) + } + l = m.BidFactor.Size() + n += 1 + l + sovBid(uint64(l)) + l = m.LiquidationPenalty.Size() + n += 1 + l + sovBid(uint64(l)) + l = m.AuctionBonus.Size() + n += 1 + l + sovBid(uint64(l)) + return n +} + +func (m *LimitOrderBidsForUser) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.BidderAddress) + if l > 0 { + n += 1 + l + sovBid(uint64(l)) + } + if len(m.LimitOrderBidKey) > 0 { + for _, e := range m.LimitOrderBidKey { + l = e.Size() + n += 1 + l + sovBid(uint64(l)) + } + } + return n +} + +func (m *LimitOrderUserKey) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.DebtTokenId != 0 { + n += 1 + sovBid(uint64(m.DebtTokenId)) + } + if m.CollateralTokenId != 0 { + n += 1 + sovBid(uint64(m.CollateralTokenId)) + } + l = m.PremiumDiscount.Size() + n += 1 + l + sovBid(uint64(l)) + if m.LimitOrderBiddingId != 0 { + n += 1 + sovBid(uint64(m.LimitOrderBiddingId)) + } + return n +} + +func (m *AuctionFeesCollectionFromLimitBidTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AssetId != 0 { + n += 1 + sovBid(uint64(m.AssetId)) + } + l = m.Amount.Size() + n += 1 + l + sovBid(uint64(l)) + return n +} + +func sovBid(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozBid(x uint64) (n int) { + return sovBid(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Bid) 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 ErrIntOverflowBid + } + 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: Bid: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Bid: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BiddingId", wireType) + } + m.BiddingId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BiddingId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType) + } + m.AuctionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AuctionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBid + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CollateralTokenAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenAmount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBid + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DebtTokenAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BidderAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BidderAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BiddingTimestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBid + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.BiddingTimestamp, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BidType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BidType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LimitOrderBid) 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 ErrIntOverflowBid + } + 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: LimitOrderBid: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LimitOrderBid: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LimitOrderBiddingId", wireType) + } + m.LimitOrderBiddingId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LimitOrderBiddingId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BidderAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BidderAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) + } + m.CollateralTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CollateralTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) + } + m.DebtTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebtTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtToken", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBid + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DebtToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType == 0 { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.BiddingId = append(m.BiddingId, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthBid + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.BiddingId) == 0 { + m.BiddingId = make([]uint64, 0, elementCount) + } + for iNdEx < postIndex { + var v uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.BiddingId = append(m.BiddingId, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field BiddingId", wireType) + } + default: + iNdEx = preIndex + skippy, err := skipBid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuctionParams) 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 ErrIntOverflowBid + } + 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: AuctionParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuctionParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionDurationSeconds", wireType) + } + m.AuctionDurationSeconds = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AuctionDurationSeconds |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Step.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WithdrawalFee", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.WithdrawalFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClosingFee", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ClosingFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MinUsdValueLeft", wireType) + } + m.MinUsdValueLeft = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MinUsdValueLeft |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BidFactor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.BidFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidationPenalty", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LiquidationPenalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionBonus", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.AuctionBonus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LimitOrderBidsForUser) 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 ErrIntOverflowBid + } + 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: LimitOrderBidsForUser: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LimitOrderBidsForUser: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BidderAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BidderAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LimitOrderBidKey", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthBid + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.LimitOrderBidKey = append(m.LimitOrderBidKey, LimitOrderUserKey{}) + if err := m.LimitOrderBidKey[len(m.LimitOrderBidKey)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LimitOrderUserKey) 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 ErrIntOverflowBid + } + 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: LimitOrderUserKey: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LimitOrderUserKey: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) + } + m.DebtTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebtTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) + } + m.CollateralTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CollateralTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LimitOrderBiddingId", wireType) + } + m.LimitOrderBiddingId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LimitOrderBiddingId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipBid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AuctionFeesCollectionFromLimitBidTx) 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 ErrIntOverflowBid + } + 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: AuctionFeesCollectionFromLimitBidTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AuctionFeesCollectionFromLimitBidTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) + } + m.AssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowBid + } + 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 ErrInvalidLengthBid + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthBid + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipBid(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthBid + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipBid(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowBid + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowBid + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowBid + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthBid + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupBid + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthBid + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthBid = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowBid = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupBid = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/auction/v2types/genesis.pb.go b/x/auction/v2types/genesis.pb.go new file mode 100644 index 000000000..5692e9aab --- /dev/null +++ b/x/auction/v2types/genesis.pb.go @@ -0,0 +1,320 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/auction/v2/genesis.proto + +package v2types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type GenesisState struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_c2722419d1052c81, []int{0} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +func (m *GenesisState) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func init() { + proto.RegisterType((*GenesisState)(nil), "comdex.auction.v2.GenesisState") +} + +func init() { proto.RegisterFile("comdex/auction/v2/genesis.proto", fileDescriptor_c2722419d1052c81) } + +var fileDescriptor_c2722419d1052c81 = []byte{ + // 199 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xce, 0xcf, 0x4d, + 0x49, 0xad, 0xd0, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd2, 0x4f, 0x4f, + 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0x28, 0xd0, + 0x83, 0x2a, 0xd0, 0x2b, 0x33, 0x92, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0xcb, 0xea, 0x83, 0x58, + 0x10, 0x85, 0x52, 0x72, 0x98, 0x26, 0x15, 0x24, 0x16, 0x25, 0xe6, 0x42, 0x0d, 0x52, 0x72, 0xe7, + 0xe2, 0x71, 0x87, 0x98, 0x1c, 0x5c, 0x92, 0x58, 0x92, 0x2a, 0x64, 0xce, 0xc5, 0x06, 0x91, 0x97, + 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd4, 0xc3, 0xb0, 0x49, 0x2f, 0x00, 0xac, 0xc0, 0x89, + 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0xa8, 0x72, 0x27, 0xdf, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, + 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, + 0x3c, 0x96, 0x63, 0x88, 0x32, 0x4e, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0x02, 0x19, 0xa4, 0x0f, 0x31, + 0x4c, 0x37, 0x3f, 0x2d, 0x2d, 0x33, 0x39, 0x33, 0x31, 0x07, 0xca, 0xd7, 0x47, 0x76, 0x5f, 0x49, + 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x79, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4c, + 0x95, 0x4a, 0x07, 0x0a, 0x01, 0x00, 0x00, +} + +func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) 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 = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GenesisState) 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 ErrIntOverflowGenesis + } + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + 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 := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenesis(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/auction/v2types/gov.pb.go b/x/auction/v2types/gov.pb.go new file mode 100644 index 000000000..6c2bea019 --- /dev/null +++ b/x/auction/v2types/gov.pb.go @@ -0,0 +1,427 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/auction/v2/gov.proto + +package v2types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type DutchAutoBidParamsProposal struct { + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty" yaml:"title"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"` + AuctionParams AuctionParams `protobuf:"bytes,3,opt,name=auctionParams,proto3" json:"auctionParams"` +} + +func (m *DutchAutoBidParamsProposal) Reset() { *m = DutchAutoBidParamsProposal{} } +func (m *DutchAutoBidParamsProposal) String() string { return proto.CompactTextString(m) } +func (*DutchAutoBidParamsProposal) ProtoMessage() {} +func (*DutchAutoBidParamsProposal) Descriptor() ([]byte, []int) { + return fileDescriptor_c6a564b40d36e1e6, []int{0} +} +func (m *DutchAutoBidParamsProposal) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DutchAutoBidParamsProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DutchAutoBidParamsProposal.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 *DutchAutoBidParamsProposal) XXX_Merge(src proto.Message) { + xxx_messageInfo_DutchAutoBidParamsProposal.Merge(m, src) +} +func (m *DutchAutoBidParamsProposal) XXX_Size() int { + return m.Size() +} +func (m *DutchAutoBidParamsProposal) XXX_DiscardUnknown() { + xxx_messageInfo_DutchAutoBidParamsProposal.DiscardUnknown(m) +} + +var xxx_messageInfo_DutchAutoBidParamsProposal proto.InternalMessageInfo + +func (m *DutchAutoBidParamsProposal) GetTitle() string { + if m != nil { + return m.Title + } + return "" +} + +func (m *DutchAutoBidParamsProposal) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *DutchAutoBidParamsProposal) GetAuctionParams() AuctionParams { + if m != nil { + return m.AuctionParams + } + return AuctionParams{} +} + +func init() { + proto.RegisterType((*DutchAutoBidParamsProposal)(nil), "comdex.auction.v2.DutchAutoBidParamsProposal") +} + +func init() { proto.RegisterFile("comdex/auction/v2/gov.proto", fileDescriptor_c6a564b40d36e1e6) } + +var fileDescriptor_c6a564b40d36e1e6 = []byte{ + // 277 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xce, 0xcf, 0x4d, + 0x49, 0xad, 0xd0, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd2, 0x4f, 0xcf, + 0x2f, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0x48, 0xea, 0x41, 0x25, 0xf5, 0xca, + 0x8c, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xb2, 0xfa, 0x20, 0x16, 0x44, 0xa1, 0x14, 0x16, + 0x53, 0x92, 0x32, 0x53, 0x20, 0x92, 0x4a, 0x67, 0x18, 0xb9, 0xa4, 0x5c, 0x4a, 0x4b, 0x92, 0x33, + 0x1c, 0x4b, 0x4b, 0xf2, 0x9d, 0x32, 0x53, 0x02, 0x12, 0x8b, 0x12, 0x73, 0x8b, 0x03, 0x8a, 0xf2, + 0x0b, 0xf2, 0x8b, 0x13, 0x73, 0x84, 0xd4, 0xb8, 0x58, 0x4b, 0x32, 0x4b, 0x72, 0x52, 0x25, 0x18, + 0x15, 0x18, 0x35, 0x38, 0x9d, 0x04, 0x3e, 0xdd, 0x93, 0xe7, 0xa9, 0x4c, 0xcc, 0xcd, 0xb1, 0x52, + 0x02, 0x0b, 0x2b, 0x05, 0x41, 0xa4, 0x85, 0x2c, 0xb8, 0xb8, 0x53, 0x52, 0x8b, 0x93, 0x8b, 0x32, + 0x0b, 0x40, 0x56, 0x48, 0x30, 0x81, 0x55, 0x8b, 0x7d, 0xba, 0x27, 0x2f, 0x04, 0x51, 0x8d, 0x24, + 0xa9, 0x14, 0x84, 0xac, 0x54, 0xc8, 0x87, 0x8b, 0x17, 0xea, 0x30, 0x88, 0xd5, 0x12, 0xcc, 0x0a, + 0x8c, 0x1a, 0xdc, 0x46, 0x0a, 0x7a, 0x18, 0xde, 0xd3, 0x73, 0x44, 0x56, 0xe7, 0xc4, 0x72, 0xe2, + 0x9e, 0x3c, 0x43, 0x10, 0xaa, 0x66, 0x27, 0xdf, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, + 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, + 0x63, 0x88, 0x32, 0x4e, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0x02, 0x19, 0xab, 0x0f, 0x31, 0x5a, 0x37, + 0x3f, 0x2d, 0x2d, 0x33, 0x39, 0x33, 0x31, 0x07, 0xca, 0xd7, 0x47, 0x0e, 0xa2, 0x92, 0xca, 0x82, + 0xd4, 0xe2, 0x24, 0x36, 0x70, 0x20, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xdd, 0x3b, 0x16, + 0xd9, 0x89, 0x01, 0x00, 0x00, +} + +func (m *DutchAutoBidParamsProposal) 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 *DutchAutoBidParamsProposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DutchAutoBidParamsProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.AuctionParams.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGov(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintGov(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x12 + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = encodeVarintGov(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintGov(dAtA []byte, offset int, v uint64) int { + offset -= sovGov(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *DutchAutoBidParamsProposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + l = m.AuctionParams.Size() + n += 1 + l + sovGov(uint64(l)) + return n +} + +func sovGov(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGov(x uint64) (n int) { + return sovGov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *DutchAutoBidParamsProposal) 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 ErrIntOverflowGov + } + 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: DutchAutoBidParamsProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DutchAutoBidParamsProposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionParams", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGov + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.AuctionParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGov(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGov + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGov(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGov + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGov + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGov + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGov + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGov + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGov + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGov = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGov = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGov = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/auction/v2types/params.pb.go b/x/auction/v2types/params.pb.go new file mode 100644 index 000000000..645788a51 --- /dev/null +++ b/x/auction/v2types/params.pb.go @@ -0,0 +1,263 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/auction/v2/params.proto + +package v2types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Params struct { +} + +func (m *Params) Reset() { *m = Params{} } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_3762e770d0a19ed4, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +func init() { + proto.RegisterType((*Params)(nil), "comdex.auction.v2.Params") +} + +func init() { proto.RegisterFile("comdex/auction/v2/params.proto", fileDescriptor_3762e770d0a19ed4) } + +var fileDescriptor_3762e770d0a19ed4 = []byte{ + // 159 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xce, 0xcf, 0x4d, + 0x49, 0xad, 0xd0, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd2, 0x2f, 0x48, + 0x2c, 0x4a, 0xcc, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0xc8, 0xeb, 0x41, + 0xe5, 0xf5, 0xca, 0x8c, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xb2, 0xfa, 0x20, 0x16, 0x44, + 0xa1, 0x12, 0x1f, 0x17, 0x5b, 0x00, 0x58, 0xa3, 0x15, 0xcb, 0x8c, 0x05, 0xf2, 0x0c, 0x4e, 0xbe, + 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, + 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0x65, 0x9c, 0x9e, 0x59, 0x92, 0x51, + 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x0f, 0x31, 0x5d, 0x37, 0x3f, 0x2d, 0x2d, 0x33, 0x39, 0x33, + 0x31, 0x07, 0xca, 0xd7, 0x47, 0x76, 0x4f, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x16, + 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe2, 0x93, 0x78, 0x84, 0xb0, 0x00, 0x00, 0x00, +} + +func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func encodeVarintParams(dAtA []byte, offset int, v uint64) int { + offset -= sovParams(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovParams(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozParams(x uint64) (n int) { + return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) 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 ErrIntOverflowParams + } + 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: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipParams(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthParams + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipParams(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthParams + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupParams + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthParams + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthParams = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowParams = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/auction/v2types/query.pb.go b/x/auction/v2types/query.pb.go new file mode 100644 index 000000000..94fe43549 --- /dev/null +++ b/x/auction/v2types/query.pb.go @@ -0,0 +1,530 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/auction/v2/query.proto + +package v2types + +import ( + context "context" + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type QueryParamsRequest struct { +} + +func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } +func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryParamsRequest) ProtoMessage() {} +func (*QueryParamsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_1b7e08455d3f955e, []int{0} +} +func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsRequest.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 *QueryParamsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsRequest.Merge(m, src) +} +func (m *QueryParamsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo + +type QueryParamsResponse struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } +func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryParamsResponse) ProtoMessage() {} +func (*QueryParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_1b7e08455d3f955e, []int{1} +} +func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsResponse.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 *QueryParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsResponse.Merge(m, src) +} +func (m *QueryParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo + +func (m *QueryParamsResponse) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func init() { + proto.RegisterType((*QueryParamsRequest)(nil), "comdex.auction.v2.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "comdex.auction.v2.QueryParamsResponse") +} + +func init() { proto.RegisterFile("comdex/auction/v2/query.proto", fileDescriptor_1b7e08455d3f955e) } + +var fileDescriptor_1b7e08455d3f955e = []byte{ + // 284 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4d, 0xce, 0xcf, 0x4d, + 0x49, 0xad, 0xd0, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd2, 0x2f, 0x2c, + 0x4d, 0x2d, 0xaa, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0x48, 0xeb, 0x41, 0xa5, + 0xf5, 0xca, 0x8c, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xb2, 0xfa, 0x20, 0x16, 0x44, 0xa1, + 0x94, 0x4c, 0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x7e, 0x62, 0x41, 0xa6, 0x7e, 0x62, 0x5e, 0x5e, + 0x7e, 0x49, 0x22, 0x48, 0x7d, 0x31, 0x54, 0x56, 0x0e, 0xd3, 0x96, 0x82, 0xc4, 0xa2, 0xc4, 0x5c, + 0xa8, 0xbc, 0x92, 0x08, 0x97, 0x50, 0x20, 0xc8, 0xd6, 0x00, 0xb0, 0x60, 0x50, 0x6a, 0x61, 0x69, + 0x6a, 0x71, 0x89, 0x92, 0x1f, 0x97, 0x30, 0x8a, 0x68, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0x90, + 0x39, 0x17, 0x1b, 0x44, 0xb3, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb7, 0x91, 0xa4, 0x1e, 0x86, 0x23, + 0xf5, 0x20, 0x5a, 0x9c, 0x58, 0x4e, 0xdc, 0x93, 0x67, 0x08, 0x82, 0x2a, 0x37, 0x9a, 0xc0, 0xc8, + 0xc5, 0x0a, 0x36, 0x50, 0xa8, 0x8d, 0x91, 0x8b, 0x0d, 0xa2, 0x44, 0x48, 0x15, 0x8b, 0x6e, 0x4c, + 0xb7, 0x48, 0xa9, 0x11, 0x52, 0x06, 0x71, 0x9c, 0x92, 0x6e, 0xd3, 0xe5, 0x27, 0x93, 0x99, 0xd4, + 0x85, 0x54, 0xf5, 0x21, 0xea, 0x75, 0xf3, 0xd3, 0xd2, 0x32, 0x93, 0x33, 0x13, 0x73, 0xa0, 0x7c, + 0xfd, 0xbc, 0xd4, 0xf2, 0xc4, 0xd2, 0x64, 0xa8, 0xf7, 0x9d, 0x7c, 0x4f, 0x3c, 0x92, 0x63, 0xbc, + 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, + 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0xca, 0x38, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x09, 0x64, 0x2d, 0x2e, + 0xa3, 0x90, 0xc3, 0xb3, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c, 0x9c, 0xc6, 0x80, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x56, 0x18, 0x7e, 0x53, 0xd6, 0x01, 0x00, 0x00, +} + +// 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 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { + out := new(QueryParamsResponse) + err := c.cc.Invoke(ctx, "/comdex.auction.v2.Query/Params", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryParamsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Params(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.auction.v2.Query/Params", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "comdex.auction.v2.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Params", + Handler: _Query_Params_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "comdex/auction/v2/query.proto", +} + +func (m *QueryParamsRequest) 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 *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryParamsResponse) 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 *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsResponse) 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 = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/auction/v2types/query.pb.gw.go b/x/auction/v2types/query.pb.gw.go new file mode 100644 index 000000000..a0b4282e0 --- /dev/null +++ b/x/auction/v2types/query.pb.gw.go @@ -0,0 +1,153 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: comdex/auction/v2/query.proto + +/* +Package v2types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package v2types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage +var _ = metadata.Join + +func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := server.Params(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"comdex-official", "comdex", "newauc", "params"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_Params_0 = runtime.ForwardResponseMessage +) diff --git a/x/auction/v2types/tx.pb.go b/x/auction/v2types/tx.pb.go new file mode 100644 index 000000000..18335081a --- /dev/null +++ b/x/auction/v2types/tx.pb.go @@ -0,0 +1,1968 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/auction/v2/tx.proto + +package v2types + +import ( + context "context" + fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type MsgPlaceMarketBidRequest struct { + AuctionId uint64 `protobuf:"varint,1,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty"` + Bidder string `protobuf:"bytes,2,opt,name=bidder,proto3" json:"bidder,omitempty"` + Amount types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"` +} + +func (m *MsgPlaceMarketBidRequest) Reset() { *m = MsgPlaceMarketBidRequest{} } +func (m *MsgPlaceMarketBidRequest) String() string { return proto.CompactTextString(m) } +func (*MsgPlaceMarketBidRequest) ProtoMessage() {} +func (*MsgPlaceMarketBidRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_f9a3512929bb96f1, []int{0} +} +func (m *MsgPlaceMarketBidRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgPlaceMarketBidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgPlaceMarketBidRequest.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 *MsgPlaceMarketBidRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgPlaceMarketBidRequest.Merge(m, src) +} +func (m *MsgPlaceMarketBidRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgPlaceMarketBidRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgPlaceMarketBidRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgPlaceMarketBidRequest proto.InternalMessageInfo + +type MsgPlaceMarketBidResponse struct { +} + +func (m *MsgPlaceMarketBidResponse) Reset() { *m = MsgPlaceMarketBidResponse{} } +func (m *MsgPlaceMarketBidResponse) String() string { return proto.CompactTextString(m) } +func (*MsgPlaceMarketBidResponse) ProtoMessage() {} +func (*MsgPlaceMarketBidResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_f9a3512929bb96f1, []int{1} +} +func (m *MsgPlaceMarketBidResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgPlaceMarketBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgPlaceMarketBidResponse.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 *MsgPlaceMarketBidResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgPlaceMarketBidResponse.Merge(m, src) +} +func (m *MsgPlaceMarketBidResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgPlaceMarketBidResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgPlaceMarketBidResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgPlaceMarketBidResponse proto.InternalMessageInfo + +type MsgDepositLimitBidRequest struct { + CollateralTokenId uint64 `protobuf:"varint,1,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty"` + DebtTokenId uint64 `protobuf:"varint,2,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty"` + PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` + Bidder string `protobuf:"bytes,4,opt,name=bidder,proto3" json:"bidder,omitempty"` + Amount types.Coin `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount"` +} + +func (m *MsgDepositLimitBidRequest) Reset() { *m = MsgDepositLimitBidRequest{} } +func (m *MsgDepositLimitBidRequest) String() string { return proto.CompactTextString(m) } +func (*MsgDepositLimitBidRequest) ProtoMessage() {} +func (*MsgDepositLimitBidRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_f9a3512929bb96f1, []int{2} +} +func (m *MsgDepositLimitBidRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDepositLimitBidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDepositLimitBidRequest.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 *MsgDepositLimitBidRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDepositLimitBidRequest.Merge(m, src) +} +func (m *MsgDepositLimitBidRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgDepositLimitBidRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDepositLimitBidRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgDepositLimitBidRequest proto.InternalMessageInfo + +type MsgDepositLimitBidResponse struct { +} + +func (m *MsgDepositLimitBidResponse) Reset() { *m = MsgDepositLimitBidResponse{} } +func (m *MsgDepositLimitBidResponse) String() string { return proto.CompactTextString(m) } +func (*MsgDepositLimitBidResponse) ProtoMessage() {} +func (*MsgDepositLimitBidResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_f9a3512929bb96f1, []int{3} +} +func (m *MsgDepositLimitBidResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgDepositLimitBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgDepositLimitBidResponse.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 *MsgDepositLimitBidResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgDepositLimitBidResponse.Merge(m, src) +} +func (m *MsgDepositLimitBidResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgDepositLimitBidResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgDepositLimitBidResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgDepositLimitBidResponse proto.InternalMessageInfo + +type MsgCancelLimitBidRequest struct { + CollateralTokenId uint64 `protobuf:"varint,1,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty"` + DebtTokenId uint64 `protobuf:"varint,2,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty"` + PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` + Bidder string `protobuf:"bytes,4,opt,name=bidder,proto3" json:"bidder,omitempty"` +} + +func (m *MsgCancelLimitBidRequest) Reset() { *m = MsgCancelLimitBidRequest{} } +func (m *MsgCancelLimitBidRequest) String() string { return proto.CompactTextString(m) } +func (*MsgCancelLimitBidRequest) ProtoMessage() {} +func (*MsgCancelLimitBidRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_f9a3512929bb96f1, []int{4} +} +func (m *MsgCancelLimitBidRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCancelLimitBidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCancelLimitBidRequest.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 *MsgCancelLimitBidRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCancelLimitBidRequest.Merge(m, src) +} +func (m *MsgCancelLimitBidRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgCancelLimitBidRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCancelLimitBidRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCancelLimitBidRequest proto.InternalMessageInfo + +type MsgCancelLimitBidResponse struct { +} + +func (m *MsgCancelLimitBidResponse) Reset() { *m = MsgCancelLimitBidResponse{} } +func (m *MsgCancelLimitBidResponse) String() string { return proto.CompactTextString(m) } +func (*MsgCancelLimitBidResponse) ProtoMessage() {} +func (*MsgCancelLimitBidResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_f9a3512929bb96f1, []int{5} +} +func (m *MsgCancelLimitBidResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgCancelLimitBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgCancelLimitBidResponse.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 *MsgCancelLimitBidResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgCancelLimitBidResponse.Merge(m, src) +} +func (m *MsgCancelLimitBidResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgCancelLimitBidResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgCancelLimitBidResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgCancelLimitBidResponse proto.InternalMessageInfo + +type MsgWithdrawLimitBidRequest struct { + CollateralTokenId uint64 `protobuf:"varint,1,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty"` + DebtTokenId uint64 `protobuf:"varint,2,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty"` + PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` + Bidder string `protobuf:"bytes,4,opt,name=bidder,proto3" json:"bidder,omitempty"` + Amount types.Coin `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount"` +} + +func (m *MsgWithdrawLimitBidRequest) Reset() { *m = MsgWithdrawLimitBidRequest{} } +func (m *MsgWithdrawLimitBidRequest) String() string { return proto.CompactTextString(m) } +func (*MsgWithdrawLimitBidRequest) ProtoMessage() {} +func (*MsgWithdrawLimitBidRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_f9a3512929bb96f1, []int{6} +} +func (m *MsgWithdrawLimitBidRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgWithdrawLimitBidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgWithdrawLimitBidRequest.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 *MsgWithdrawLimitBidRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgWithdrawLimitBidRequest.Merge(m, src) +} +func (m *MsgWithdrawLimitBidRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgWithdrawLimitBidRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgWithdrawLimitBidRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgWithdrawLimitBidRequest proto.InternalMessageInfo + +type MsgWithdrawLimitBidResponse struct { +} + +func (m *MsgWithdrawLimitBidResponse) Reset() { *m = MsgWithdrawLimitBidResponse{} } +func (m *MsgWithdrawLimitBidResponse) String() string { return proto.CompactTextString(m) } +func (*MsgWithdrawLimitBidResponse) ProtoMessage() {} +func (*MsgWithdrawLimitBidResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_f9a3512929bb96f1, []int{7} +} +func (m *MsgWithdrawLimitBidResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgWithdrawLimitBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgWithdrawLimitBidResponse.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 *MsgWithdrawLimitBidResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgWithdrawLimitBidResponse.Merge(m, src) +} +func (m *MsgWithdrawLimitBidResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgWithdrawLimitBidResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgWithdrawLimitBidResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgWithdrawLimitBidResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgPlaceMarketBidRequest)(nil), "comdex.auction.v2.MsgPlaceMarketBidRequest") + proto.RegisterType((*MsgPlaceMarketBidResponse)(nil), "comdex.auction.v2.MsgPlaceMarketBidResponse") + proto.RegisterType((*MsgDepositLimitBidRequest)(nil), "comdex.auction.v2.MsgDepositLimitBidRequest") + proto.RegisterType((*MsgDepositLimitBidResponse)(nil), "comdex.auction.v2.MsgDepositLimitBidResponse") + proto.RegisterType((*MsgCancelLimitBidRequest)(nil), "comdex.auction.v2.MsgCancelLimitBidRequest") + proto.RegisterType((*MsgCancelLimitBidResponse)(nil), "comdex.auction.v2.MsgCancelLimitBidResponse") + proto.RegisterType((*MsgWithdrawLimitBidRequest)(nil), "comdex.auction.v2.MsgWithdrawLimitBidRequest") + proto.RegisterType((*MsgWithdrawLimitBidResponse)(nil), "comdex.auction.v2.MsgWithdrawLimitBidResponse") +} + +func init() { proto.RegisterFile("comdex/auction/v2/tx.proto", fileDescriptor_f9a3512929bb96f1) } + +var fileDescriptor_f9a3512929bb96f1 = []byte{ + // 558 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x55, 0xc1, 0x6e, 0xd3, 0x30, + 0x18, 0x4e, 0xba, 0x52, 0xa9, 0x9e, 0x10, 0xd4, 0x43, 0xd0, 0x65, 0x2c, 0xad, 0x72, 0x40, 0x95, + 0xa0, 0x8e, 0xd6, 0x1d, 0x90, 0x38, 0x76, 0xbb, 0x54, 0xa2, 0x12, 0xaa, 0x40, 0x48, 0x5c, 0x2a, + 0x27, 0xf6, 0x3a, 0xab, 0x49, 0xdc, 0xc5, 0x4e, 0xd9, 0x5e, 0x81, 0x13, 0x8f, 0xc1, 0x13, 0xc0, + 0x2b, 0xf4, 0x84, 0x76, 0x44, 0x1c, 0x2a, 0x68, 0xdf, 0x80, 0x33, 0x07, 0x94, 0xd8, 0xb0, 0x6e, + 0x4d, 0xa4, 0x72, 0x86, 0x53, 0xe2, 0xff, 0xfb, 0xe4, 0xff, 0xfb, 0x3f, 0x7d, 0xb6, 0x81, 0xe5, + 0xf3, 0x90, 0xd0, 0x73, 0x17, 0x27, 0xbe, 0x64, 0x3c, 0x72, 0xa7, 0x1d, 0x57, 0x9e, 0xa3, 0x49, + 0xcc, 0x25, 0x87, 0x35, 0x85, 0x21, 0x8d, 0xa1, 0x69, 0xc7, 0xba, 0x37, 0xe2, 0x23, 0x9e, 0xa1, + 0x6e, 0xfa, 0xa7, 0x88, 0x96, 0xed, 0x73, 0x11, 0x72, 0xe1, 0x7a, 0x58, 0x50, 0x77, 0x7a, 0xe0, + 0x51, 0x89, 0x0f, 0x5c, 0x9f, 0xb3, 0x48, 0xe1, 0xce, 0x3b, 0x13, 0xd4, 0xfb, 0x62, 0xf4, 0x22, + 0xc0, 0x3e, 0xed, 0xe3, 0x78, 0x4c, 0x65, 0x97, 0x91, 0x01, 0x3d, 0x4b, 0xa8, 0x90, 0x70, 0x1f, + 0x00, 0xdd, 0x60, 0xc8, 0x48, 0xdd, 0x6c, 0x9a, 0xad, 0xf2, 0xa0, 0xaa, 0x2b, 0x3d, 0x02, 0xef, + 0x83, 0x8a, 0xc7, 0x08, 0xa1, 0x71, 0xbd, 0xd4, 0x34, 0x5b, 0xd5, 0x81, 0x5e, 0xc1, 0xa7, 0xa0, + 0x82, 0x43, 0x9e, 0x44, 0xb2, 0xbe, 0xd5, 0x34, 0x5b, 0xdb, 0x9d, 0x5d, 0xa4, 0x44, 0xa0, 0x54, + 0x04, 0xd2, 0x22, 0xd0, 0x11, 0x67, 0x51, 0xb7, 0x3c, 0x9b, 0x37, 0x8c, 0x81, 0xa6, 0x3b, 0x7b, + 0x60, 0x37, 0x47, 0x8b, 0x98, 0xf0, 0x48, 0x50, 0xe7, 0x63, 0x29, 0x43, 0x8f, 0xe9, 0x84, 0x0b, + 0x26, 0x9f, 0xb3, 0x90, 0xad, 0x4a, 0x45, 0x60, 0xc7, 0xe7, 0x41, 0x80, 0x25, 0x8d, 0x71, 0x30, + 0x94, 0x7c, 0x4c, 0x57, 0x34, 0xd7, 0xae, 0xa0, 0x97, 0x29, 0xd2, 0x23, 0xd0, 0x01, 0xb7, 0x09, + 0xf5, 0xe4, 0x15, 0xb3, 0x94, 0x31, 0xb7, 0xd3, 0xe2, 0x6f, 0x8e, 0x04, 0x77, 0x27, 0x31, 0x0d, + 0x59, 0x12, 0x0e, 0x09, 0x13, 0xfe, 0x9f, 0x89, 0xaa, 0xdd, 0x5e, 0x2a, 0xfb, 0xeb, 0xbc, 0xf1, + 0x68, 0xc4, 0xe4, 0x69, 0xe2, 0x21, 0x9f, 0x87, 0xae, 0x36, 0x5a, 0x7d, 0xda, 0x82, 0x8c, 0x5d, + 0x79, 0x31, 0xa1, 0x02, 0xf5, 0x22, 0xf9, 0x63, 0xde, 0x78, 0x70, 0x81, 0xc3, 0xe0, 0x99, 0x73, + 0x73, 0x3f, 0x67, 0x70, 0x47, 0x97, 0x8e, 0x75, 0x65, 0xc5, 0xd5, 0x72, 0x81, 0xab, 0xb7, 0xfe, + 0xce, 0xd5, 0x87, 0xc0, 0xca, 0xf3, 0x4d, 0xdb, 0xfa, 0x53, 0x05, 0xe0, 0x08, 0x47, 0x3e, 0x0d, + 0xfe, 0x39, 0x57, 0x75, 0xe4, 0x6e, 0x4e, 0xaf, 0xbd, 0xf9, 0x54, 0xca, 0xac, 0x7b, 0xcd, 0xe4, + 0x29, 0x89, 0xf1, 0xdb, 0xff, 0x99, 0xdb, 0x38, 0x73, 0xfb, 0x60, 0x2f, 0xd7, 0x38, 0x65, 0x6c, + 0xe7, 0xf3, 0x16, 0xd8, 0xea, 0x8b, 0x11, 0x8c, 0x40, 0x6d, 0xed, 0xc0, 0xc3, 0xc7, 0x68, 0xed, + 0x72, 0x43, 0x45, 0x57, 0x94, 0xf5, 0x64, 0x33, 0xb2, 0xea, 0x0b, 0xcf, 0x00, 0x5c, 0x3f, 0x0a, + 0xb0, 0x60, 0x8f, 0xfc, 0x9b, 0xc6, 0x6a, 0x6f, 0xc8, 0xd6, 0x2d, 0xd5, 0x88, 0xd7, 0x03, 0x56, + 0x34, 0x62, 0xee, 0x21, 0x2c, 0x1a, 0x31, 0x3f, 0xb3, 0x50, 0x82, 0x9d, 0x1c, 0xe7, 0x61, 0x81, + 0xea, 0x82, 0x68, 0x5b, 0x68, 0x53, 0xba, 0xea, 0xda, 0x7d, 0x35, 0xfb, 0x6e, 0x1b, 0x1f, 0x16, + 0xb6, 0x31, 0x5b, 0xd8, 0xe6, 0xe5, 0xc2, 0x36, 0xbf, 0x2d, 0x6c, 0xf3, 0xfd, 0xd2, 0x36, 0x2e, + 0x97, 0xb6, 0xf1, 0x65, 0x69, 0x1b, 0x6f, 0x0e, 0xaf, 0xc5, 0x36, 0xdd, 0xbb, 0xcd, 0x4f, 0x4e, + 0x98, 0xcf, 0x70, 0xa0, 0xd7, 0xee, 0xea, 0x53, 0x97, 0xe5, 0xd8, 0xab, 0x64, 0x8f, 0xd4, 0xe1, + 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, 0x58, 0xf1, 0x3f, 0x0b, 0x07, 0x00, 0x00, +} + +// 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 { + MsgPlaceMarketBid(ctx context.Context, in *MsgPlaceMarketBidRequest, opts ...grpc.CallOption) (*MsgPlaceMarketBidResponse, error) + MsgDepositLimitBid(ctx context.Context, in *MsgDepositLimitBidRequest, opts ...grpc.CallOption) (*MsgDepositLimitBidResponse, error) + MsgCancelLimitBid(ctx context.Context, in *MsgCancelLimitBidRequest, opts ...grpc.CallOption) (*MsgCancelLimitBidResponse, error) + MsgWithdrawLimitBid(ctx context.Context, in *MsgWithdrawLimitBidRequest, opts ...grpc.CallOption) (*MsgWithdrawLimitBidResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) MsgPlaceMarketBid(ctx context.Context, in *MsgPlaceMarketBidRequest, opts ...grpc.CallOption) (*MsgPlaceMarketBidResponse, error) { + out := new(MsgPlaceMarketBidResponse) + err := c.cc.Invoke(ctx, "/comdex.auction.v2.Msg/MsgPlaceMarketBid", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) MsgDepositLimitBid(ctx context.Context, in *MsgDepositLimitBidRequest, opts ...grpc.CallOption) (*MsgDepositLimitBidResponse, error) { + out := new(MsgDepositLimitBidResponse) + err := c.cc.Invoke(ctx, "/comdex.auction.v2.Msg/MsgDepositLimitBid", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) MsgCancelLimitBid(ctx context.Context, in *MsgCancelLimitBidRequest, opts ...grpc.CallOption) (*MsgCancelLimitBidResponse, error) { + out := new(MsgCancelLimitBidResponse) + err := c.cc.Invoke(ctx, "/comdex.auction.v2.Msg/MsgCancelLimitBid", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) MsgWithdrawLimitBid(ctx context.Context, in *MsgWithdrawLimitBidRequest, opts ...grpc.CallOption) (*MsgWithdrawLimitBidResponse, error) { + out := new(MsgWithdrawLimitBidResponse) + err := c.cc.Invoke(ctx, "/comdex.auction.v2.Msg/MsgWithdrawLimitBid", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + MsgPlaceMarketBid(context.Context, *MsgPlaceMarketBidRequest) (*MsgPlaceMarketBidResponse, error) + MsgDepositLimitBid(context.Context, *MsgDepositLimitBidRequest) (*MsgDepositLimitBidResponse, error) + MsgCancelLimitBid(context.Context, *MsgCancelLimitBidRequest) (*MsgCancelLimitBidResponse, error) + MsgWithdrawLimitBid(context.Context, *MsgWithdrawLimitBidRequest) (*MsgWithdrawLimitBidResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) MsgPlaceMarketBid(ctx context.Context, req *MsgPlaceMarketBidRequest) (*MsgPlaceMarketBidResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MsgPlaceMarketBid not implemented") +} +func (*UnimplementedMsgServer) MsgDepositLimitBid(ctx context.Context, req *MsgDepositLimitBidRequest) (*MsgDepositLimitBidResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MsgDepositLimitBid not implemented") +} +func (*UnimplementedMsgServer) MsgCancelLimitBid(ctx context.Context, req *MsgCancelLimitBidRequest) (*MsgCancelLimitBidResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MsgCancelLimitBid not implemented") +} +func (*UnimplementedMsgServer) MsgWithdrawLimitBid(ctx context.Context, req *MsgWithdrawLimitBidRequest) (*MsgWithdrawLimitBidResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MsgWithdrawLimitBid not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_MsgPlaceMarketBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgPlaceMarketBidRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MsgPlaceMarketBid(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.auction.v2.Msg/MsgPlaceMarketBid", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MsgPlaceMarketBid(ctx, req.(*MsgPlaceMarketBidRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_MsgDepositLimitBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgDepositLimitBidRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MsgDepositLimitBid(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.auction.v2.Msg/MsgDepositLimitBid", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MsgDepositLimitBid(ctx, req.(*MsgDepositLimitBidRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_MsgCancelLimitBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgCancelLimitBidRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MsgCancelLimitBid(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.auction.v2.Msg/MsgCancelLimitBid", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MsgCancelLimitBid(ctx, req.(*MsgCancelLimitBidRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_MsgWithdrawLimitBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgWithdrawLimitBidRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MsgWithdrawLimitBid(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.auction.v2.Msg/MsgWithdrawLimitBid", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MsgWithdrawLimitBid(ctx, req.(*MsgWithdrawLimitBidRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "comdex.auction.v2.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "MsgPlaceMarketBid", + Handler: _Msg_MsgPlaceMarketBid_Handler, + }, + { + MethodName: "MsgDepositLimitBid", + Handler: _Msg_MsgDepositLimitBid_Handler, + }, + { + MethodName: "MsgCancelLimitBid", + Handler: _Msg_MsgCancelLimitBid_Handler, + }, + { + MethodName: "MsgWithdrawLimitBid", + Handler: _Msg_MsgWithdrawLimitBid_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "comdex/auction/v2/tx.proto", +} + +func (m *MsgPlaceMarketBidRequest) 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 *MsgPlaceMarketBidRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgPlaceMarketBidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.Bidder) > 0 { + i -= len(m.Bidder) + copy(dAtA[i:], m.Bidder) + i = encodeVarintTx(dAtA, i, uint64(len(m.Bidder))) + i-- + dAtA[i] = 0x12 + } + if m.AuctionId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.AuctionId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgPlaceMarketBidResponse) 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 *MsgPlaceMarketBidResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgPlaceMarketBidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgDepositLimitBidRequest) 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 *MsgDepositLimitBidRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDepositLimitBidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if len(m.Bidder) > 0 { + i -= len(m.Bidder) + copy(dAtA[i:], m.Bidder) + i = encodeVarintTx(dAtA, i, uint64(len(m.Bidder))) + i-- + dAtA[i] = 0x22 + } + { + size := m.PremiumDiscount.Size() + i -= size + if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.DebtTokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.DebtTokenId)) + i-- + dAtA[i] = 0x10 + } + if m.CollateralTokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CollateralTokenId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgDepositLimitBidResponse) 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 *MsgDepositLimitBidResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgDepositLimitBidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgCancelLimitBidRequest) 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 *MsgCancelLimitBidRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCancelLimitBidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Bidder) > 0 { + i -= len(m.Bidder) + copy(dAtA[i:], m.Bidder) + i = encodeVarintTx(dAtA, i, uint64(len(m.Bidder))) + i-- + dAtA[i] = 0x22 + } + { + size := m.PremiumDiscount.Size() + i -= size + if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.DebtTokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.DebtTokenId)) + i-- + dAtA[i] = 0x10 + } + if m.CollateralTokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CollateralTokenId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgCancelLimitBidResponse) 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 *MsgCancelLimitBidResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgCancelLimitBidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawLimitBidRequest) 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 *MsgWithdrawLimitBidRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawLimitBidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if len(m.Bidder) > 0 { + i -= len(m.Bidder) + copy(dAtA[i:], m.Bidder) + i = encodeVarintTx(dAtA, i, uint64(len(m.Bidder))) + i-- + dAtA[i] = 0x22 + } + { + size := m.PremiumDiscount.Size() + i -= size + if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.DebtTokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.DebtTokenId)) + i-- + dAtA[i] = 0x10 + } + if m.CollateralTokenId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CollateralTokenId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgWithdrawLimitBidResponse) 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 *MsgWithdrawLimitBidResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgWithdrawLimitBidResponse) 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 *MsgPlaceMarketBidRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AuctionId != 0 { + n += 1 + sovTx(uint64(m.AuctionId)) + } + l = len(m.Bidder) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgPlaceMarketBidResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgDepositLimitBidRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CollateralTokenId != 0 { + n += 1 + sovTx(uint64(m.CollateralTokenId)) + } + if m.DebtTokenId != 0 { + n += 1 + sovTx(uint64(m.DebtTokenId)) + } + l = m.PremiumDiscount.Size() + n += 1 + l + sovTx(uint64(l)) + l = len(m.Bidder) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgDepositLimitBidResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgCancelLimitBidRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CollateralTokenId != 0 { + n += 1 + sovTx(uint64(m.CollateralTokenId)) + } + if m.DebtTokenId != 0 { + n += 1 + sovTx(uint64(m.DebtTokenId)) + } + l = m.PremiumDiscount.Size() + n += 1 + l + sovTx(uint64(l)) + l = len(m.Bidder) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgCancelLimitBidResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgWithdrawLimitBidRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CollateralTokenId != 0 { + n += 1 + sovTx(uint64(m.CollateralTokenId)) + } + if m.DebtTokenId != 0 { + n += 1 + sovTx(uint64(m.DebtTokenId)) + } + l = m.PremiumDiscount.Size() + n += 1 + l + sovTx(uint64(l)) + l = len(m.Bidder) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgWithdrawLimitBidResponse) 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 *MsgPlaceMarketBidRequest) 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: MsgPlaceMarketBidRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgPlaceMarketBidRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType) + } + m.AuctionId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AuctionId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bidder", 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.Bidder = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 err := m.Amount.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 *MsgPlaceMarketBidResponse) 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: MsgPlaceMarketBidResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgPlaceMarketBidResponse: 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 *MsgDepositLimitBidRequest) 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: MsgDepositLimitBidRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDepositLimitBidRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) + } + m.CollateralTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CollateralTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) + } + m.DebtTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebtTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", 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.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bidder", 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.Bidder = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 err := m.Amount.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 *MsgDepositLimitBidResponse) 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: MsgDepositLimitBidResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgDepositLimitBidResponse: 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 *MsgCancelLimitBidRequest) 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: MsgCancelLimitBidRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCancelLimitBidRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) + } + m.CollateralTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CollateralTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) + } + m.DebtTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebtTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", 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.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bidder", 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.Bidder = 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 *MsgCancelLimitBidResponse) 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: MsgCancelLimitBidResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCancelLimitBidResponse: 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 *MsgWithdrawLimitBidRequest) 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: MsgWithdrawLimitBidRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawLimitBidRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) + } + m.CollateralTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CollateralTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) + } + m.DebtTokenId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebtTokenId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", 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.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bidder", 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.Bidder = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 err := m.Amount.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 *MsgWithdrawLimitBidResponse) 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: MsgWithdrawLimitBidResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgWithdrawLimitBidResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquidation/v2types/genesis.pb.go b/x/liquidation/v2types/genesis.pb.go new file mode 100644 index 000000000..91ea2e080 --- /dev/null +++ b/x/liquidation/v2types/genesis.pb.go @@ -0,0 +1,322 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/liquidation/v2/genesis.proto + +package v2types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type GenesisState struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *GenesisState) Reset() { *m = GenesisState{} } +func (m *GenesisState) String() string { return proto.CompactTextString(m) } +func (*GenesisState) ProtoMessage() {} +func (*GenesisState) Descriptor() ([]byte, []int) { + return fileDescriptor_9f9021f2fff7cb6b, []int{0} +} +func (m *GenesisState) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { + xxx_messageInfo_GenesisState.Merge(m, src) +} +func (m *GenesisState) XXX_Size() int { + return m.Size() +} +func (m *GenesisState) XXX_DiscardUnknown() { + xxx_messageInfo_GenesisState.DiscardUnknown(m) +} + +var xxx_messageInfo_GenesisState proto.InternalMessageInfo + +func (m *GenesisState) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func init() { + proto.RegisterType((*GenesisState)(nil), "comdex.liquidation.v2.GenesisState") +} + +func init() { + proto.RegisterFile("comdex/liquidation/v2/genesis.proto", fileDescriptor_9f9021f2fff7cb6b) +} + +var fileDescriptor_9f9021f2fff7cb6b = []byte{ + // 203 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4e, 0xce, 0xcf, 0x4d, + 0x49, 0xad, 0xd0, 0xcf, 0xc9, 0x2c, 0x2c, 0xcd, 0x4c, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, + 0x33, 0xd2, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, + 0x12, 0x85, 0x28, 0xd2, 0x43, 0x52, 0xa4, 0x57, 0x66, 0x24, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, + 0x56, 0xa1, 0x0f, 0x62, 0x41, 0x14, 0x4b, 0x29, 0x61, 0x37, 0xb1, 0x20, 0xb1, 0x28, 0x31, 0x17, + 0x6a, 0xa0, 0x92, 0x37, 0x17, 0x8f, 0x3b, 0xc4, 0x86, 0xe0, 0x92, 0xc4, 0x92, 0x54, 0x21, 0x6b, + 0x2e, 0x36, 0x88, 0xbc, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb7, 0x91, 0xac, 0x1e, 0x56, 0x1b, 0xf5, + 0x02, 0xc0, 0x8a, 0x9c, 0x58, 0x4e, 0xdc, 0x93, 0x67, 0x08, 0x82, 0x6a, 0x71, 0x0a, 0x3c, 0xf1, + 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, + 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xf3, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, + 0x90, 0x61, 0xfa, 0x10, 0x03, 0x75, 0xf3, 0xd3, 0xd2, 0x32, 0x93, 0x33, 0x13, 0x73, 0xa0, 0x7c, + 0x7d, 0x74, 0x77, 0x96, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x9d, 0x69, 0x0c, 0x08, 0x00, + 0x00, 0xff, 0xff, 0xea, 0x8a, 0xa0, 0xd1, 0x1e, 0x01, 0x00, 0x00, +} + +func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *GenesisState) 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 = encodeVarintGenesis(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { + offset -= sovGenesis(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *GenesisState) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovGenesis(uint64(l)) + return n +} + +func sovGenesis(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGenesis(x uint64) (n int) { + return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *GenesisState) 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 ErrIntOverflowGenesis + } + 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: GenesisState: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenesis + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenesis + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenesis + } + 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 := skipGenesis(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenesis + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenesis(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenesis + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGenesis + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGenesis + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGenesis + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquidation/v2types/gov.pb.go b/x/liquidation/v2types/gov.pb.go new file mode 100644 index 000000000..6431b349a --- /dev/null +++ b/x/liquidation/v2types/gov.pb.go @@ -0,0 +1,407 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/liquidation/v2/gov.proto + +package v2types + +import ( + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type WhitelistLiquidationProposal struct { + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty" yaml:"title"` + Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"` + Whitelisting LiquidationWhiteListing `protobuf:"bytes,3,opt,name=whitelisting,proto3" json:"whitelisting"` +} + +func (m *WhitelistLiquidationProposal) Reset() { *m = WhitelistLiquidationProposal{} } +func (m *WhitelistLiquidationProposal) String() string { return proto.CompactTextString(m) } +func (*WhitelistLiquidationProposal) ProtoMessage() {} +func (*WhitelistLiquidationProposal) Descriptor() ([]byte, []int) { + return fileDescriptor_a3d7b286df81d8d3, []int{0} +} +func (m *WhitelistLiquidationProposal) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *WhitelistLiquidationProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_WhitelistLiquidationProposal.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 *WhitelistLiquidationProposal) XXX_Merge(src proto.Message) { + xxx_messageInfo_WhitelistLiquidationProposal.Merge(m, src) +} +func (m *WhitelistLiquidationProposal) XXX_Size() int { + return m.Size() +} +func (m *WhitelistLiquidationProposal) XXX_DiscardUnknown() { + xxx_messageInfo_WhitelistLiquidationProposal.DiscardUnknown(m) +} + +var xxx_messageInfo_WhitelistLiquidationProposal proto.InternalMessageInfo + +func init() { + proto.RegisterType((*WhitelistLiquidationProposal)(nil), "comdex.liquidation.v2.WhitelistLiquidationProposal") +} + +func init() { proto.RegisterFile("comdex/liquidation/v2/gov.proto", fileDescriptor_a3d7b286df81d8d3) } + +var fileDescriptor_a3d7b286df81d8d3 = []byte{ + // 291 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xce, 0xcf, 0x4d, + 0x49, 0xad, 0xd0, 0xcf, 0xc9, 0x2c, 0x2c, 0xcd, 0x4c, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, + 0x33, 0xd2, 0x4f, 0xcf, 0x2f, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x85, 0x28, 0xd0, + 0x43, 0x52, 0xa0, 0x57, 0x66, 0x24, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, 0x56, 0xa1, 0x0f, 0x62, + 0x41, 0x14, 0x4b, 0xa9, 0x62, 0x37, 0x0d, 0xc6, 0x4d, 0x85, 0x28, 0x53, 0xba, 0xc5, 0xc8, 0x25, + 0x13, 0x9e, 0x91, 0x59, 0x92, 0x9a, 0x93, 0x59, 0x5c, 0xe2, 0x83, 0x50, 0x1b, 0x50, 0x94, 0x5f, + 0x90, 0x5f, 0x9c, 0x98, 0x23, 0xa4, 0xc6, 0xc5, 0x5a, 0x92, 0x59, 0x92, 0x93, 0x2a, 0xc1, 0xa8, + 0xc0, 0xa8, 0xc1, 0xe9, 0x24, 0xf0, 0xe9, 0x9e, 0x3c, 0x4f, 0x65, 0x62, 0x6e, 0x8e, 0x95, 0x12, + 0x58, 0x58, 0x29, 0x08, 0x22, 0x2d, 0x64, 0xc1, 0xc5, 0x9d, 0x92, 0x5a, 0x9c, 0x5c, 0x94, 0x59, + 0x00, 0xd2, 0x2e, 0xc1, 0x04, 0x56, 0x2d, 0xf6, 0xe9, 0x9e, 0xbc, 0x10, 0x44, 0x35, 0x92, 0xa4, + 0x52, 0x10, 0xb2, 0x52, 0xa1, 0x08, 0x2e, 0x9e, 0x72, 0x98, 0x0b, 0x32, 0xf3, 0xd2, 0x25, 0x98, + 0x15, 0x18, 0x35, 0xb8, 0x8d, 0xf4, 0xf4, 0xb0, 0xfa, 0x56, 0x0f, 0xc9, 0x8d, 0x60, 0x77, 0xfb, + 0x40, 0x74, 0x39, 0xb1, 0x9c, 0xb8, 0x27, 0xcf, 0x10, 0x84, 0x62, 0x92, 0x53, 0xe4, 0x89, 0x87, + 0x72, 0x0c, 0x2b, 0x1e, 0xc9, 0x31, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, + 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, + 0x94, 0x79, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x12, 0xc8, 0x2e, 0x7d, 0x88, 0x7d, 0xba, 0xf9, 0x69, + 0x69, 0x99, 0xc9, 0x99, 0x89, 0x39, 0x50, 0xbe, 0x3e, 0x7a, 0x10, 0x96, 0x54, 0x16, 0xa4, 0x16, + 0x27, 0xb1, 0x81, 0x83, 0xcf, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x1c, 0xbb, 0x82, 0xb5, + 0x01, 0x00, 0x00, +} + +func (m *WhitelistLiquidationProposal) 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 *WhitelistLiquidationProposal) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *WhitelistLiquidationProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Whitelisting.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintGov(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.Description) > 0 { + i -= len(m.Description) + copy(dAtA[i:], m.Description) + i = encodeVarintGov(dAtA, i, uint64(len(m.Description))) + i-- + dAtA[i] = 0x12 + } + if len(m.Title) > 0 { + i -= len(m.Title) + copy(dAtA[i:], m.Title) + i = encodeVarintGov(dAtA, i, uint64(len(m.Title))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintGov(dAtA []byte, offset int, v uint64) int { + offset -= sovGov(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *WhitelistLiquidationProposal) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Title) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + l = len(m.Description) + if l > 0 { + n += 1 + l + sovGov(uint64(l)) + } + l = m.Whitelisting.Size() + n += 1 + l + sovGov(uint64(l)) + return n +} + +func sovGov(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozGov(x uint64) (n int) { + return sovGov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *WhitelistLiquidationProposal) 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 ErrIntOverflowGov + } + 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: WhitelistLiquidationProposal: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WhitelistLiquidationProposal: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Title = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + 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 ErrInvalidLengthGov + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Description = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Whitelisting", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGov + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGov + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGov + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Whitelisting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGov(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGov + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGov(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGov + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGov + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGov + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthGov + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupGov + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthGov + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthGov = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGov = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupGov = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquidation/v2types/liquidate.pb.go b/x/liquidation/v2types/liquidate.pb.go new file mode 100644 index 000000000..f8290d147 --- /dev/null +++ b/x/liquidation/v2types/liquidate.pb.go @@ -0,0 +1,2867 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/liquidation/v2/liquidate.proto + +package v2types + +import ( + fmt "fmt" + _ "github.com/cosmos/cosmos-sdk/types" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type LiquidationWhiteListing struct { + AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` + //AuctionTriggerer + //External Apps -------------> If external triggerer , then some params will be used from Comdex base app // If internal app triggerrer then params to be used from base app + //Comdex Apps + //bool param + //true - comdex apps + //false external apps + Initiator bool `protobuf:"varint,6,opt,name=initiator,proto3" json:"initiator,omitempty" yaml:"initiator"` + //Sets of Params for Dutch Auction + IsDutchActivated bool `protobuf:"varint,7,opt,name=is_dutch_activated,json=isDutchActivated,proto3" json:"is_dutch_activated,omitempty" yaml:"is_dutch_activated"` + DutchAuctionParam *DutchAuctionParam `protobuf:"bytes,8,opt,name=dutch_auction_param,json=dutchAuctionParam,proto3" json:"dutch_auction_param,omitempty" yaml:"dutch_auction_param"` + //Sets of Params for English Auction + IsEnglishActivated bool `protobuf:"varint,9,opt,name=is_english_activated,json=isEnglishActivated,proto3" json:"is_english_activated,omitempty" yaml:"is_english_activated"` + EnglishAuctionParam *EnglishAuctionParam `protobuf:"bytes,10,opt,name=english_auction_param,json=englishAuctionParam,proto3" json:"english_auction_param,omitempty" yaml:"english_auction_param"` + KeeeperIncentive github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,11,opt,name=keeeper_incentive,json=keeeperIncentive,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"keeeper_incentive" yaml:"keeper_incentive"` +} + +func (m *LiquidationWhiteListing) Reset() { *m = LiquidationWhiteListing{} } +func (m *LiquidationWhiteListing) String() string { return proto.CompactTextString(m) } +func (*LiquidationWhiteListing) ProtoMessage() {} +func (*LiquidationWhiteListing) Descriptor() ([]byte, []int) { + return fileDescriptor_5b5ec44ce2c32c8b, []int{0} +} +func (m *LiquidationWhiteListing) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidationWhiteListing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidationWhiteListing.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 *LiquidationWhiteListing) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidationWhiteListing.Merge(m, src) +} +func (m *LiquidationWhiteListing) XXX_Size() int { + return m.Size() +} +func (m *LiquidationWhiteListing) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidationWhiteListing.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidationWhiteListing proto.InternalMessageInfo + +type AppReserveFunds struct { + AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` + AssetId uint64 `protobuf:"varint,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty" yaml:"asset_id"` + TokenQuantity github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=token_quantity,json=tokenQuantity,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"token_quantity" yaml:"token_quantity"` +} + +func (m *AppReserveFunds) Reset() { *m = AppReserveFunds{} } +func (m *AppReserveFunds) String() string { return proto.CompactTextString(m) } +func (*AppReserveFunds) ProtoMessage() {} +func (*AppReserveFunds) Descriptor() ([]byte, []int) { + return fileDescriptor_5b5ec44ce2c32c8b, []int{1} +} +func (m *AppReserveFunds) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppReserveFunds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AppReserveFunds.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 *AppReserveFunds) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppReserveFunds.Merge(m, src) +} +func (m *AppReserveFunds) XXX_Size() int { + return m.Size() +} +func (m *AppReserveFunds) XXX_DiscardUnknown() { + xxx_messageInfo_AppReserveFunds.DiscardUnknown(m) +} + +var xxx_messageInfo_AppReserveFunds proto.InternalMessageInfo + +type AppReserveFundsTxData struct { + AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` + AssetTxData []AssetTxData `protobuf:"bytes,2,rep,name=asset_tx_data,json=assetTxData,proto3" json:"asset_tx_data" yaml:"asset_tx_data"` +} + +func (m *AppReserveFundsTxData) Reset() { *m = AppReserveFundsTxData{} } +func (m *AppReserveFundsTxData) String() string { return proto.CompactTextString(m) } +func (*AppReserveFundsTxData) ProtoMessage() {} +func (*AppReserveFundsTxData) Descriptor() ([]byte, []int) { + return fileDescriptor_5b5ec44ce2c32c8b, []int{2} +} +func (m *AppReserveFundsTxData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AppReserveFundsTxData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AppReserveFundsTxData.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 *AppReserveFundsTxData) XXX_Merge(src proto.Message) { + xxx_messageInfo_AppReserveFundsTxData.Merge(m, src) +} +func (m *AppReserveFundsTxData) XXX_Size() int { + return m.Size() +} +func (m *AppReserveFundsTxData) XXX_DiscardUnknown() { + xxx_messageInfo_AppReserveFundsTxData.DiscardUnknown(m) +} + +var xxx_messageInfo_AppReserveFundsTxData proto.InternalMessageInfo + +type AssetTxData struct { + AssetId uint64 `protobuf:"varint,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty" yaml:"asset_id"` + TxType string `protobuf:"bytes,2,opt,name=tx_type,json=txType,proto3" json:"tx_type,omitempty" yaml:"tx_type"` + TokenQuantity github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=token_quantity,json=tokenQuantity,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"token_quantity" yaml:"token_quantity"` +} + +func (m *AssetTxData) Reset() { *m = AssetTxData{} } +func (m *AssetTxData) String() string { return proto.CompactTextString(m) } +func (*AssetTxData) ProtoMessage() {} +func (*AssetTxData) Descriptor() ([]byte, []int) { + return fileDescriptor_5b5ec44ce2c32c8b, []int{3} +} +func (m *AssetTxData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AssetTxData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AssetTxData.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 *AssetTxData) XXX_Merge(src proto.Message) { + xxx_messageInfo_AssetTxData.Merge(m, src) +} +func (m *AssetTxData) XXX_Size() int { + return m.Size() +} +func (m *AssetTxData) XXX_DiscardUnknown() { + xxx_messageInfo_AssetTxData.DiscardUnknown(m) +} + +var xxx_messageInfo_AssetTxData proto.InternalMessageInfo + +type DutchAuctionParam struct { + Premium github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=premium,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"premium" yaml:"premium"` + Discount github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=discount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"discount" yaml:"discount"` + DecrementFactor github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=decrement_factor,json=decrementFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"decrement_factor" yaml:"decrement_factor"` +} + +func (m *DutchAuctionParam) Reset() { *m = DutchAuctionParam{} } +func (m *DutchAuctionParam) String() string { return proto.CompactTextString(m) } +func (*DutchAuctionParam) ProtoMessage() {} +func (*DutchAuctionParam) Descriptor() ([]byte, []int) { + return fileDescriptor_5b5ec44ce2c32c8b, []int{4} +} +func (m *DutchAuctionParam) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DutchAuctionParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DutchAuctionParam.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 *DutchAuctionParam) XXX_Merge(src proto.Message) { + xxx_messageInfo_DutchAuctionParam.Merge(m, src) +} +func (m *DutchAuctionParam) XXX_Size() int { + return m.Size() +} +func (m *DutchAuctionParam) XXX_DiscardUnknown() { + xxx_messageInfo_DutchAuctionParam.DiscardUnknown(m) +} + +var xxx_messageInfo_DutchAuctionParam proto.InternalMessageInfo + +type EnglishAuctionParam struct { + DecrementFactor github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=decrement_factor,json=decrementFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"decrement_factor" yaml:"decrement_factor"` +} + +func (m *EnglishAuctionParam) Reset() { *m = EnglishAuctionParam{} } +func (m *EnglishAuctionParam) String() string { return proto.CompactTextString(m) } +func (*EnglishAuctionParam) ProtoMessage() {} +func (*EnglishAuctionParam) Descriptor() ([]byte, []int) { + return fileDescriptor_5b5ec44ce2c32c8b, []int{5} +} +func (m *EnglishAuctionParam) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EnglishAuctionParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EnglishAuctionParam.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 *EnglishAuctionParam) XXX_Merge(src proto.Message) { + xxx_messageInfo_EnglishAuctionParam.Merge(m, src) +} +func (m *EnglishAuctionParam) XXX_Size() int { + return m.Size() +} +func (m *EnglishAuctionParam) XXX_DiscardUnknown() { + xxx_messageInfo_EnglishAuctionParam.DiscardUnknown(m) +} + +var xxx_messageInfo_EnglishAuctionParam proto.InternalMessageInfo + +type LiquidationOffsetHolder struct { + AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"id"` + CurrentOffset uint64 `protobuf:"varint,2,opt,name=current_offset,json=currentOffset,proto3" json:"current_offset,omitempty"` +} + +func (m *LiquidationOffsetHolder) Reset() { *m = LiquidationOffsetHolder{} } +func (m *LiquidationOffsetHolder) String() string { return proto.CompactTextString(m) } +func (*LiquidationOffsetHolder) ProtoMessage() {} +func (*LiquidationOffsetHolder) Descriptor() ([]byte, []int) { + return fileDescriptor_5b5ec44ce2c32c8b, []int{6} +} +func (m *LiquidationOffsetHolder) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LiquidationOffsetHolder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LiquidationOffsetHolder.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 *LiquidationOffsetHolder) XXX_Merge(src proto.Message) { + xxx_messageInfo_LiquidationOffsetHolder.Merge(m, src) +} +func (m *LiquidationOffsetHolder) XXX_Size() int { + return m.Size() +} +func (m *LiquidationOffsetHolder) XXX_DiscardUnknown() { + xxx_messageInfo_LiquidationOffsetHolder.DiscardUnknown(m) +} + +var xxx_messageInfo_LiquidationOffsetHolder proto.InternalMessageInfo + +type LockedVault struct { + LockedVaultId uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" yaml:"id"` + AppId uint64 `protobuf:"varint,2,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"id"` + OriginalVaultId uint64 `protobuf:"varint,3,opt,name=original_vault_id,json=originalVaultId,proto3" json:"original_vault_id,omitempty" yaml:"id"` + ExtendedPairId uint64 `protobuf:"varint,4,opt,name=extended_pair_vault_id,json=extendedPairVaultId,proto3" json:"extended_pair_vault_id,omitempty" yaml:"extended_pair_vault_id"` + Owner string `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty" yaml:"owner"` + CollateralToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,6,opt,name=collateral_token,json=collateralToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_token" yaml:"collateral_token"` + DebtToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,7,opt,name=debt_token,json=debtToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token" yaml:"debt_token"` + CurrentCollaterlisationRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=current_collateralisation_ratio,json=currentCollateralisationRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"current_collateralisation_ratio" yaml:"current_collateralisation_ratio"` + CollateralToBeAuctioned github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,9,opt,name=collateral_to_be_auctioned,json=collateralToBeAuctioned,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_to_be_auctioned" yaml:"CollateralToBeAuctioned"` + TargetDebt github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,10,opt,name=target_debt,json=targetDebt,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"target_debt" yaml:"target_debt"` + LiquidationTimestamp time.Time `protobuf:"bytes,11,opt,name=liquidation_timestamp,json=liquidationTimestamp,proto3,stdtime" json:"liquidation_timestamp" yaml:"liquidation_timestamp"` + // true for internal liquidator through bot , false if abci initiated liquidation + IsInternalKeeper bool `protobuf:"varint,12,opt,name=is_internal_keeper,json=isInternalKeeper,proto3" json:"is_internal_keeper,omitempty" yaml:"is_intenal_keeper"` + InternalKeeperAddress string `protobuf:"bytes,13,opt,name=internal_keeper_address,json=internalKeeperAddress,proto3" json:"internal_keeper_address,omitempty" yaml:"internal_keeper_address"` + //To return funds to the external app back + ExternalKeeperAddress string `protobuf:"bytes,15,opt,name=external_keeper_address,json=externalKeeperAddress,proto3" json:"external_keeper_address,omitempty" yaml:"external_keeper_address"` + FeeToBeCollected github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,16,opt,name=fee_to_be_collected,json=feeToBeCollected,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"fee_to_be_collected" yaml:"fee_to_be_collected"` + BonusToBeGiven github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,17,opt,name=bonus_to_be_given,json=bonusToBeGiven,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonus_to_be_given" yaml:"bonus_to_be_given"` + InitiatorType string `protobuf:"bytes,18,opt,name=initiator_type,json=initiatorType,proto3" json:"initiator_type,omitempty" yaml:"initiator_type"` + AuctionType bool `protobuf:"varint,19,opt,name=auction_type,json=auctionType,proto3" json:"auction_type,omitempty" yaml:"auction_type"` + IsDebtCmst bool `protobuf:"varint,20,opt,name=is_debt_cmst,json=isDebtCmst,proto3" json:"is_debt_cmst,omitempty" yaml:"is_debt_cmst"` + // uint64 pair_id = 21 [ + // (gogoproto.customname) = "PairId", + // (gogoproto.moretags) = "yaml:\"pair_id\""]; + CollateralAssetId uint64 `protobuf:"varint,21,opt,name=collateral_asset_id,json=collateralAssetId,proto3" json:"collateral_asset_id,omitempty" yaml:"collateral_asset_id"` + DebtAssetId uint64 `protobuf:"varint,22,opt,name=debt_asset_id,json=debtAssetId,proto3" json:"debt_asset_id,omitempty" yaml:"debt_asset_id"` +} + +func (m *LockedVault) Reset() { *m = LockedVault{} } +func (m *LockedVault) String() string { return proto.CompactTextString(m) } +func (*LockedVault) ProtoMessage() {} +func (*LockedVault) Descriptor() ([]byte, []int) { + return fileDescriptor_5b5ec44ce2c32c8b, []int{7} +} +func (m *LockedVault) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LockedVault) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LockedVault.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 *LockedVault) XXX_Merge(src proto.Message) { + xxx_messageInfo_LockedVault.Merge(m, src) +} +func (m *LockedVault) XXX_Size() int { + return m.Size() +} +func (m *LockedVault) XXX_DiscardUnknown() { + xxx_messageInfo_LockedVault.DiscardUnknown(m) +} + +var xxx_messageInfo_LockedVault proto.InternalMessageInfo + +func init() { + proto.RegisterType((*LiquidationWhiteListing)(nil), "comdex.liquidation.v2.LiquidationWhiteListing") + proto.RegisterType((*AppReserveFunds)(nil), "comdex.liquidation.v2.AppReserveFunds") + proto.RegisterType((*AppReserveFundsTxData)(nil), "comdex.liquidation.v2.AppReserveFundsTxData") + proto.RegisterType((*AssetTxData)(nil), "comdex.liquidation.v2.AssetTxData") + proto.RegisterType((*DutchAuctionParam)(nil), "comdex.liquidation.v2.DutchAuctionParam") + proto.RegisterType((*EnglishAuctionParam)(nil), "comdex.liquidation.v2.EnglishAuctionParam") + proto.RegisterType((*LiquidationOffsetHolder)(nil), "comdex.liquidation.v2.LiquidationOffsetHolder") + proto.RegisterType((*LockedVault)(nil), "comdex.liquidation.v2.LockedVault") +} + +func init() { + proto.RegisterFile("comdex/liquidation/v2/liquidate.proto", fileDescriptor_5b5ec44ce2c32c8b) +} + +var fileDescriptor_5b5ec44ce2c32c8b = []byte{ + // 1597 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x5d, 0x6f, 0x1b, 0x45, + 0x17, 0xce, 0x3a, 0xcd, 0x87, 0xc7, 0x71, 0x62, 0x4f, 0xe2, 0xc6, 0xcd, 0xdb, 0x7a, 0xf3, 0xae, + 0xd4, 0xbe, 0x51, 0xab, 0xda, 0x6f, 0x52, 0xa1, 0x8a, 0x0f, 0x09, 0xe2, 0x24, 0x6d, 0x0d, 0x11, + 0x6d, 0x57, 0x11, 0x88, 0x0a, 0x58, 0xc6, 0xbb, 0x63, 0x67, 0x14, 0x7b, 0xd7, 0xdd, 0x1d, 0x1b, + 0xe7, 0x06, 0x09, 0x6e, 0x90, 0xf8, 0x10, 0xe5, 0x8a, 0xbf, 0x00, 0xbf, 0x02, 0x2e, 0xb8, 0xa8, + 0xb8, 0xea, 0x25, 0xe2, 0x62, 0x81, 0xed, 0x3f, 0xf0, 0x1d, 0x5c, 0xa1, 0xf9, 0x58, 0xef, 0xda, + 0xd9, 0x84, 0xba, 0x12, 0x12, 0x37, 0x75, 0x77, 0xce, 0x79, 0x9e, 0x73, 0xe6, 0xcc, 0x99, 0x33, + 0xe7, 0x04, 0x5c, 0x36, 0x9d, 0xb6, 0x85, 0xfb, 0x95, 0x16, 0x79, 0xd8, 0x25, 0x16, 0xa2, 0xc4, + 0xb1, 0x2b, 0xbd, 0xad, 0xe1, 0x27, 0x2e, 0x77, 0x5c, 0x87, 0x3a, 0xb0, 0x20, 0xd4, 0xca, 0x31, + 0xb5, 0x72, 0x6f, 0x6b, 0x6d, 0xa5, 0xe9, 0x34, 0x1d, 0xae, 0x51, 0x61, 0xff, 0x13, 0xca, 0x6b, + 0x6a, 0xd3, 0x71, 0x9a, 0x2d, 0x5c, 0xe1, 0x5f, 0xf5, 0x6e, 0xa3, 0x42, 0x49, 0x1b, 0x7b, 0x14, + 0xb5, 0x3b, 0x52, 0xa1, 0x64, 0x3a, 0x5e, 0xdb, 0xf1, 0x2a, 0x75, 0xe4, 0xe1, 0x4a, 0x6f, 0xb3, + 0x8e, 0x29, 0xda, 0xac, 0x98, 0x0e, 0xb1, 0x85, 0x5c, 0xfb, 0x63, 0x06, 0xac, 0xee, 0x47, 0x96, + 0xde, 0x3e, 0x24, 0x14, 0xef, 0x13, 0x8f, 0x12, 0xbb, 0x09, 0x37, 0xc1, 0x2c, 0xea, 0x74, 0x0c, + 0x62, 0x15, 0x95, 0x75, 0x65, 0xe3, 0x5c, 0x75, 0x2d, 0xf0, 0xd5, 0x99, 0xed, 0x4e, 0xa7, 0x66, + 0x0d, 0x7c, 0x35, 0x7b, 0x8c, 0xda, 0xad, 0x97, 0x34, 0xa1, 0xa0, 0xe9, 0x33, 0x88, 0xad, 0xc3, + 0x57, 0x41, 0x9a, 0xd8, 0x84, 0x12, 0x44, 0x1d, 0xb7, 0x38, 0xbb, 0xae, 0x6c, 0xcc, 0x57, 0xff, + 0x1b, 0xf8, 0x6a, 0xba, 0x16, 0x2e, 0x0e, 0x7c, 0x35, 0x27, 0x90, 0x43, 0x3d, 0x4d, 0x8f, 0x30, + 0xd0, 0x00, 0x90, 0x78, 0x86, 0xd5, 0xa5, 0xe6, 0xa1, 0x81, 0x4c, 0x4a, 0x7a, 0x88, 0x62, 0xab, + 0x38, 0xc7, 0x99, 0x36, 0x03, 0x5f, 0xcd, 0xd5, 0xbc, 0x5d, 0x26, 0xdc, 0x0e, 0x65, 0x03, 0x5f, + 0xbd, 0x20, 0x09, 0x4f, 0xe0, 0x34, 0x3d, 0x47, 0xc6, 0xd4, 0xe1, 0x97, 0x0a, 0x58, 0x96, 0x6a, + 0x5d, 0x93, 0x6d, 0xd9, 0xe8, 0x20, 0x17, 0xb5, 0x8b, 0xf3, 0xeb, 0xca, 0x46, 0x66, 0x6b, 0xa3, + 0x9c, 0x18, 0xfd, 0xb2, 0x20, 0x11, 0x80, 0x7b, 0x4c, 0xbf, 0x7a, 0x23, 0xf0, 0xd5, 0xfc, 0x89, + 0xe5, 0x81, 0xaf, 0xae, 0x09, 0x6f, 0x12, 0x6c, 0x68, 0x7a, 0xde, 0x1a, 0x07, 0xc0, 0x26, 0x58, + 0x21, 0x9e, 0x81, 0xed, 0x66, 0x8b, 0x78, 0xf1, 0x2d, 0xa7, 0xf9, 0x96, 0x5f, 0x08, 0x7c, 0x15, + 0xd6, 0xbc, 0x3d, 0x21, 0x8e, 0x6f, 0xfa, 0x3f, 0xc3, 0x4d, 0x9f, 0xc0, 0x6a, 0x3a, 0x24, 0x27, + 0x20, 0xf0, 0x1b, 0x05, 0x14, 0x86, 0xaa, 0x23, 0x5b, 0x07, 0x7c, 0xeb, 0x57, 0x4f, 0xd9, 0x7a, + 0x48, 0x14, 0xdf, 0xfc, 0xcd, 0xc0, 0x57, 0x97, 0x13, 0x04, 0x03, 0x5f, 0xbd, 0x28, 0xfc, 0x4a, + 0xb4, 0xa4, 0xe9, 0xcb, 0xf8, 0x24, 0x08, 0xf6, 0x40, 0xfe, 0x08, 0x63, 0xdc, 0xc1, 0xae, 0x41, + 0x6c, 0x13, 0xdb, 0x94, 0xf4, 0x70, 0x31, 0xb3, 0xae, 0x6c, 0xa4, 0xab, 0xb5, 0xc7, 0xbe, 0x3a, + 0xf5, 0x8b, 0xaf, 0x5e, 0x69, 0x12, 0x7a, 0xd8, 0xad, 0x33, 0x17, 0x2b, 0x32, 0xa3, 0xc5, 0xcf, + 0x75, 0xcf, 0x3a, 0xaa, 0xd0, 0xe3, 0x0e, 0xf6, 0xca, 0xbb, 0xd8, 0x1c, 0xf8, 0xea, 0xaa, 0xb0, + 0x7f, 0x34, 0xc6, 0xa7, 0xe9, 0x39, 0x69, 0xa3, 0x36, 0x5c, 0xfa, 0x22, 0x05, 0x96, 0xb6, 0x3b, + 0x1d, 0x1d, 0x7b, 0xd8, 0xed, 0xe1, 0x5b, 0x5d, 0xdb, 0xf2, 0x9e, 0x27, 0xe7, 0x5f, 0x04, 0xf3, + 0xc8, 0xf3, 0x30, 0x65, 0xa0, 0x14, 0x07, 0x95, 0x02, 0x5f, 0x9d, 0xdb, 0x66, 0x6b, 0x1c, 0xb6, + 0x24, 0x61, 0x52, 0x49, 0xd3, 0xe7, 0x90, 0x90, 0xc1, 0xcf, 0x14, 0xb0, 0x48, 0x9d, 0x23, 0x6c, + 0x1b, 0x0f, 0xbb, 0xc8, 0xa6, 0x84, 0x1e, 0x17, 0xa7, 0xf9, 0x61, 0x5c, 0x28, 0x8b, 0xed, 0x95, + 0xd9, 0xbd, 0x2d, 0xcb, 0x7b, 0x5b, 0xde, 0x71, 0x88, 0x5d, 0xbd, 0xc3, 0x42, 0x32, 0xf0, 0xd5, + 0x82, 0x60, 0x1d, 0x85, 0x6b, 0x7f, 0xfa, 0xea, 0xff, 0x9e, 0x21, 0x56, 0x8c, 0x49, 0xcf, 0x72, + 0xec, 0xfd, 0x10, 0xfa, 0xbd, 0x02, 0x0a, 0x63, 0xe1, 0x38, 0xe8, 0xef, 0x22, 0x8a, 0x9e, 0x27, + 0x28, 0x1e, 0xc8, 0x8a, 0xfd, 0xd2, 0xbe, 0x61, 0x21, 0x8a, 0x8a, 0xa9, 0xf5, 0xe9, 0x8d, 0xcc, + 0x96, 0x76, 0x4a, 0x92, 0xf1, 0x60, 0x09, 0x6b, 0xd5, 0x6b, 0x6c, 0x83, 0x81, 0xaf, 0x66, 0x62, + 0x8b, 0x03, 0x5f, 0x5d, 0x89, 0x47, 0x51, 0xb2, 0x6a, 0x7a, 0x06, 0x45, 0x4a, 0xda, 0x27, 0x29, + 0x10, 0x07, 0x8d, 0x9c, 0x8c, 0x32, 0xd9, 0xc9, 0x5c, 0x03, 0x73, 0xb4, 0x6f, 0xb0, 0x60, 0xf1, + 0x33, 0x4d, 0x57, 0xe1, 0xc0, 0x57, 0x17, 0x65, 0xc8, 0x85, 0x40, 0xd3, 0x67, 0x69, 0xff, 0xe0, + 0xb8, 0x83, 0xff, 0x5d, 0xc7, 0xf8, 0x63, 0x0a, 0x9c, 0xac, 0x4b, 0xf0, 0x01, 0x98, 0xeb, 0xb8, + 0xb8, 0x4d, 0xba, 0x6d, 0x1e, 0x89, 0x74, 0xf5, 0xb5, 0x89, 0x6f, 0x96, 0xdc, 0xbd, 0xa4, 0xd1, + 0xf4, 0x90, 0x10, 0xbe, 0x07, 0xe6, 0x2d, 0xe2, 0x99, 0x4e, 0xd7, 0xa6, 0x32, 0x58, 0xdb, 0x13, + 0x93, 0xcb, 0x93, 0x08, 0x79, 0x34, 0x7d, 0x48, 0x09, 0x29, 0xc8, 0x59, 0xd8, 0x74, 0x71, 0x1b, + 0xdb, 0xd4, 0x68, 0x20, 0x93, 0x3d, 0x2d, 0xd3, 0x13, 0x57, 0x87, 0x9a, 0x4d, 0xa3, 0xea, 0x30, + 0xce, 0xa7, 0xe9, 0x4b, 0xc3, 0xa5, 0x5b, 0x62, 0xe5, 0x73, 0x05, 0x24, 0x55, 0xb8, 0x44, 0x6f, + 0x94, 0x7f, 0xdc, 0x1b, 0x67, 0xe4, 0x95, 0xbe, 0xdb, 0x68, 0x78, 0x98, 0xde, 0x71, 0x5a, 0x16, + 0x76, 0xe1, 0xf5, 0xb1, 0xcb, 0x79, 0x3e, 0x7e, 0x39, 0xd3, 0xf2, 0x95, 0x88, 0x2e, 0xe6, 0x65, + 0xb0, 0x68, 0x76, 0x5d, 0x97, 0x59, 0x73, 0x38, 0x8d, 0xa8, 0x59, 0x7a, 0x56, 0xae, 0x0a, 0x6e, + 0xed, 0xa7, 0x3c, 0xc8, 0xec, 0x3b, 0xe6, 0x11, 0xb6, 0xde, 0x42, 0xdd, 0x16, 0x85, 0x65, 0x90, + 0x1a, 0xb9, 0x44, 0xd9, 0x98, 0x70, 0xdc, 0x52, 0x8a, 0x58, 0x31, 0xaf, 0x52, 0xcf, 0xe2, 0xd5, + 0x3e, 0xc8, 0x3b, 0x2e, 0x69, 0x12, 0x1b, 0xb5, 0x8c, 0x1e, 0xe3, 0x64, 0xc8, 0x69, 0x8e, 0x5c, + 0x0f, 0x7c, 0x75, 0xe9, 0xae, 0x14, 0x26, 0xda, 0x5b, 0x72, 0x46, 0xa5, 0xf0, 0x10, 0x9c, 0xc7, + 0x7d, 0x8a, 0x6d, 0x0b, 0x5b, 0x46, 0x07, 0x11, 0x37, 0xa2, 0x3c, 0xc7, 0x29, 0xd9, 0xdb, 0xbd, + 0xb8, 0x27, 0x35, 0xee, 0x21, 0xe2, 0x72, 0xc6, 0x4b, 0xf2, 0xe5, 0x4a, 0x44, 0xb2, 0xa7, 0x2b, + 0x06, 0x08, 0x2d, 0x55, 0xc0, 0x8c, 0xf3, 0xa1, 0x8d, 0xdd, 0xe2, 0x0c, 0x4f, 0x81, 0x0b, 0x6c, + 0x97, 0x77, 0xd9, 0xc2, 0xc0, 0x57, 0x17, 0x04, 0x1f, 0x97, 0x6b, 0xba, 0xd0, 0x83, 0x8f, 0x14, + 0x90, 0x33, 0x9d, 0x56, 0x0b, 0x51, 0xec, 0xa2, 0x96, 0xc1, 0xaf, 0x2e, 0x6f, 0x94, 0xce, 0x2c, + 0x16, 0xaf, 0xcb, 0x62, 0x21, 0x13, 0x66, 0x9c, 0x60, 0xa2, 0x72, 0xb1, 0x14, 0xa1, 0x0f, 0x18, + 0x18, 0x7e, 0x04, 0x80, 0x85, 0xeb, 0x54, 0xfa, 0x32, 0xf7, 0x77, 0xbe, 0xec, 0x4a, 0x5f, 0xf2, + 0x61, 0xf2, 0x86, 0xd0, 0x89, 0xbc, 0x48, 0x33, 0x9c, 0xb0, 0xff, 0x83, 0x02, 0xd4, 0x30, 0x25, + 0x23, 0xdf, 0x88, 0xc7, 0x53, 0xdd, 0x70, 0xd9, 0x0f, 0xef, 0xce, 0xd2, 0xd5, 0xfe, 0x64, 0x65, + 0x25, 0xf0, 0xd5, 0x8b, 0x3b, 0x82, 0x78, 0x47, 0xf2, 0x86, 0xb4, 0x3a, 0xfb, 0x77, 0xe0, 0xab, + 0x57, 0x64, 0x40, 0xcf, 0x36, 0xaf, 0xe9, 0x97, 0xcc, 0x51, 0x1e, 0x34, 0x42, 0x04, 0xbf, 0x53, + 0xc0, 0xda, 0xc8, 0xa1, 0x18, 0x75, 0x1c, 0xb6, 0x3e, 0xb2, 0x97, 0x3b, 0x33, 0xa6, 0xf7, 0x65, + 0x4c, 0x4b, 0xc2, 0x9d, 0x9d, 0xd8, 0x09, 0x55, 0xf1, 0x76, 0xc8, 0x33, 0x51, 0x80, 0x57, 0xcd, + 0x64, 0x12, 0xf8, 0xb1, 0x02, 0x32, 0x14, 0xb9, 0x4d, 0x4c, 0x0d, 0x76, 0x06, 0xb2, 0xfb, 0x3b, + 0xc3, 0xb9, 0x3d, 0xe9, 0x1c, 0x94, 0x2f, 0x55, 0x84, 0x9d, 0xc8, 0x21, 0x20, 0x80, 0xbb, 0xb8, + 0x4e, 0xe1, 0xd7, 0x0a, 0x28, 0xc4, 0x3a, 0x00, 0x63, 0x38, 0xb5, 0xf0, 0xb6, 0x2f, 0xb3, 0xb5, + 0x56, 0x16, 0x73, 0x4d, 0x39, 0x9c, 0x6b, 0xca, 0x07, 0xa1, 0x86, 0x78, 0xb8, 0x02, 0x5f, 0x5d, + 0x89, 0x15, 0xc4, 0xa1, 0x34, 0x6a, 0x40, 0x13, 0xe9, 0xb5, 0x47, 0xbf, 0xaa, 0x8a, 0xbe, 0xd2, + 0x4a, 0x40, 0xc2, 0xf7, 0xf9, 0xe4, 0x41, 0x6c, 0x8a, 0x5d, 0x56, 0x85, 0x44, 0x03, 0x59, 0x5c, + 0xe0, 0x6d, 0xf8, 0xff, 0xc5, 0xe4, 0x51, 0x93, 0xc2, 0x37, 0xb8, 0x6c, 0xe0, 0xab, 0xc5, 0x61, + 0x13, 0xce, 0x70, 0x11, 0x8c, 0x0f, 0x1e, 0xa3, 0xda, 0xd0, 0x03, 0xab, 0x63, 0xe4, 0x06, 0xb2, + 0x2c, 0x17, 0x7b, 0x5e, 0x31, 0xcb, 0xb3, 0xfb, 0xe5, 0xc0, 0x57, 0x0b, 0xa3, 0xa0, 0x6d, 0xa1, + 0x10, 0x65, 0xc6, 0x29, 0x0c, 0x9a, 0x5e, 0x20, 0x49, 0x40, 0x66, 0x94, 0x95, 0xad, 0x24, 0xa3, + 0x4b, 0x91, 0xd1, 0xbd, 0xfe, 0x99, 0x46, 0x4f, 0x61, 0xd0, 0xf4, 0x02, 0x4e, 0x02, 0xc2, 0xaf, + 0x14, 0xb0, 0xdc, 0xc0, 0x58, 0x5e, 0x03, 0x96, 0x87, 0xd8, 0x64, 0x23, 0x4d, 0x8e, 0x5b, 0xfc, + 0x60, 0xb2, 0x67, 0x92, 0x45, 0xfe, 0x16, 0xc6, 0x2c, 0x87, 0x77, 0x42, 0xa6, 0x68, 0xca, 0x4a, + 0x30, 0xa3, 0xe9, 0xb9, 0xc6, 0x98, 0x3e, 0xfc, 0x54, 0x01, 0xf9, 0xba, 0x63, 0x77, 0x3d, 0xa9, + 0xdc, 0x24, 0x3d, 0x6c, 0x17, 0xf3, 0xdc, 0x9f, 0x77, 0x27, 0xf6, 0x67, 0xb1, 0xca, 0xa8, 0x98, + 0x85, 0xdb, 0x8c, 0x27, 0xca, 0x83, 0x13, 0x26, 0x34, 0x7d, 0xb1, 0x3e, 0xa2, 0x0b, 0xef, 0x83, + 0xc5, 0xe1, 0xb0, 0x2b, 0xda, 0x4b, 0xc8, 0xbd, 0xb8, 0xca, 0xde, 0xd4, 0xe1, 0x94, 0xcc, 0xba, + 0xca, 0xa8, 0x37, 0x1c, 0x05, 0x68, 0x7a, 0x96, 0xc4, 0xf5, 0x60, 0x0d, 0x2c, 0x84, 0x53, 0x16, + 0x27, 0x5c, 0xe6, 0x29, 0x7b, 0x85, 0x77, 0xd0, 0x62, 0x5d, 0xd2, 0x2d, 0xcb, 0x6e, 0x37, 0xa6, + 0xcc, 0x1a, 0xe8, 0x48, 0x07, 0xde, 0x06, 0x0b, 0x6c, 0x8a, 0x66, 0x25, 0xdd, 0x6c, 0x7b, 0xb4, + 0xb8, 0xc2, 0xa9, 0x2e, 0x07, 0xbe, 0x0a, 0x6a, 0x1e, 0xbb, 0xb9, 0x3b, 0x6d, 0x8f, 0x46, 0x4c, + 0x71, 0x5d, 0x4d, 0x07, 0x64, 0xa8, 0x02, 0xdf, 0x04, 0xcb, 0xb1, 0x7a, 0x38, 0x6c, 0xc2, 0x0b, + 0xa2, 0x7f, 0x88, 0xce, 0x2f, 0x41, 0x49, 0xd3, 0xf3, 0xd1, 0xaa, 0x6c, 0xd5, 0xe1, 0x2b, 0x20, + 0xcb, 0x2d, 0x0d, 0x99, 0xce, 0x73, 0xa6, 0x62, 0x34, 0x17, 0x8c, 0x88, 0x35, 0x3d, 0xc3, 0xbe, + 0x25, 0xba, 0xfa, 0xce, 0xe3, 0xdf, 0x4b, 0x53, 0xdf, 0x06, 0xa5, 0xa9, 0xc7, 0x41, 0x49, 0x79, + 0x12, 0x94, 0x94, 0xdf, 0x82, 0x92, 0xf2, 0xe8, 0x69, 0x69, 0xea, 0xc9, 0xd3, 0xd2, 0xd4, 0xcf, + 0x4f, 0x4b, 0x53, 0x0f, 0x6e, 0x8e, 0x1c, 0x3e, 0x9b, 0x50, 0xae, 0x3b, 0x8d, 0x06, 0x31, 0x09, + 0x6a, 0xc9, 0xef, 0xca, 0xf8, 0x1f, 0x6e, 0x78, 0x46, 0xd4, 0x67, 0x79, 0x85, 0xba, 0xf1, 0x57, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x5d, 0x9f, 0xeb, 0xef, 0xdd, 0x11, 0x00, 0x00, +} + +func (m *LiquidationWhiteListing) 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 *LiquidationWhiteListing) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidationWhiteListing) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.KeeeperIncentive.Size() + i -= size + if _, err := m.KeeeperIncentive.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + if m.EnglishAuctionParam != nil { + { + size, err := m.EnglishAuctionParam.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.IsEnglishActivated { + i-- + if m.IsEnglishActivated { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } + if m.DutchAuctionParam != nil { + { + size, err := m.DutchAuctionParam.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.IsDutchActivated { + i-- + if m.IsDutchActivated { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + } + if m.Initiator { + i-- + if m.Initiator { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if m.AppId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AppReserveFunds) 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 *AppReserveFunds) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppReserveFunds) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.TokenQuantity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.AssetId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.AssetId)) + i-- + dAtA[i] = 0x10 + } + if m.AppId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AppReserveFundsTxData) 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 *AppReserveFundsTxData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AppReserveFundsTxData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.AssetTxData) > 0 { + for iNdEx := len(m.AssetTxData) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.AssetTxData[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if m.AppId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AssetTxData) 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 *AssetTxData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AssetTxData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.TokenQuantity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.TxType) > 0 { + i -= len(m.TxType) + copy(dAtA[i:], m.TxType) + i = encodeVarintLiquidate(dAtA, i, uint64(len(m.TxType))) + i-- + dAtA[i] = 0x12 + } + if m.AssetId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.AssetId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *DutchAuctionParam) 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 *DutchAuctionParam) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DutchAuctionParam) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.DecrementFactor.Size() + i -= size + if _, err := m.DecrementFactor.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + { + size := m.Discount.Size() + i -= size + if _, err := m.Discount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size := m.Premium.Size() + i -= size + if _, err := m.Premium.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *EnglishAuctionParam) 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 *EnglishAuctionParam) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EnglishAuctionParam) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.DecrementFactor.Size() + i -= size + if _, err := m.DecrementFactor.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *LiquidationOffsetHolder) 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 *LiquidationOffsetHolder) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LiquidationOffsetHolder) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CurrentOffset != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.CurrentOffset)) + i-- + dAtA[i] = 0x10 + } + if m.AppId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *LockedVault) 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 *LockedVault) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LockedVault) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DebtAssetId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.DebtAssetId)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xb0 + } + if m.CollateralAssetId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.CollateralAssetId)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa8 + } + if m.IsDebtCmst { + i-- + if m.IsDebtCmst { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xa0 + } + if m.AuctionType { + i-- + if m.AuctionType { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x98 + } + if len(m.InitiatorType) > 0 { + i -= len(m.InitiatorType) + copy(dAtA[i:], m.InitiatorType) + i = encodeVarintLiquidate(dAtA, i, uint64(len(m.InitiatorType))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + { + size := m.BonusToBeGiven.Size() + i -= size + if _, err := m.BonusToBeGiven.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + { + size := m.FeeToBeCollected.Size() + i -= size + if _, err := m.FeeToBeCollected.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x82 + if len(m.ExternalKeeperAddress) > 0 { + i -= len(m.ExternalKeeperAddress) + copy(dAtA[i:], m.ExternalKeeperAddress) + i = encodeVarintLiquidate(dAtA, i, uint64(len(m.ExternalKeeperAddress))) + i-- + dAtA[i] = 0x7a + } + if len(m.InternalKeeperAddress) > 0 { + i -= len(m.InternalKeeperAddress) + copy(dAtA[i:], m.InternalKeeperAddress) + i = encodeVarintLiquidate(dAtA, i, uint64(len(m.InternalKeeperAddress))) + i-- + dAtA[i] = 0x6a + } + if m.IsInternalKeeper { + i-- + if m.IsInternalKeeper { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + } + n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LiquidationTimestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LiquidationTimestamp):]) + if err5 != nil { + return 0, err5 + } + i -= n5 + i = encodeVarintLiquidate(dAtA, i, uint64(n5)) + i-- + dAtA[i] = 0x5a + { + size, err := m.TargetDebt.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + { + size, err := m.CollateralToBeAuctioned.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + { + size := m.CurrentCollaterlisationRatio.Size() + i -= size + if _, err := m.CurrentCollaterlisationRatio.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + { + size, err := m.DebtToken.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + { + size, err := m.CollateralToken.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintLiquidate(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintLiquidate(dAtA, i, uint64(len(m.Owner))) + i-- + dAtA[i] = 0x2a + } + if m.ExtendedPairId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.ExtendedPairId)) + i-- + dAtA[i] = 0x20 + } + if m.OriginalVaultId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.OriginalVaultId)) + i-- + dAtA[i] = 0x18 + } + if m.AppId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x10 + } + if m.LockedVaultId != 0 { + i = encodeVarintLiquidate(dAtA, i, uint64(m.LockedVaultId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintLiquidate(dAtA []byte, offset int, v uint64) int { + offset -= sovLiquidate(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *LiquidationWhiteListing) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AppId != 0 { + n += 1 + sovLiquidate(uint64(m.AppId)) + } + if m.Initiator { + n += 2 + } + if m.IsDutchActivated { + n += 2 + } + if m.DutchAuctionParam != nil { + l = m.DutchAuctionParam.Size() + n += 1 + l + sovLiquidate(uint64(l)) + } + if m.IsEnglishActivated { + n += 2 + } + if m.EnglishAuctionParam != nil { + l = m.EnglishAuctionParam.Size() + n += 1 + l + sovLiquidate(uint64(l)) + } + l = m.KeeeperIncentive.Size() + n += 1 + l + sovLiquidate(uint64(l)) + return n +} + +func (m *AppReserveFunds) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AppId != 0 { + n += 1 + sovLiquidate(uint64(m.AppId)) + } + if m.AssetId != 0 { + n += 1 + sovLiquidate(uint64(m.AssetId)) + } + l = m.TokenQuantity.Size() + n += 1 + l + sovLiquidate(uint64(l)) + return n +} + +func (m *AppReserveFundsTxData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AppId != 0 { + n += 1 + sovLiquidate(uint64(m.AppId)) + } + if len(m.AssetTxData) > 0 { + for _, e := range m.AssetTxData { + l = e.Size() + n += 1 + l + sovLiquidate(uint64(l)) + } + } + return n +} + +func (m *AssetTxData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AssetId != 0 { + n += 1 + sovLiquidate(uint64(m.AssetId)) + } + l = len(m.TxType) + if l > 0 { + n += 1 + l + sovLiquidate(uint64(l)) + } + l = m.TokenQuantity.Size() + n += 1 + l + sovLiquidate(uint64(l)) + return n +} + +func (m *DutchAuctionParam) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Premium.Size() + n += 1 + l + sovLiquidate(uint64(l)) + l = m.Discount.Size() + n += 1 + l + sovLiquidate(uint64(l)) + l = m.DecrementFactor.Size() + n += 1 + l + sovLiquidate(uint64(l)) + return n +} + +func (m *EnglishAuctionParam) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.DecrementFactor.Size() + n += 1 + l + sovLiquidate(uint64(l)) + return n +} + +func (m *LiquidationOffsetHolder) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AppId != 0 { + n += 1 + sovLiquidate(uint64(m.AppId)) + } + if m.CurrentOffset != 0 { + n += 1 + sovLiquidate(uint64(m.CurrentOffset)) + } + return n +} + +func (m *LockedVault) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LockedVaultId != 0 { + n += 1 + sovLiquidate(uint64(m.LockedVaultId)) + } + if m.AppId != 0 { + n += 1 + sovLiquidate(uint64(m.AppId)) + } + if m.OriginalVaultId != 0 { + n += 1 + sovLiquidate(uint64(m.OriginalVaultId)) + } + if m.ExtendedPairId != 0 { + n += 1 + sovLiquidate(uint64(m.ExtendedPairId)) + } + l = len(m.Owner) + if l > 0 { + n += 1 + l + sovLiquidate(uint64(l)) + } + l = m.CollateralToken.Size() + n += 1 + l + sovLiquidate(uint64(l)) + l = m.DebtToken.Size() + n += 1 + l + sovLiquidate(uint64(l)) + l = m.CurrentCollaterlisationRatio.Size() + n += 1 + l + sovLiquidate(uint64(l)) + l = m.CollateralToBeAuctioned.Size() + n += 1 + l + sovLiquidate(uint64(l)) + l = m.TargetDebt.Size() + n += 1 + l + sovLiquidate(uint64(l)) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LiquidationTimestamp) + n += 1 + l + sovLiquidate(uint64(l)) + if m.IsInternalKeeper { + n += 2 + } + l = len(m.InternalKeeperAddress) + if l > 0 { + n += 1 + l + sovLiquidate(uint64(l)) + } + l = len(m.ExternalKeeperAddress) + if l > 0 { + n += 1 + l + sovLiquidate(uint64(l)) + } + l = m.FeeToBeCollected.Size() + n += 2 + l + sovLiquidate(uint64(l)) + l = m.BonusToBeGiven.Size() + n += 2 + l + sovLiquidate(uint64(l)) + l = len(m.InitiatorType) + if l > 0 { + n += 2 + l + sovLiquidate(uint64(l)) + } + if m.AuctionType { + n += 3 + } + if m.IsDebtCmst { + n += 3 + } + if m.CollateralAssetId != 0 { + n += 2 + sovLiquidate(uint64(m.CollateralAssetId)) + } + if m.DebtAssetId != 0 { + n += 2 + sovLiquidate(uint64(m.DebtAssetId)) + } + return n +} + +func sovLiquidate(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozLiquidate(x uint64) (n int) { + return sovLiquidate(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *LiquidationWhiteListing) 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 ErrIntOverflowLiquidate + } + 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: LiquidationWhiteListing: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidationWhiteListing: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Initiator", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Initiator = bool(v != 0) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsDutchActivated", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsDutchActivated = bool(v != 0) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DutchAuctionParam", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DutchAuctionParam == nil { + m.DutchAuctionParam = &DutchAuctionParam{} + } + if err := m.DutchAuctionParam.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsEnglishActivated", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsEnglishActivated = bool(v != 0) + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EnglishAuctionParam", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.EnglishAuctionParam == nil { + m.EnglishAuctionParam = &EnglishAuctionParam{} + } + if err := m.EnglishAuctionParam.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field KeeeperIncentive", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.KeeeperIncentive.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquidate(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquidate + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppReserveFunds) 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 ErrIntOverflowLiquidate + } + 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: AppReserveFunds: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppReserveFunds: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) + } + m.AssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenQuantity", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TokenQuantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquidate(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquidate + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AppReserveFundsTxData) 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 ErrIntOverflowLiquidate + } + 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: AppReserveFundsTxData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AppReserveFundsTxData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetTxData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AssetTxData = append(m.AssetTxData, AssetTxData{}) + if err := m.AssetTxData[len(m.AssetTxData)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquidate(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquidate + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AssetTxData) 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 ErrIntOverflowLiquidate + } + 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: AssetTxData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AssetTxData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) + } + m.AssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TxType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenQuantity", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TokenQuantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquidate(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquidate + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DutchAuctionParam) 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 ErrIntOverflowLiquidate + } + 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: DutchAuctionParam: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DutchAuctionParam: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Premium", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Premium.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Discount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Discount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DecrementFactor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DecrementFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquidate(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquidate + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EnglishAuctionParam) 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 ErrIntOverflowLiquidate + } + 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: EnglishAuctionParam: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EnglishAuctionParam: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DecrementFactor", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DecrementFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipLiquidate(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquidate + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LiquidationOffsetHolder) 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 ErrIntOverflowLiquidate + } + 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: LiquidationOffsetHolder: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LiquidationOffsetHolder: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentOffset", wireType) + } + m.CurrentOffset = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CurrentOffset |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipLiquidate(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquidate + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LockedVault) 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 ErrIntOverflowLiquidate + } + 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: LockedVault: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LockedVault: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LockedVaultId", wireType) + } + m.LockedVaultId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LockedVaultId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OriginalVaultId", wireType) + } + m.OriginalVaultId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.OriginalVaultId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ExtendedPairId", wireType) + } + m.ExtendedPairId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ExtendedPairId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralToken", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CollateralToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtToken", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.DebtToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CurrentCollaterlisationRatio", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CurrentCollaterlisationRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralToBeAuctioned", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.CollateralToBeAuctioned.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TargetDebt", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TargetDebt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidationTimestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthLiquidate + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LiquidationTimestamp, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsInternalKeeper", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsInternalKeeper = bool(v != 0) + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InternalKeeperAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InternalKeeperAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ExternalKeeperAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ExternalKeeperAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 16: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeeToBeCollected", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.FeeToBeCollected.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BonusToBeGiven", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.BonusToBeGiven.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field InitiatorType", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + 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 ErrInvalidLengthLiquidate + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthLiquidate + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.InitiatorType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 19: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AuctionType", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.AuctionType = bool(v != 0) + case 20: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsDebtCmst", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsDebtCmst = bool(v != 0) + case 21: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralAssetId", wireType) + } + m.CollateralAssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CollateralAssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 22: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtAssetId", wireType) + } + m.DebtAssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowLiquidate + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebtAssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipLiquidate(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthLiquidate + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipLiquidate(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLiquidate + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLiquidate + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowLiquidate + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthLiquidate + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupLiquidate + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthLiquidate + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthLiquidate = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowLiquidate = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupLiquidate = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquidation/v2types/params.pb.go b/x/liquidation/v2types/params.pb.go new file mode 100644 index 000000000..8c8951909 --- /dev/null +++ b/x/liquidation/v2types/params.pb.go @@ -0,0 +1,302 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/liquidation/v2/params.proto + +package v2types + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Params struct { + LiquidationBatchSize uint64 `protobuf:"varint,1,opt,name=liquidation_batch_size,json=liquidationBatchSize,proto3" json:"liquidation_batch_size,omitempty"` +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_67185986e5384794, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +func (m *Params) GetLiquidationBatchSize() uint64 { + if m != nil { + return m.LiquidationBatchSize + } + return 0 +} + +func init() { + proto.RegisterType((*Params)(nil), "comdex.liquidation.v2.Params") +} + +func init() { + proto.RegisterFile("comdex/liquidation/v2/params.proto", fileDescriptor_67185986e5384794) +} + +var fileDescriptor_67185986e5384794 = []byte{ + // 178 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4a, 0xce, 0xcf, 0x4d, + 0x49, 0xad, 0xd0, 0xcf, 0xc9, 0x2c, 0x2c, 0xcd, 0x4c, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, + 0x33, 0xd2, 0x2f, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, + 0x85, 0xa8, 0xd1, 0x43, 0x52, 0xa3, 0x57, 0x66, 0xa4, 0x64, 0xc7, 0xc5, 0x16, 0x00, 0x56, 0x26, + 0x64, 0xc2, 0x25, 0x86, 0x24, 0x17, 0x9f, 0x94, 0x58, 0x92, 0x9c, 0x11, 0x5f, 0x9c, 0x59, 0x95, + 0x2a, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x12, 0x24, 0x82, 0x24, 0xeb, 0x04, 0x92, 0x0c, 0xce, 0xac, + 0x4a, 0x75, 0x0a, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, + 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xf3, 0xf4, + 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x88, 0xdd, 0xba, 0xf9, 0x69, 0x69, + 0x99, 0xc9, 0x99, 0x89, 0x39, 0x50, 0xbe, 0x3e, 0xba, 0x8b, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, + 0xd8, 0xc0, 0x0e, 0x36, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x48, 0x45, 0xc6, 0x61, 0xd6, 0x00, + 0x00, 0x00, +} + +func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.LiquidationBatchSize != 0 { + i = encodeVarintParams(dAtA, i, uint64(m.LiquidationBatchSize)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintParams(dAtA []byte, offset int, v uint64) int { + offset -= sovParams(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LiquidationBatchSize != 0 { + n += 1 + sovParams(uint64(m.LiquidationBatchSize)) + } + return n +} + +func sovParams(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozParams(x uint64) (n int) { + return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) 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 ErrIntOverflowParams + } + 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: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LiquidationBatchSize", wireType) + } + m.LiquidationBatchSize = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LiquidationBatchSize |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipParams(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthParams + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipParams(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowParams + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthParams + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupParams + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthParams + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthParams = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowParams = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquidation/v2types/query.pb.go b/x/liquidation/v2types/query.pb.go new file mode 100644 index 000000000..104ef67f1 --- /dev/null +++ b/x/liquidation/v2types/query.pb.go @@ -0,0 +1,530 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/liquidation/v2/query.proto + +package v2types + +import ( + context "context" + fmt "fmt" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type QueryParamsRequest struct { +} + +func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } +func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryParamsRequest) ProtoMessage() {} +func (*QueryParamsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_3dcfcfd5101fa7f1, []int{0} +} +func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsRequest.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 *QueryParamsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsRequest.Merge(m, src) +} +func (m *QueryParamsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo + +type QueryParamsResponse struct { + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } +func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryParamsResponse) ProtoMessage() {} +func (*QueryParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_3dcfcfd5101fa7f1, []int{1} +} +func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsResponse.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 *QueryParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsResponse.Merge(m, src) +} +func (m *QueryParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo + +func (m *QueryParamsResponse) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +func init() { + proto.RegisterType((*QueryParamsRequest)(nil), "comdex.liquidation.v2.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "comdex.liquidation.v2.QueryParamsResponse") +} + +func init() { proto.RegisterFile("comdex/liquidation/v2/query.proto", fileDescriptor_3dcfcfd5101fa7f1) } + +var fileDescriptor_3dcfcfd5101fa7f1 = []byte{ + // 280 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4c, 0xce, 0xcf, 0x4d, + 0x49, 0xad, 0xd0, 0xcf, 0xc9, 0x2c, 0x2c, 0xcd, 0x4c, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, + 0x33, 0xd2, 0x2f, 0x2c, 0x4d, 0x2d, 0xaa, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x85, + 0x28, 0xd1, 0x43, 0x52, 0xa2, 0x57, 0x66, 0x24, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, 0x56, 0xa1, + 0x0f, 0x62, 0x41, 0x14, 0x4b, 0xc9, 0xa4, 0xe7, 0xe7, 0xa7, 0xe7, 0xa4, 0xea, 0x27, 0x16, 0x64, + 0xea, 0x27, 0xe6, 0xe5, 0xe5, 0x97, 0x80, 0xd5, 0x17, 0x43, 0x65, 0x95, 0xb0, 0xdb, 0x56, 0x90, + 0x58, 0x94, 0x98, 0x0b, 0x55, 0xa3, 0x24, 0xc2, 0x25, 0x14, 0x08, 0xb2, 0x3d, 0x00, 0x2c, 0x18, + 0x94, 0x5a, 0x58, 0x9a, 0x5a, 0x5c, 0xa2, 0x14, 0xc4, 0x25, 0x8c, 0x22, 0x5a, 0x5c, 0x90, 0x9f, + 0x57, 0x9c, 0x2a, 0x64, 0xcd, 0xc5, 0x06, 0xd1, 0x2c, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0x24, + 0xab, 0x87, 0xd5, 0xb1, 0x7a, 0x10, 0x6d, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x41, 0xb5, + 0x18, 0x2d, 0x60, 0xe4, 0x62, 0x05, 0x1b, 0x2a, 0x34, 0x8d, 0x91, 0x8b, 0x0d, 0xa2, 0x44, 0x48, + 0x13, 0x87, 0x09, 0x98, 0x6e, 0x92, 0xd2, 0x22, 0x46, 0x29, 0xc4, 0xa1, 0x4a, 0xa6, 0x4d, 0x97, + 0x9f, 0x4c, 0x66, 0xd2, 0x17, 0xd2, 0xd5, 0x87, 0xe8, 0xd1, 0xcd, 0x4f, 0x4b, 0xcb, 0x4c, 0xce, + 0x4c, 0xcc, 0xd1, 0xc7, 0x17, 0x24, 0x4e, 0x81, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, + 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, + 0xc7, 0x10, 0x65, 0x9e, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0x04, 0x72, 0x02, 0x2e, 0x23, 0xd1, 0x0d, + 0x2d, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x07, 0xb3, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, + 0xd5, 0xc7, 0x67, 0x30, 0xfa, 0x01, 0x00, 0x00, +} + +// 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 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { + out := new(QueryParamsResponse) + err := c.cc.Invoke(ctx, "/comdex.liquidation.v2.Query/Params", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryParamsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Params(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.liquidation.v2.Query/Params", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "comdex.liquidation.v2.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Params", + Handler: _Query_Params_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "comdex/liquidation/v2/query.proto", +} + +func (m *QueryParamsRequest) 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 *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryParamsResponse) 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 *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsResponse) 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 = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/liquidation/v2types/query.pb.gw.go b/x/liquidation/v2types/query.pb.gw.go new file mode 100644 index 000000000..70313c703 --- /dev/null +++ b/x/liquidation/v2types/query.pb.gw.go @@ -0,0 +1,153 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: comdex/liquidation/v2/query.proto + +/* +Package v2types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package v2types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage +var _ = metadata.Join + +func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryParamsRequest + var metadata runtime.ServerMetadata + + msg, err := server.Params(ctx, &protoReq) + return msg, metadata, err + +} + +// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". +// UnaryRPC :call QueryServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"comdex-official", "comdex", "liquidation", "v2", "params"}, "", runtime.AssumeColonVerbOpt(false))) +) + +var ( + forward_Query_Params_0 = runtime.ForwardResponseMessage +) diff --git a/x/liquidation/v2types/tx.pb.go b/x/liquidation/v2types/tx.pb.go new file mode 100644 index 000000000..66b93ece1 --- /dev/null +++ b/x/liquidation/v2types/tx.pb.go @@ -0,0 +1,1598 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: comdex/liquidation/v2/tx.proto + +package v2types + +import ( + context "context" + fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + types "github.com/cosmos/cosmos-sdk/types" + _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type MsgLiquidateInternalKeeperRequest struct { + From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"` + LiqType uint64 `protobuf:"varint,2,opt,name=liq_type,json=liqType,proto3" json:"liq_type,omitempty" yaml:"liq_type"` + Id uint64 `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty" yaml:"id"` +} + +func (m *MsgLiquidateInternalKeeperRequest) Reset() { *m = MsgLiquidateInternalKeeperRequest{} } +func (m *MsgLiquidateInternalKeeperRequest) String() string { return proto.CompactTextString(m) } +func (*MsgLiquidateInternalKeeperRequest) ProtoMessage() {} +func (*MsgLiquidateInternalKeeperRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_6183e44c40ceafc9, []int{0} +} +func (m *MsgLiquidateInternalKeeperRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgLiquidateInternalKeeperRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgLiquidateInternalKeeperRequest.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 *MsgLiquidateInternalKeeperRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgLiquidateInternalKeeperRequest.Merge(m, src) +} +func (m *MsgLiquidateInternalKeeperRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgLiquidateInternalKeeperRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgLiquidateInternalKeeperRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgLiquidateInternalKeeperRequest proto.InternalMessageInfo + +type MsgLiquidateInternalKeeperResponse struct { +} + +func (m *MsgLiquidateInternalKeeperResponse) Reset() { *m = MsgLiquidateInternalKeeperResponse{} } +func (m *MsgLiquidateInternalKeeperResponse) String() string { return proto.CompactTextString(m) } +func (*MsgLiquidateInternalKeeperResponse) ProtoMessage() {} +func (*MsgLiquidateInternalKeeperResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_6183e44c40ceafc9, []int{1} +} +func (m *MsgLiquidateInternalKeeperResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgLiquidateInternalKeeperResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgLiquidateInternalKeeperResponse.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 *MsgLiquidateInternalKeeperResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgLiquidateInternalKeeperResponse.Merge(m, src) +} +func (m *MsgLiquidateInternalKeeperResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgLiquidateInternalKeeperResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgLiquidateInternalKeeperResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgLiquidateInternalKeeperResponse proto.InternalMessageInfo + +type MsgAppReserveFundsRequest struct { + AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` + AssetId uint64 `protobuf:"varint,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty" yaml:"asset_id"` + TokenQuantity types.Coin `protobuf:"bytes,3,opt,name=token_quantity,json=tokenQuantity,proto3" json:"token_quantity"` + From string `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty" yaml:"from"` +} + +func (m *MsgAppReserveFundsRequest) Reset() { *m = MsgAppReserveFundsRequest{} } +func (m *MsgAppReserveFundsRequest) String() string { return proto.CompactTextString(m) } +func (*MsgAppReserveFundsRequest) ProtoMessage() {} +func (*MsgAppReserveFundsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_6183e44c40ceafc9, []int{2} +} +func (m *MsgAppReserveFundsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgAppReserveFundsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgAppReserveFundsRequest.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 *MsgAppReserveFundsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgAppReserveFundsRequest.Merge(m, src) +} +func (m *MsgAppReserveFundsRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgAppReserveFundsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgAppReserveFundsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgAppReserveFundsRequest proto.InternalMessageInfo + +type MsgAppReserveFundsResponse struct { +} + +func (m *MsgAppReserveFundsResponse) Reset() { *m = MsgAppReserveFundsResponse{} } +func (m *MsgAppReserveFundsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgAppReserveFundsResponse) ProtoMessage() {} +func (*MsgAppReserveFundsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_6183e44c40ceafc9, []int{3} +} +func (m *MsgAppReserveFundsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgAppReserveFundsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgAppReserveFundsResponse.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 *MsgAppReserveFundsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgAppReserveFundsResponse.Merge(m, src) +} +func (m *MsgAppReserveFundsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgAppReserveFundsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgAppReserveFundsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgAppReserveFundsResponse proto.InternalMessageInfo + +type MsgLiquidateExternalKeeperRequest struct { + From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"` + AppId uint64 `protobuf:"varint,2,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` + Owner string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty" yaml:"owner"` + CollateralToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,4,opt,name=collateral_token,json=collateralToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_token" yaml:"collateral_token"` + DebtToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,5,opt,name=debt_token,json=debtToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token" yaml:"debt_token"` + CollateralAssetId uint64 `protobuf:"varint,6,opt,name=collateral_asset_id,json=collateralAssetId,proto3" json:"collateral_asset_id,omitempty" yaml:"collateral_asset_id"` + DebtAssetId uint64 `protobuf:"varint,7,opt,name=debt_asset_id,json=debtAssetId,proto3" json:"debt_asset_id,omitempty" yaml:"debt_asset_id"` + IsDebtCmst bool `protobuf:"varint,8,opt,name=isDebtCmst,proto3" json:"isDebtCmst,omitempty" yaml:"debt_asset_id"` +} + +func (m *MsgLiquidateExternalKeeperRequest) Reset() { *m = MsgLiquidateExternalKeeperRequest{} } +func (m *MsgLiquidateExternalKeeperRequest) String() string { return proto.CompactTextString(m) } +func (*MsgLiquidateExternalKeeperRequest) ProtoMessage() {} +func (*MsgLiquidateExternalKeeperRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_6183e44c40ceafc9, []int{4} +} +func (m *MsgLiquidateExternalKeeperRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgLiquidateExternalKeeperRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgLiquidateExternalKeeperRequest.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 *MsgLiquidateExternalKeeperRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgLiquidateExternalKeeperRequest.Merge(m, src) +} +func (m *MsgLiquidateExternalKeeperRequest) XXX_Size() int { + return m.Size() +} +func (m *MsgLiquidateExternalKeeperRequest) XXX_DiscardUnknown() { + xxx_messageInfo_MsgLiquidateExternalKeeperRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgLiquidateExternalKeeperRequest proto.InternalMessageInfo + +type MsgLiquidateExternalKeeperResponse struct { +} + +func (m *MsgLiquidateExternalKeeperResponse) Reset() { *m = MsgLiquidateExternalKeeperResponse{} } +func (m *MsgLiquidateExternalKeeperResponse) String() string { return proto.CompactTextString(m) } +func (*MsgLiquidateExternalKeeperResponse) ProtoMessage() {} +func (*MsgLiquidateExternalKeeperResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_6183e44c40ceafc9, []int{5} +} +func (m *MsgLiquidateExternalKeeperResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgLiquidateExternalKeeperResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgLiquidateExternalKeeperResponse.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 *MsgLiquidateExternalKeeperResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgLiquidateExternalKeeperResponse.Merge(m, src) +} +func (m *MsgLiquidateExternalKeeperResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgLiquidateExternalKeeperResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgLiquidateExternalKeeperResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgLiquidateExternalKeeperResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgLiquidateInternalKeeperRequest)(nil), "comdex.liquidation.v2.MsgLiquidateInternalKeeperRequest") + proto.RegisterType((*MsgLiquidateInternalKeeperResponse)(nil), "comdex.liquidation.v2.MsgLiquidateInternalKeeperResponse") + proto.RegisterType((*MsgAppReserveFundsRequest)(nil), "comdex.liquidation.v2.MsgAppReserveFundsRequest") + proto.RegisterType((*MsgAppReserveFundsResponse)(nil), "comdex.liquidation.v2.MsgAppReserveFundsResponse") + proto.RegisterType((*MsgLiquidateExternalKeeperRequest)(nil), "comdex.liquidation.v2.MsgLiquidateExternalKeeperRequest") + proto.RegisterType((*MsgLiquidateExternalKeeperResponse)(nil), "comdex.liquidation.v2.MsgLiquidateExternalKeeperResponse") +} + +func init() { proto.RegisterFile("comdex/liquidation/v2/tx.proto", fileDescriptor_6183e44c40ceafc9) } + +var fileDescriptor_6183e44c40ceafc9 = []byte{ + // 735 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xbf, 0x52, 0xdb, 0x4e, + 0x10, 0xb6, 0x8c, 0x8d, 0xf1, 0xf1, 0xe3, 0x47, 0x10, 0x64, 0x62, 0x3c, 0x19, 0x89, 0x88, 0xcc, + 0x84, 0x06, 0x29, 0x76, 0x8a, 0x40, 0x26, 0x0d, 0x86, 0x30, 0x43, 0x02, 0xc9, 0x44, 0x43, 0x93, + 0x34, 0x9e, 0xb3, 0x75, 0x38, 0x37, 0xc8, 0x3a, 0x59, 0x77, 0x76, 0x70, 0x93, 0x36, 0x2d, 0x79, + 0x0b, 0x1e, 0x85, 0x92, 0x32, 0x95, 0x26, 0x11, 0x6f, 0xa0, 0x22, 0x45, 0xaa, 0xcc, 0xdd, 0xc9, + 0xd8, 0x18, 0x63, 0xfe, 0x54, 0xb6, 0x76, 0xf7, 0xdb, 0xdd, 0xef, 0xdb, 0x5d, 0x09, 0x68, 0x75, + 0xd2, 0x74, 0xd0, 0x91, 0xe5, 0xe2, 0x56, 0x1b, 0x3b, 0x90, 0x61, 0xe2, 0x59, 0x9d, 0xb2, 0xc5, + 0x8e, 0x4c, 0x3f, 0x20, 0x8c, 0xa8, 0x0f, 0xa5, 0xdf, 0x1c, 0xf0, 0x9b, 0x9d, 0x72, 0x71, 0xa1, + 0x41, 0x1a, 0x44, 0x44, 0x58, 0xfc, 0x9f, 0x0c, 0x2e, 0x6a, 0x75, 0x42, 0x9b, 0x84, 0x5a, 0x35, + 0x48, 0x91, 0xd5, 0x29, 0xd5, 0x10, 0x83, 0x25, 0xab, 0x4e, 0xb0, 0x27, 0xfd, 0xc6, 0x89, 0x02, + 0x9e, 0xec, 0xd1, 0xc6, 0x6e, 0x92, 0x0b, 0xed, 0x78, 0x0c, 0x05, 0x1e, 0x74, 0xdf, 0x21, 0xe4, + 0xa3, 0xc0, 0x46, 0xad, 0x36, 0xa2, 0x4c, 0x5d, 0x06, 0x99, 0x83, 0x80, 0x34, 0x0b, 0xca, 0x92, + 0xb2, 0x92, 0xaf, 0xcc, 0xc6, 0xa1, 0x3e, 0xdd, 0x85, 0x4d, 0xf7, 0x95, 0xc1, 0xad, 0x86, 0x2d, + 0x9c, 0xea, 0x3a, 0x98, 0x72, 0x71, 0xab, 0xca, 0xba, 0x3e, 0x2a, 0xa4, 0x97, 0x94, 0x95, 0x4c, + 0x45, 0x8b, 0x42, 0x3d, 0xb7, 0x8b, 0x5b, 0xfb, 0x5d, 0x1f, 0xc5, 0xa1, 0x3e, 0x2b, 0x31, 0xbd, + 0x20, 0xc3, 0xce, 0xb9, 0xd2, 0xa7, 0x2e, 0x83, 0x34, 0x76, 0x0a, 0x13, 0x02, 0x34, 0x1f, 0x85, + 0x7a, 0x7a, 0xc7, 0x89, 0x43, 0x3d, 0x2f, 0xe3, 0xb1, 0x63, 0xd8, 0x69, 0xec, 0x18, 0x4f, 0x81, + 0x31, 0xae, 0x53, 0xea, 0x13, 0x8f, 0x22, 0xe3, 0x8f, 0x02, 0x16, 0xf7, 0x68, 0x63, 0xc3, 0xf7, + 0x6d, 0x44, 0x51, 0xd0, 0x41, 0xdb, 0x6d, 0xcf, 0xa1, 0x3d, 0x22, 0x25, 0x30, 0x09, 0x7d, 0xbf, + 0x8a, 0x1d, 0x41, 0x25, 0x53, 0x29, 0x46, 0xa1, 0x9e, 0xdd, 0xf0, 0x7d, 0x51, 0x6f, 0x46, 0xd6, + 0x93, 0x01, 0x86, 0x9d, 0x85, 0xdc, 0xce, 0x69, 0x41, 0x4a, 0x11, 0xe3, 0xa0, 0x01, 0x5a, 0x1b, + 0xdc, 0x26, 0x60, 0x09, 0xad, 0x5e, 0x90, 0x61, 0xe7, 0xa0, 0xf4, 0xa9, 0xdb, 0xe0, 0x7f, 0x46, + 0x0e, 0x91, 0x57, 0x6d, 0xb5, 0xa1, 0xc7, 0x30, 0xeb, 0x0a, 0x8a, 0xd3, 0xe5, 0x45, 0x53, 0x4e, + 0xc5, 0xe4, 0x53, 0x31, 0x93, 0xa9, 0x98, 0x9b, 0x04, 0x7b, 0x95, 0xcc, 0x69, 0xa8, 0xa7, 0xec, + 0x19, 0x01, 0xfb, 0x98, 0xa0, 0x2e, 0xe4, 0xcf, 0x8c, 0x91, 0xdf, 0x78, 0x0c, 0x8a, 0xa3, 0x78, + 0x27, 0xb2, 0x7c, 0xcf, 0x5e, 0x9e, 0xf3, 0x9b, 0xa3, 0x7b, 0xcf, 0xb9, 0xaf, 0x61, 0xfa, 0xb6, + 0x1a, 0x5a, 0x20, 0x4b, 0xbe, 0x7a, 0x28, 0x10, 0xfc, 0xf3, 0x95, 0x45, 0x8e, 0xf8, 0xc0, 0x0d, + 0x71, 0xa8, 0xff, 0x27, 0x11, 0xc2, 0x6f, 0xd8, 0x32, 0x4e, 0x3d, 0x56, 0xc0, 0x83, 0x3a, 0x71, + 0x5d, 0xc8, 0x50, 0x00, 0xdd, 0xaa, 0x90, 0x43, 0xd0, 0x1f, 0x2b, 0xde, 0x5b, 0x2e, 0x5e, 0x1c, + 0xea, 0x8f, 0x64, 0xca, 0xe1, 0x04, 0xc6, 0xdf, 0x50, 0x7f, 0xd6, 0xc0, 0xec, 0x4b, 0xbb, 0x66, + 0xd6, 0x49, 0xd3, 0x4a, 0x4e, 0x43, 0xfe, 0xac, 0x52, 0xe7, 0xd0, 0xe2, 0x6b, 0x49, 0x45, 0x2e, + 0x7b, 0xb6, 0x8f, 0xde, 0xe7, 0x60, 0xf5, 0x1b, 0x00, 0x0e, 0xaa, 0xb1, 0xa4, 0x97, 0xec, 0x4d, + 0xbd, 0x6c, 0x25, 0xbd, 0xcc, 0xc9, 0x5e, 0xfa, 0xd0, 0x3b, 0x75, 0x91, 0xe7, 0x38, 0x59, 0xff, + 0x3d, 0x98, 0x1f, 0x20, 0x74, 0xb1, 0x92, 0x93, 0x72, 0x25, 0xe3, 0x50, 0x2f, 0x5e, 0x61, 0xdd, + 0x5f, 0xc9, 0xb9, 0xbe, 0x35, 0x59, 0x5c, 0xf5, 0x35, 0x98, 0x11, 0x4d, 0x5d, 0x64, 0xca, 0x89, + 0x4c, 0x85, 0x38, 0xd4, 0x17, 0x06, 0x7a, 0xee, 0xe7, 0x98, 0xe6, 0xcf, 0x3d, 0xf4, 0x1a, 0x00, + 0x98, 0x6e, 0xa1, 0x1a, 0xdb, 0x6c, 0x52, 0x56, 0x98, 0x5a, 0x52, 0x56, 0xa6, 0xc6, 0x40, 0x07, + 0x62, 0x87, 0xcf, 0x78, 0x78, 0x11, 0xe5, 0xbe, 0x96, 0x4f, 0x26, 0xc0, 0xc4, 0x1e, 0x6d, 0xa8, + 0x3f, 0x14, 0xb1, 0xd6, 0xd7, 0x5c, 0xbd, 0xba, 0x66, 0x8e, 0x7c, 0x19, 0x9a, 0x37, 0xbe, 0xd2, + 0x8a, 0xeb, 0xf7, 0x40, 0xca, 0xde, 0xd4, 0x2e, 0x50, 0xaf, 0x5e, 0x9a, 0xfa, 0xfc, 0xfa, 0x84, + 0xa3, 0x5f, 0x46, 0xc5, 0xd2, 0x1d, 0x10, 0x49, 0xe9, 0x61, 0x39, 0x2e, 0xab, 0x77, 0x2b, 0x39, + 0x46, 0x5e, 0xfe, 0xad, 0xe4, 0x18, 0x3d, 0xaa, 0xca, 0xa7, 0xd3, 0xdf, 0x5a, 0xea, 0x24, 0xd2, + 0x52, 0xa7, 0x91, 0xa6, 0x9c, 0x45, 0x9a, 0xf2, 0x2b, 0xd2, 0x94, 0xe3, 0x73, 0x2d, 0x75, 0x76, + 0xae, 0xa5, 0x7e, 0x9e, 0x6b, 0xa9, 0xcf, 0x2f, 0x2f, 0xad, 0x3b, 0x2f, 0xb3, 0x4a, 0x0e, 0x0e, + 0x70, 0x1d, 0x43, 0x37, 0x79, 0xb6, 0x86, 0x3f, 0x77, 0xe2, 0x06, 0x6a, 0x93, 0xe2, 0x23, 0xf5, + 0xe2, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x4e, 0x84, 0x10, 0x13, 0x07, 0x00, 0x00, +} + +// 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 { + MsgLiquidateInternalKeeper(ctx context.Context, in *MsgLiquidateInternalKeeperRequest, opts ...grpc.CallOption) (*MsgLiquidateInternalKeeperResponse, error) + MsgAppReserveFunds(ctx context.Context, in *MsgAppReserveFundsRequest, opts ...grpc.CallOption) (*MsgAppReserveFundsResponse, error) + MsgLiquidateExternalKeeper(ctx context.Context, in *MsgLiquidateExternalKeeperRequest, opts ...grpc.CallOption) (*MsgLiquidateExternalKeeperResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) MsgLiquidateInternalKeeper(ctx context.Context, in *MsgLiquidateInternalKeeperRequest, opts ...grpc.CallOption) (*MsgLiquidateInternalKeeperResponse, error) { + out := new(MsgLiquidateInternalKeeperResponse) + err := c.cc.Invoke(ctx, "/comdex.liquidation.v2.Msg/MsgLiquidateInternalKeeper", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) MsgAppReserveFunds(ctx context.Context, in *MsgAppReserveFundsRequest, opts ...grpc.CallOption) (*MsgAppReserveFundsResponse, error) { + out := new(MsgAppReserveFundsResponse) + err := c.cc.Invoke(ctx, "/comdex.liquidation.v2.Msg/MsgAppReserveFunds", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) MsgLiquidateExternalKeeper(ctx context.Context, in *MsgLiquidateExternalKeeperRequest, opts ...grpc.CallOption) (*MsgLiquidateExternalKeeperResponse, error) { + out := new(MsgLiquidateExternalKeeperResponse) + err := c.cc.Invoke(ctx, "/comdex.liquidation.v2.Msg/MsgLiquidateExternalKeeper", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + MsgLiquidateInternalKeeper(context.Context, *MsgLiquidateInternalKeeperRequest) (*MsgLiquidateInternalKeeperResponse, error) + MsgAppReserveFunds(context.Context, *MsgAppReserveFundsRequest) (*MsgAppReserveFundsResponse, error) + MsgLiquidateExternalKeeper(context.Context, *MsgLiquidateExternalKeeperRequest) (*MsgLiquidateExternalKeeperResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) MsgLiquidateInternalKeeper(ctx context.Context, req *MsgLiquidateInternalKeeperRequest) (*MsgLiquidateInternalKeeperResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MsgLiquidateInternalKeeper not implemented") +} +func (*UnimplementedMsgServer) MsgAppReserveFunds(ctx context.Context, req *MsgAppReserveFundsRequest) (*MsgAppReserveFundsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MsgAppReserveFunds not implemented") +} +func (*UnimplementedMsgServer) MsgLiquidateExternalKeeper(ctx context.Context, req *MsgLiquidateExternalKeeperRequest) (*MsgLiquidateExternalKeeperResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method MsgLiquidateExternalKeeper not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_MsgLiquidateInternalKeeper_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgLiquidateInternalKeeperRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MsgLiquidateInternalKeeper(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.liquidation.v2.Msg/MsgLiquidateInternalKeeper", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MsgLiquidateInternalKeeper(ctx, req.(*MsgLiquidateInternalKeeperRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_MsgAppReserveFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgAppReserveFundsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MsgAppReserveFunds(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.liquidation.v2.Msg/MsgAppReserveFunds", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MsgAppReserveFunds(ctx, req.(*MsgAppReserveFundsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_MsgLiquidateExternalKeeper_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgLiquidateExternalKeeperRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).MsgLiquidateExternalKeeper(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/comdex.liquidation.v2.Msg/MsgLiquidateExternalKeeper", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).MsgLiquidateExternalKeeper(ctx, req.(*MsgLiquidateExternalKeeperRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "comdex.liquidation.v2.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "MsgLiquidateInternalKeeper", + Handler: _Msg_MsgLiquidateInternalKeeper_Handler, + }, + { + MethodName: "MsgAppReserveFunds", + Handler: _Msg_MsgAppReserveFunds_Handler, + }, + { + MethodName: "MsgLiquidateExternalKeeper", + Handler: _Msg_MsgLiquidateExternalKeeper_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "comdex/liquidation/v2/tx.proto", +} + +func (m *MsgLiquidateInternalKeeperRequest) 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 *MsgLiquidateInternalKeeperRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgLiquidateInternalKeeperRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Id != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Id)) + i-- + dAtA[i] = 0x18 + } + if m.LiqType != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.LiqType)) + i-- + dAtA[i] = 0x10 + } + if len(m.From) > 0 { + i -= len(m.From) + copy(dAtA[i:], m.From) + i = encodeVarintTx(dAtA, i, uint64(len(m.From))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgLiquidateInternalKeeperResponse) 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 *MsgLiquidateInternalKeeperResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgLiquidateInternalKeeperResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgAppReserveFundsRequest) 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 *MsgAppReserveFundsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgAppReserveFundsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.From) > 0 { + i -= len(m.From) + copy(dAtA[i:], m.From) + i = encodeVarintTx(dAtA, i, uint64(len(m.From))) + i-- + dAtA[i] = 0x22 + } + { + size, err := m.TokenQuantity.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if m.AssetId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.AssetId)) + i-- + dAtA[i] = 0x10 + } + if m.AppId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *MsgAppReserveFundsResponse) 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 *MsgAppReserveFundsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgAppReserveFundsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgLiquidateExternalKeeperRequest) 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 *MsgLiquidateExternalKeeperRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgLiquidateExternalKeeperRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.IsDebtCmst { + i-- + if m.IsDebtCmst { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if m.DebtAssetId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.DebtAssetId)) + i-- + dAtA[i] = 0x38 + } + if m.CollateralAssetId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.CollateralAssetId)) + i-- + dAtA[i] = 0x30 + } + { + size, err := m.DebtToken.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + { + size, err := m.CollateralToken.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintTx(dAtA, i, uint64(len(m.Owner))) + i-- + dAtA[i] = 0x1a + } + if m.AppId != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.AppId)) + i-- + dAtA[i] = 0x10 + } + if len(m.From) > 0 { + i -= len(m.From) + copy(dAtA[i:], m.From) + i = encodeVarintTx(dAtA, i, uint64(len(m.From))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgLiquidateExternalKeeperResponse) 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 *MsgLiquidateExternalKeeperResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgLiquidateExternalKeeperResponse) 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 *MsgLiquidateInternalKeeperRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.From) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.LiqType != 0 { + n += 1 + sovTx(uint64(m.LiqType)) + } + if m.Id != 0 { + n += 1 + sovTx(uint64(m.Id)) + } + return n +} + +func (m *MsgLiquidateInternalKeeperResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgAppReserveFundsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.AppId != 0 { + n += 1 + sovTx(uint64(m.AppId)) + } + if m.AssetId != 0 { + n += 1 + sovTx(uint64(m.AssetId)) + } + l = m.TokenQuantity.Size() + n += 1 + l + sovTx(uint64(l)) + l = len(m.From) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgAppReserveFundsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgLiquidateExternalKeeperRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.From) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.AppId != 0 { + n += 1 + sovTx(uint64(m.AppId)) + } + l = len(m.Owner) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.CollateralToken.Size() + n += 1 + l + sovTx(uint64(l)) + l = m.DebtToken.Size() + n += 1 + l + sovTx(uint64(l)) + if m.CollateralAssetId != 0 { + n += 1 + sovTx(uint64(m.CollateralAssetId)) + } + if m.DebtAssetId != 0 { + n += 1 + sovTx(uint64(m.DebtAssetId)) + } + if m.IsDebtCmst { + n += 2 + } + return n +} + +func (m *MsgLiquidateExternalKeeperResponse) 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 *MsgLiquidateInternalKeeperRequest) 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: MsgLiquidateInternalKeeperRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgLiquidateInternalKeeperRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LiqType", wireType) + } + m.LiqType = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LiqType |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + m.Id = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Id |= 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 *MsgLiquidateInternalKeeperResponse) 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: MsgLiquidateInternalKeeperResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgLiquidateInternalKeeperResponse: 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 *MsgAppReserveFundsRequest) 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: MsgAppReserveFundsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgAppReserveFundsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) + } + m.AssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TokenQuantity", 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 err := m.TokenQuantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgAppReserveFundsResponse) 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: MsgAppReserveFundsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgAppReserveFundsResponse: 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 *MsgLiquidateExternalKeeperRequest) 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: MsgLiquidateExternalKeeperRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgLiquidateExternalKeeperRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) + } + m.AppId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AppId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralToken", 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 err := m.CollateralToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtToken", 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 err := m.DebtToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CollateralAssetId", wireType) + } + m.CollateralAssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CollateralAssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DebtAssetId", wireType) + } + m.DebtAssetId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.DebtAssetId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsDebtCmst", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsDebtCmst = bool(v != 0) + 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 *MsgLiquidateExternalKeeperResponse) 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: MsgLiquidateExternalKeeperResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgLiquidateExternalKeeperResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) From 4fee7a1e053792e8b447608e3b62cec37d18af9e Mon Sep 17 00:00:00 2001 From: Dheeraj Dubey Date: Wed, 21 Jun 2023 12:58:56 +0530 Subject: [PATCH 2/2] remove v2 pb file --- x/auction/v2types/auction.pb.go | 1513 ------------- x/auction/v2types/bid.pb.go | 2354 -------------------- x/auction/v2types/genesis.pb.go | 320 --- x/auction/v2types/gov.pb.go | 427 ---- x/auction/v2types/params.pb.go | 263 --- x/auction/v2types/query.pb.go | 530 ----- x/auction/v2types/query.pb.gw.go | 153 -- x/auction/v2types/tx.pb.go | 1968 ----------------- x/liquidation/v2types/genesis.pb.go | 322 --- x/liquidation/v2types/gov.pb.go | 407 ---- x/liquidation/v2types/liquidate.pb.go | 2867 ------------------------- x/liquidation/v2types/params.pb.go | 302 --- x/liquidation/v2types/query.pb.go | 530 ----- x/liquidation/v2types/query.pb.gw.go | 153 -- x/liquidation/v2types/tx.pb.go | 1598 -------------- 15 files changed, 13707 deletions(-) delete mode 100644 x/auction/v2types/auction.pb.go delete mode 100644 x/auction/v2types/bid.pb.go delete mode 100644 x/auction/v2types/genesis.pb.go delete mode 100644 x/auction/v2types/gov.pb.go delete mode 100644 x/auction/v2types/params.pb.go delete mode 100644 x/auction/v2types/query.pb.go delete mode 100644 x/auction/v2types/query.pb.gw.go delete mode 100644 x/auction/v2types/tx.pb.go delete mode 100644 x/liquidation/v2types/genesis.pb.go delete mode 100644 x/liquidation/v2types/gov.pb.go delete mode 100644 x/liquidation/v2types/liquidate.pb.go delete mode 100644 x/liquidation/v2types/params.pb.go delete mode 100644 x/liquidation/v2types/query.pb.go delete mode 100644 x/liquidation/v2types/query.pb.gw.go delete mode 100644 x/liquidation/v2types/tx.pb.go diff --git a/x/auction/v2types/auction.pb.go b/x/auction/v2types/auction.pb.go deleted file mode 100644 index a7d9a9dc1..000000000 --- a/x/auction/v2types/auction.pb.go +++ /dev/null @@ -1,1513 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/auction/v2/auction.proto - -package v2types - -import ( - fmt "fmt" - v2types "github.com/comdex-official/comdex/x/liquidation/v2types" - _ "github.com/cosmos/cosmos-sdk/types" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" - _ "google.golang.org/protobuf/types/known/timestamppb" - io "io" - math "math" - math_bits "math/bits" - time "time" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf -var _ = time.Kitchen - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type AuctionHistorical struct { - AuctionId uint64 `protobuf:"varint,1,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty" yaml:"auction_id"` - AuctionHistorical *Auction `protobuf:"bytes,2,opt,name=auction_historical,json=auctionHistorical,proto3" json:"auction_historical,omitempty" yaml:"auction_historical"` - LockedVault *v2types.LockedVault `protobuf:"bytes,3,opt,name=locked_vault,json=lockedVault,proto3" json:"locked_vault,omitempty" yaml:"locked_vault"` -} - -func (m *AuctionHistorical) Reset() { *m = AuctionHistorical{} } -func (m *AuctionHistorical) String() string { return proto.CompactTextString(m) } -func (*AuctionHistorical) ProtoMessage() {} -func (*AuctionHistorical) Descriptor() ([]byte, []int) { - return fileDescriptor_18605748e24be228, []int{0} -} -func (m *AuctionHistorical) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AuctionHistorical) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AuctionHistorical.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 *AuctionHistorical) XXX_Merge(src proto.Message) { - xxx_messageInfo_AuctionHistorical.Merge(m, src) -} -func (m *AuctionHistorical) XXX_Size() int { - return m.Size() -} -func (m *AuctionHistorical) XXX_DiscardUnknown() { - xxx_messageInfo_AuctionHistorical.DiscardUnknown(m) -} - -var xxx_messageInfo_AuctionHistorical proto.InternalMessageInfo - -func (m *AuctionHistorical) GetAuctionId() uint64 { - if m != nil { - return m.AuctionId - } - return 0 -} - -func (m *AuctionHistorical) GetAuctionHistorical() *Auction { - if m != nil { - return m.AuctionHistorical - } - return nil -} - -func (m *AuctionHistorical) GetLockedVault() *v2types.LockedVault { - if m != nil { - return m.LockedVault - } - return nil -} - -type Auction struct { - AuctionId uint64 `protobuf:"varint,1,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty" yaml:"auction_id"` - CollateralToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,2,opt,name=collateral_token,json=collateralToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_token" yaml:"collateral_token"` - DebtToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=debt_token,json=debtToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token" yaml:"inflow_token_target_amount"` - ActiveBiddingId uint64 `protobuf:"varint,4,opt,name=active_bidding_id,json=activeBiddingId,proto3" json:"active_bidding_id,omitempty" yaml:"active_bidding_id"` - BiddingIds []*BidOwnerMapping `protobuf:"bytes,5,rep,name=bidding_ids,json=biddingIds,proto3" json:"bidding_ids,omitempty" yaml:"bidding_ids"` - // price indicator only for dutch auctions - CollateralTokenAuctionPrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=collateral_token_auction_price,json=collateralTokenAuctionPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"collateral_token_auction_price" yaml:"outflow_token_auction_price"` - CollateralTokenOraclePrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=collateral_token_oracle_price,json=collateralTokenOraclePrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"collateral_token_oracle_price" yaml:"outflow_token_oracle_price"` - DebtTokenOraclePrice github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,9,opt,name=debt_token_oracle_price,json=debtTokenOraclePrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"debt_token_oracle_price" yaml:"inflow_token_oracle_price"` - LockedVaultId uint64 `protobuf:"varint,10,opt,name=locked_vault_id,json=lockedVaultId,proto3" json:"locked_vault_id,omitempty" yaml:"locked_vault_id"` - StartTime time.Time `protobuf:"bytes,11,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time" yaml:"start_time"` - EndTime time.Time `protobuf:"bytes,12,opt,name=end_time,json=endTime,proto3,stdtime" json:"end_time" yaml:"end_time"` - AppId uint64 `protobuf:"varint,13,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` - AuctionType bool `protobuf:"varint,14,opt,name=auction_type,json=auctionType,proto3" json:"auction_type,omitempty" yaml:"auction_type"` - CollateralAssetId uint64 `protobuf:"varint,15,opt,name=collateral_asset_id,json=collateralAssetId,proto3" json:"collateral_asset_id,omitempty" yaml:"collateral_asset_id"` - DebtAssetId uint64 `protobuf:"varint,16,opt,name=debt_asset_id,json=debtAssetId,proto3" json:"debt_asset_id,omitempty" yaml:"debt_asset_id"` - BonusAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,17,opt,name=bonus_amount,json=bonusAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonus_amount" yaml:"bonus_amount"` -} - -func (m *Auction) Reset() { *m = Auction{} } -func (m *Auction) String() string { return proto.CompactTextString(m) } -func (*Auction) ProtoMessage() {} -func (*Auction) Descriptor() ([]byte, []int) { - return fileDescriptor_18605748e24be228, []int{1} -} -func (m *Auction) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Auction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Auction.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 *Auction) XXX_Merge(src proto.Message) { - xxx_messageInfo_Auction.Merge(m, src) -} -func (m *Auction) XXX_Size() int { - return m.Size() -} -func (m *Auction) XXX_DiscardUnknown() { - xxx_messageInfo_Auction.DiscardUnknown(m) -} - -var xxx_messageInfo_Auction proto.InternalMessageInfo - -func (m *Auction) GetAuctionId() uint64 { - if m != nil { - return m.AuctionId - } - return 0 -} - -func (m *Auction) GetCollateralToken() github_com_cosmos_cosmos_sdk_types.Coin { - if m != nil { - return m.CollateralToken - } - return github_com_cosmos_cosmos_sdk_types.Coin{} -} - -func (m *Auction) GetDebtToken() github_com_cosmos_cosmos_sdk_types.Coin { - if m != nil { - return m.DebtToken - } - return github_com_cosmos_cosmos_sdk_types.Coin{} -} - -func (m *Auction) GetActiveBiddingId() uint64 { - if m != nil { - return m.ActiveBiddingId - } - return 0 -} - -func (m *Auction) GetBiddingIds() []*BidOwnerMapping { - if m != nil { - return m.BiddingIds - } - return nil -} - -func (m *Auction) GetLockedVaultId() uint64 { - if m != nil { - return m.LockedVaultId - } - return 0 -} - -func (m *Auction) GetStartTime() time.Time { - if m != nil { - return m.StartTime - } - return time.Time{} -} - -func (m *Auction) GetEndTime() time.Time { - if m != nil { - return m.EndTime - } - return time.Time{} -} - -func (m *Auction) GetAppId() uint64 { - if m != nil { - return m.AppId - } - return 0 -} - -func (m *Auction) GetAuctionType() bool { - if m != nil { - return m.AuctionType - } - return false -} - -func (m *Auction) GetCollateralAssetId() uint64 { - if m != nil { - return m.CollateralAssetId - } - return 0 -} - -func (m *Auction) GetDebtAssetId() uint64 { - if m != nil { - return m.DebtAssetId - } - return 0 -} - -type BidOwnerMapping struct { - BidId uint64 `protobuf:"varint,1,opt,name=bid_id,json=bidId,proto3" json:"bid_id,omitempty"` - BidOwner string `protobuf:"bytes,2,opt,name=bid_owner,json=bidOwner,proto3" json:"bid_owner,omitempty"` -} - -func (m *BidOwnerMapping) Reset() { *m = BidOwnerMapping{} } -func (m *BidOwnerMapping) String() string { return proto.CompactTextString(m) } -func (*BidOwnerMapping) ProtoMessage() {} -func (*BidOwnerMapping) Descriptor() ([]byte, []int) { - return fileDescriptor_18605748e24be228, []int{2} -} -func (m *BidOwnerMapping) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *BidOwnerMapping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_BidOwnerMapping.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 *BidOwnerMapping) XXX_Merge(src proto.Message) { - xxx_messageInfo_BidOwnerMapping.Merge(m, src) -} -func (m *BidOwnerMapping) XXX_Size() int { - return m.Size() -} -func (m *BidOwnerMapping) XXX_DiscardUnknown() { - xxx_messageInfo_BidOwnerMapping.DiscardUnknown(m) -} - -var xxx_messageInfo_BidOwnerMapping proto.InternalMessageInfo - -func (m *BidOwnerMapping) GetBidId() uint64 { - if m != nil { - return m.BidId - } - return 0 -} - -func (m *BidOwnerMapping) GetBidOwner() string { - if m != nil { - return m.BidOwner - } - return "" -} - -func init() { - proto.RegisterType((*AuctionHistorical)(nil), "comdex.auction.v2.AuctionHistorical") - proto.RegisterType((*Auction)(nil), "comdex.auction.v2.Auction") - proto.RegisterType((*BidOwnerMapping)(nil), "comdex.auction.v2.bidOwnerMapping") -} - -func init() { proto.RegisterFile("comdex/auction/v2/auction.proto", fileDescriptor_18605748e24be228) } - -var fileDescriptor_18605748e24be228 = []byte{ - // 939 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcb, 0x6e, 0xdb, 0x46, - 0x17, 0x36, 0xe3, 0xf8, 0xa2, 0x91, 0xfc, 0x2b, 0x62, 0x9c, 0x98, 0x91, 0x7f, 0x8b, 0xca, 0x00, - 0x4d, 0xb5, 0x09, 0x89, 0x38, 0x5d, 0x15, 0xdd, 0x98, 0x6d, 0x80, 0xa8, 0x68, 0x9a, 0x62, 0x6a, - 0x14, 0x45, 0x0b, 0x54, 0x18, 0x72, 0xc6, 0xf2, 0xc0, 0x14, 0x87, 0x15, 0x47, 0x4a, 0xfd, 0x08, - 0xdd, 0x14, 0x06, 0x0a, 0x14, 0xe8, 0x2b, 0xf4, 0x49, 0xb2, 0xcc, 0xb2, 0xe8, 0x82, 0x2d, 0xec, - 0x37, 0xe0, 0xb2, 0xab, 0x62, 0x2e, 0x34, 0x29, 0x29, 0x40, 0xea, 0xae, 0xc4, 0x73, 0xfb, 0xce, - 0x37, 0x67, 0x3e, 0x1e, 0x0a, 0xb8, 0x11, 0x9f, 0x10, 0xfa, 0x83, 0x8f, 0x67, 0x91, 0x60, 0x3c, - 0xf1, 0xe7, 0x87, 0xe5, 0xa3, 0x97, 0x4e, 0xb9, 0xe0, 0x76, 0x47, 0x27, 0x78, 0xa5, 0x77, 0x7e, - 0xd8, 0xdd, 0x1d, 0xf3, 0x31, 0x57, 0x51, 0x5f, 0x3e, 0xe9, 0xc4, 0xae, 0x3b, 0xe6, 0x7c, 0x1c, - 0x53, 0x5f, 0x59, 0xe1, 0xec, 0xc4, 0x17, 0x6c, 0x42, 0x33, 0x81, 0x27, 0xa9, 0x49, 0xe8, 0x45, - 0x3c, 0x9b, 0xf0, 0xcc, 0x0f, 0x71, 0x46, 0xfd, 0xf9, 0x93, 0x90, 0x0a, 0xfc, 0xc4, 0x8f, 0x38, - 0x33, 0x9d, 0xba, 0xef, 0x19, 0x2a, 0x31, 0xfb, 0x7e, 0xc6, 0x08, 0x2e, 0xe9, 0x94, 0x26, 0xd5, - 0x69, 0xf0, 0xe7, 0x5b, 0xa0, 0x73, 0xa4, 0xc9, 0x3c, 0x67, 0x99, 0xe0, 0x53, 0x16, 0xe1, 0xd8, - 0xfe, 0x00, 0x00, 0xc3, 0x70, 0xc4, 0x88, 0x63, 0xf5, 0xad, 0xc1, 0xed, 0xe0, 0x5e, 0x91, 0xbb, - 0x9d, 0x73, 0x3c, 0x89, 0x3f, 0x84, 0x55, 0x0c, 0xa2, 0x86, 0x31, 0x86, 0xc4, 0x3e, 0x05, 0x76, - 0x19, 0x39, 0xbd, 0xc6, 0x72, 0x6e, 0xf5, 0xad, 0x41, 0xf3, 0xb0, 0xeb, 0xad, 0x9c, 0xdc, 0x33, - 0x7d, 0x83, 0x83, 0x22, 0x77, 0x1f, 0x2c, 0x22, 0x57, 0xf5, 0x10, 0x75, 0xf0, 0x0a, 0xbf, 0xef, - 0x40, 0x2b, 0xe6, 0xd1, 0x19, 0x25, 0xa3, 0x39, 0x9e, 0xc5, 0xc2, 0x59, 0x57, 0x3d, 0x60, 0xd9, - 0xa3, 0x76, 0x66, 0xd9, 0xe7, 0x33, 0x95, 0xfa, 0x95, 0xcc, 0x0c, 0xf6, 0x8a, 0xdc, 0xbd, 0xab, - 0x7b, 0xd5, 0x11, 0x20, 0x6a, 0xc6, 0x55, 0x16, 0xfc, 0xad, 0x05, 0xb6, 0x0c, 0xbb, 0xff, 0x38, - 0x8b, 0x0b, 0x0b, 0xdc, 0x89, 0x78, 0x1c, 0x63, 0x41, 0xa7, 0x38, 0x1e, 0x09, 0x7e, 0x46, 0x13, - 0x33, 0x8a, 0x07, 0x9e, 0xbe, 0x3a, 0x4f, 0x5e, 0x9d, 0x67, 0xae, 0xce, 0xfb, 0x98, 0xb3, 0x24, - 0xf8, 0xf4, 0x75, 0xee, 0xae, 0x15, 0xb9, 0xbb, 0xa7, 0xb1, 0x97, 0x01, 0xe0, 0xdf, 0xb9, 0xfb, - 0xfe, 0x98, 0x89, 0xd3, 0x59, 0x28, 0x8f, 0xea, 0x1b, 0x09, 0xe8, 0x9f, 0xc7, 0x19, 0x39, 0xf3, - 0xc5, 0x79, 0x4a, 0x33, 0x85, 0x85, 0xda, 0x55, 0xf5, 0xb1, 0x2c, 0xb6, 0x7f, 0xb2, 0x00, 0x20, - 0x34, 0x14, 0x86, 0xcc, 0xfa, 0xbb, 0xc8, 0x1c, 0x1b, 0x32, 0x0f, 0x35, 0x19, 0x96, 0x9c, 0xc4, - 0xfc, 0x95, 0x2e, 0x1e, 0x09, 0x3c, 0x1d, 0x53, 0x31, 0xc2, 0x13, 0x3e, 0x4b, 0xc4, 0x8d, 0x68, - 0x35, 0x24, 0x05, 0x4d, 0xe8, 0x39, 0xe8, 0xe0, 0x48, 0xb0, 0x39, 0x1d, 0x85, 0x8c, 0x10, 0x96, - 0x8c, 0xe5, 0x80, 0x6f, 0xab, 0x01, 0xff, 0xbf, 0xc8, 0x5d, 0xc7, 0x0c, 0x78, 0x39, 0x05, 0xa2, - 0xb6, 0xf6, 0x05, 0xda, 0x35, 0x24, 0xf6, 0xb7, 0xa0, 0x59, 0xc5, 0x33, 0x67, 0xa3, 0xbf, 0x5e, - 0x97, 0x43, 0x4d, 0x72, 0x21, 0x23, 0x2f, 0x5f, 0x25, 0x74, 0xfa, 0x02, 0xa7, 0x29, 0x4b, 0xc6, - 0xc1, 0xfd, 0x22, 0x77, 0x6d, 0xdd, 0xa7, 0x06, 0x00, 0x11, 0x08, 0x4b, 0xec, 0xcc, 0xfe, 0xd5, - 0x02, 0xbd, 0xe5, 0x9b, 0x18, 0x95, 0xd7, 0x9e, 0x4e, 0x59, 0x44, 0x9d, 0xad, 0xbe, 0x35, 0x68, - 0xe8, 0x81, 0xfd, 0x91, 0xbb, 0x8f, 0xfe, 0xc5, 0x2c, 0x3e, 0xa1, 0x51, 0x91, 0xbb, 0x50, 0xb7, - 0xe6, 0x33, 0x51, 0x9b, 0xed, 0x02, 0x34, 0x44, 0xfb, 0x4b, 0xf7, 0x68, 0x74, 0xf9, 0x85, 0x8c, - 0xda, 0xbf, 0x58, 0xe0, 0x60, 0x85, 0x1b, 0x9f, 0xe2, 0x28, 0xa6, 0x86, 0xda, 0xb6, 0xa2, 0xf6, - 0xe5, 0x8d, 0xa9, 0x3d, 0x7c, 0x1b, 0xb5, 0x3a, 0x32, 0x44, 0xdd, 0x25, 0x66, 0x2f, 0x55, 0x54, - 0x13, 0xfb, 0xd1, 0x02, 0x7b, 0x95, 0xd8, 0x16, 0x29, 0x35, 0x14, 0x25, 0x74, 0x63, 0x4a, 0xfd, - 0xb7, 0x08, 0x71, 0x91, 0xd1, 0xee, 0xb5, 0xb8, 0xea, 0x5c, 0x02, 0xd0, 0xae, 0xbf, 0xeb, 0x52, - 0x65, 0x40, 0xa9, 0xac, 0x5b, 0xe4, 0xee, 0xfd, 0xd5, 0x65, 0xa0, 0x34, 0xb6, 0x53, 0xdb, 0x07, - 0x43, 0x62, 0x7f, 0x0d, 0x40, 0x26, 0xf0, 0x54, 0x8c, 0xe4, 0x1e, 0x76, 0x9a, 0x66, 0xa7, 0xe9, - 0x25, 0xed, 0x95, 0x4b, 0xda, 0x3b, 0x2e, 0x97, 0x74, 0x70, 0x60, 0x5e, 0x1e, 0xb3, 0x25, 0xaa, - 0x5a, 0x78, 0xf1, 0xa7, 0x6b, 0xa1, 0x86, 0x72, 0xc8, 0x74, 0x1b, 0x81, 0x6d, 0x9a, 0x10, 0x8d, - 0xdb, 0x7a, 0x27, 0xee, 0xbe, 0xc1, 0x6d, 0x6b, 0xdc, 0xb2, 0x52, 0xa3, 0x6e, 0xd1, 0x84, 0x28, - 0xcc, 0x01, 0xd8, 0xc4, 0x69, 0x2a, 0x0f, 0xba, 0xa3, 0x0e, 0xda, 0x29, 0x72, 0x77, 0xc7, 0xbc, - 0x4e, 0xca, 0x0f, 0xd1, 0x06, 0x4e, 0xd3, 0x21, 0xb1, 0x87, 0xa0, 0x55, 0xea, 0x4d, 0x8e, 0xda, - 0xf9, 0x5f, 0xdf, 0x1a, 0x6c, 0x07, 0x8f, 0x2e, 0x73, 0xb7, 0x69, 0x84, 0x76, 0x7c, 0x9e, 0xd2, - 0x6a, 0x69, 0xd6, 0x93, 0x21, 0x6a, 0xe2, 0x2a, 0xc7, 0xfe, 0x1c, 0xdc, 0xad, 0x49, 0x11, 0x67, - 0x19, 0x55, 0xa3, 0x6e, 0x2b, 0x06, 0xbd, 0x22, 0x77, 0xbb, 0x2b, 0x5b, 0xad, 0x4c, 0x82, 0xa8, - 0x53, 0x79, 0x8f, 0xa4, 0x73, 0x48, 0xec, 0x8f, 0xc0, 0x8e, 0x52, 0xd0, 0x35, 0xd2, 0x1d, 0x85, - 0xe4, 0x14, 0xb9, 0xbb, 0xab, 0x91, 0x16, 0xc2, 0x10, 0x35, 0xa5, 0x5d, 0x56, 0x9f, 0x82, 0x56, - 0xc8, 0x93, 0x59, 0x66, 0x76, 0x94, 0xd3, 0x51, 0xa2, 0x7b, 0x76, 0x03, 0xd1, 0x0d, 0x13, 0x51, - 0x9d, 0xbb, 0x8e, 0x05, 0x51, 0x53, 0x99, 0x47, 0xda, 0x7a, 0x06, 0xda, 0x4b, 0x6b, 0xc5, 0xbe, - 0x07, 0x36, 0x43, 0x46, 0xae, 0xbf, 0x17, 0x68, 0x23, 0x64, 0x64, 0x48, 0xec, 0x7d, 0xd0, 0x90, - 0x6e, 0x2e, 0x53, 0xd5, 0xc7, 0xa0, 0x81, 0xb6, 0xcb, 0xd2, 0xe0, 0xc5, 0xeb, 0xcb, 0x9e, 0xf5, - 0xe6, 0xb2, 0x67, 0xfd, 0x75, 0xd9, 0xb3, 0x2e, 0xae, 0x7a, 0x6b, 0x6f, 0xae, 0x7a, 0x6b, 0xbf, - 0x5f, 0xf5, 0xd6, 0xbe, 0x79, 0xba, 0x40, 0x56, 0xae, 0xb4, 0xc7, 0xfc, 0xe4, 0x84, 0x45, 0x0c, - 0xc7, 0xc6, 0xf6, 0xeb, 0x7f, 0x39, 0x14, 0xfb, 0x70, 0x53, 0x89, 0xe7, 0xe9, 0x3f, 0x01, 0x00, - 0x00, 0xff, 0xff, 0xd6, 0xaa, 0xe3, 0xd9, 0x93, 0x08, 0x00, 0x00, -} - -func (m *AuctionHistorical) 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 *AuctionHistorical) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AuctionHistorical) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.LockedVault != nil { - { - size, err := m.LockedVault.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - } - if m.AuctionHistorical != nil { - { - size, err := m.AuctionHistorical.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.AuctionId != 0 { - i = encodeVarintAuction(dAtA, i, uint64(m.AuctionId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *Auction) 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 *Auction) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Auction) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.BonusAmount.Size() - i -= size - if _, err := m.BonusAmount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x8a - if m.DebtAssetId != 0 { - i = encodeVarintAuction(dAtA, i, uint64(m.DebtAssetId)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x80 - } - if m.CollateralAssetId != 0 { - i = encodeVarintAuction(dAtA, i, uint64(m.CollateralAssetId)) - i-- - dAtA[i] = 0x78 - } - if m.AuctionType { - i-- - if m.AuctionType { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x70 - } - if m.AppId != 0 { - i = encodeVarintAuction(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x68 - } - n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime):]) - if err3 != nil { - return 0, err3 - } - i -= n3 - i = encodeVarintAuction(dAtA, i, uint64(n3)) - i-- - dAtA[i] = 0x62 - n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime):]) - if err4 != nil { - return 0, err4 - } - i -= n4 - i = encodeVarintAuction(dAtA, i, uint64(n4)) - i-- - dAtA[i] = 0x5a - if m.LockedVaultId != 0 { - i = encodeVarintAuction(dAtA, i, uint64(m.LockedVaultId)) - i-- - dAtA[i] = 0x50 - } - { - size := m.DebtTokenOraclePrice.Size() - i -= size - if _, err := m.DebtTokenOraclePrice.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x4a - { - size := m.CollateralTokenOraclePrice.Size() - i -= size - if _, err := m.CollateralTokenOraclePrice.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x42 - { - size := m.CollateralTokenAuctionPrice.Size() - i -= size - if _, err := m.CollateralTokenAuctionPrice.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3a - if len(m.BiddingIds) > 0 { - for iNdEx := len(m.BiddingIds) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.BiddingIds[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - } - } - if m.ActiveBiddingId != 0 { - i = encodeVarintAuction(dAtA, i, uint64(m.ActiveBiddingId)) - i-- - dAtA[i] = 0x20 - } - { - size, err := m.DebtToken.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - { - size, err := m.CollateralToken.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintAuction(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - if m.AuctionId != 0 { - i = encodeVarintAuction(dAtA, i, uint64(m.AuctionId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *BidOwnerMapping) 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 *BidOwnerMapping) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *BidOwnerMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.BidOwner) > 0 { - i -= len(m.BidOwner) - copy(dAtA[i:], m.BidOwner) - i = encodeVarintAuction(dAtA, i, uint64(len(m.BidOwner))) - i-- - dAtA[i] = 0x12 - } - if m.BidId != 0 { - i = encodeVarintAuction(dAtA, i, uint64(m.BidId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func encodeVarintAuction(dAtA []byte, offset int, v uint64) int { - offset -= sovAuction(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *AuctionHistorical) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AuctionId != 0 { - n += 1 + sovAuction(uint64(m.AuctionId)) - } - if m.AuctionHistorical != nil { - l = m.AuctionHistorical.Size() - n += 1 + l + sovAuction(uint64(l)) - } - if m.LockedVault != nil { - l = m.LockedVault.Size() - n += 1 + l + sovAuction(uint64(l)) - } - return n -} - -func (m *Auction) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AuctionId != 0 { - n += 1 + sovAuction(uint64(m.AuctionId)) - } - l = m.CollateralToken.Size() - n += 1 + l + sovAuction(uint64(l)) - l = m.DebtToken.Size() - n += 1 + l + sovAuction(uint64(l)) - if m.ActiveBiddingId != 0 { - n += 1 + sovAuction(uint64(m.ActiveBiddingId)) - } - if len(m.BiddingIds) > 0 { - for _, e := range m.BiddingIds { - l = e.Size() - n += 1 + l + sovAuction(uint64(l)) - } - } - l = m.CollateralTokenAuctionPrice.Size() - n += 1 + l + sovAuction(uint64(l)) - l = m.CollateralTokenOraclePrice.Size() - n += 1 + l + sovAuction(uint64(l)) - l = m.DebtTokenOraclePrice.Size() - n += 1 + l + sovAuction(uint64(l)) - if m.LockedVaultId != 0 { - n += 1 + sovAuction(uint64(m.LockedVaultId)) - } - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StartTime) - n += 1 + l + sovAuction(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndTime) - n += 1 + l + sovAuction(uint64(l)) - if m.AppId != 0 { - n += 1 + sovAuction(uint64(m.AppId)) - } - if m.AuctionType { - n += 2 - } - if m.CollateralAssetId != 0 { - n += 1 + sovAuction(uint64(m.CollateralAssetId)) - } - if m.DebtAssetId != 0 { - n += 2 + sovAuction(uint64(m.DebtAssetId)) - } - l = m.BonusAmount.Size() - n += 2 + l + sovAuction(uint64(l)) - return n -} - -func (m *BidOwnerMapping) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.BidId != 0 { - n += 1 + sovAuction(uint64(m.BidId)) - } - l = len(m.BidOwner) - if l > 0 { - n += 1 + l + sovAuction(uint64(l)) - } - return n -} - -func sovAuction(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozAuction(x uint64) (n int) { - return sovAuction(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *AuctionHistorical) 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 ErrIntOverflowAuction - } - 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: AuctionHistorical: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AuctionHistorical: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType) - } - m.AuctionId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AuctionId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionHistorical", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAuction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.AuctionHistorical == nil { - m.AuctionHistorical = &Auction{} - } - if err := m.AuctionHistorical.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LockedVault", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAuction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.LockedVault == nil { - m.LockedVault = &v2types.LockedVault{} - } - if err := m.LockedVault.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipAuction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthAuction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Auction) 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 ErrIntOverflowAuction - } - 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: Auction: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Auction: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType) - } - m.AuctionId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AuctionId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralToken", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAuction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.CollateralToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtToken", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAuction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.DebtToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ActiveBiddingId", wireType) - } - m.ActiveBiddingId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ActiveBiddingId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BiddingIds", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAuction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.BiddingIds = append(m.BiddingIds, &BidOwnerMapping{}) - if err := m.BiddingIds[len(m.BiddingIds)-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 CollateralTokenAuctionPrice", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - 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 ErrInvalidLengthAuction - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.CollateralTokenAuctionPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenOraclePrice", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - 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 ErrInvalidLengthAuction - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.CollateralTokenOraclePrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 9: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenOraclePrice", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - 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 ErrInvalidLengthAuction - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.DebtTokenOraclePrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 10: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LockedVaultId", wireType) - } - m.LockedVaultId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LockedVaultId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 11: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAuction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 12: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthAuction - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndTime, dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 13: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 14: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionType", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.AuctionType = bool(v != 0) - case 15: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralAssetId", wireType) - } - m.CollateralAssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CollateralAssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 16: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtAssetId", wireType) - } - m.DebtAssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebtAssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 17: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BonusAmount", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - 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 ErrInvalidLengthAuction - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.BonusAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipAuction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthAuction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *BidOwnerMapping) 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 ErrIntOverflowAuction - } - 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: bidOwnerMapping: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: bidOwnerMapping: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BidId", wireType) - } - m.BidId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.BidId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BidOwner", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowAuction - } - 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 ErrInvalidLengthAuction - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthAuction - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.BidOwner = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipAuction(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthAuction - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipAuction(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowAuction - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowAuction - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowAuction - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthAuction - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupAuction - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthAuction - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthAuction = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowAuction = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupAuction = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/auction/v2types/bid.pb.go b/x/auction/v2types/bid.pb.go deleted file mode 100644 index aa505654f..000000000 --- a/x/auction/v2types/bid.pb.go +++ /dev/null @@ -1,2354 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/auction/v2/bid.proto - -package v2types - -import ( - fmt "fmt" - _ "github.com/cosmos/cosmos-sdk/types" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" - _ "google.golang.org/protobuf/types/known/timestamppb" - io "io" - math "math" - math_bits "math/bits" - time "time" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf -var _ = time.Kitchen - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type Bid struct { - BiddingId uint64 `protobuf:"varint,1,opt,name=bidding_id,json=biddingId,proto3" json:"bidding_id,omitempty" yaml:"bidding_id"` - AuctionId uint64 `protobuf:"varint,2,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty" yaml:"auction_id"` - CollateralTokenAmount github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=collateral_token_amount,json=collateralTokenAmount,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_token_amount" yaml:"outflow_token_amount"` - DebtTokenAmount github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,4,opt,name=debt_token_amount,json=debtTokenAmount,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token_amount" yaml:"inflow_token_amount"` - BidderAddress string `protobuf:"bytes,5,opt,name=bidder_address,json=bidderAddress,proto3" json:"bidder_address,omitempty" yaml:"bidder"` - BiddingTimestamp time.Time `protobuf:"bytes,6,opt,name=bidding_timestamp,json=biddingTimestamp,proto3,stdtime" json:"bidding_timestamp" yaml:"bidding_timestamp"` - AppId uint64 `protobuf:"varint,7,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` - BidType string `protobuf:"bytes,8,opt,name=bid_type,json=bidType,proto3" json:"bid_type,omitempty" yaml:"bid_type"` -} - -func (m *Bid) Reset() { *m = Bid{} } -func (m *Bid) String() string { return proto.CompactTextString(m) } -func (*Bid) ProtoMessage() {} -func (*Bid) Descriptor() ([]byte, []int) { - return fileDescriptor_627413fbf33ef9e3, []int{0} -} -func (m *Bid) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Bid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Bid.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 *Bid) XXX_Merge(src proto.Message) { - xxx_messageInfo_Bid.Merge(m, src) -} -func (m *Bid) XXX_Size() int { - return m.Size() -} -func (m *Bid) XXX_DiscardUnknown() { - xxx_messageInfo_Bid.DiscardUnknown(m) -} - -var xxx_messageInfo_Bid proto.InternalMessageInfo - -func (m *Bid) GetBiddingId() uint64 { - if m != nil { - return m.BiddingId - } - return 0 -} - -func (m *Bid) GetAuctionId() uint64 { - if m != nil { - return m.AuctionId - } - return 0 -} - -func (m *Bid) GetCollateralTokenAmount() github_com_cosmos_cosmos_sdk_types.Coin { - if m != nil { - return m.CollateralTokenAmount - } - return github_com_cosmos_cosmos_sdk_types.Coin{} -} - -func (m *Bid) GetDebtTokenAmount() github_com_cosmos_cosmos_sdk_types.Coin { - if m != nil { - return m.DebtTokenAmount - } - return github_com_cosmos_cosmos_sdk_types.Coin{} -} - -func (m *Bid) GetBidderAddress() string { - if m != nil { - return m.BidderAddress - } - return "" -} - -func (m *Bid) GetBiddingTimestamp() time.Time { - if m != nil { - return m.BiddingTimestamp - } - return time.Time{} -} - -func (m *Bid) GetAppId() uint64 { - if m != nil { - return m.AppId - } - return 0 -} - -func (m *Bid) GetBidType() string { - if m != nil { - return m.BidType - } - return "" -} - -type LimitOrderBid struct { - LimitOrderBiddingId uint64 `protobuf:"varint,1,opt,name=limit_order_bidding_id,json=limitOrderBiddingId,proto3" json:"limit_order_bidding_id,omitempty" yaml:"limit_order_bidding_id"` - BidderAddress string `protobuf:"bytes,2,opt,name=bidder_address,json=bidderAddress,proto3" json:"bidder_address,omitempty" yaml:"bidder"` - CollateralTokenId uint64 `protobuf:"varint,3,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty" yaml:"collateral_token_id"` - PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` - DebtTokenId uint64 `protobuf:"varint,5,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty" yaml:"debt_token_id"` - DebtToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,6,opt,name=debt_token,json=debtToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token" yaml:"debt_token"` - BiddingId []uint64 `protobuf:"varint,7,rep,packed,name=bidding_id,json=biddingId,proto3" json:"bidding_id,omitempty" yaml:"bidding_id"` -} - -func (m *LimitOrderBid) Reset() { *m = LimitOrderBid{} } -func (m *LimitOrderBid) String() string { return proto.CompactTextString(m) } -func (*LimitOrderBid) ProtoMessage() {} -func (*LimitOrderBid) Descriptor() ([]byte, []int) { - return fileDescriptor_627413fbf33ef9e3, []int{1} -} -func (m *LimitOrderBid) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *LimitOrderBid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_LimitOrderBid.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 *LimitOrderBid) XXX_Merge(src proto.Message) { - xxx_messageInfo_LimitOrderBid.Merge(m, src) -} -func (m *LimitOrderBid) XXX_Size() int { - return m.Size() -} -func (m *LimitOrderBid) XXX_DiscardUnknown() { - xxx_messageInfo_LimitOrderBid.DiscardUnknown(m) -} - -var xxx_messageInfo_LimitOrderBid proto.InternalMessageInfo - -func (m *LimitOrderBid) GetLimitOrderBiddingId() uint64 { - if m != nil { - return m.LimitOrderBiddingId - } - return 0 -} - -func (m *LimitOrderBid) GetBidderAddress() string { - if m != nil { - return m.BidderAddress - } - return "" -} - -func (m *LimitOrderBid) GetCollateralTokenId() uint64 { - if m != nil { - return m.CollateralTokenId - } - return 0 -} - -func (m *LimitOrderBid) GetDebtTokenId() uint64 { - if m != nil { - return m.DebtTokenId - } - return 0 -} - -func (m *LimitOrderBid) GetDebtToken() github_com_cosmos_cosmos_sdk_types.Coin { - if m != nil { - return m.DebtToken - } - return github_com_cosmos_cosmos_sdk_types.Coin{} -} - -func (m *LimitOrderBid) GetBiddingId() []uint64 { - if m != nil { - return m.BiddingId - } - return nil -} - -type AuctionParams struct { - AuctionDurationSeconds uint64 `protobuf:"varint,1,opt,name=auction_duration_seconds,json=auctionDurationSeconds,proto3" json:"auction_duration_seconds,omitempty" yaml:"auction_duration_seconds"` - Step github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=step,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"step" yaml:"step"` - WithdrawalFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=withdrawal_fee,json=withdrawalFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"withdrawal_fee" yaml:"withdrawal_fee"` - ClosingFee github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,4,opt,name=closing_fee,json=closingFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"closing_fee" yaml:"closing_fee"` - MinUsdValueLeft uint64 `protobuf:"varint,5,opt,name=min_usd_value_left,json=minUsdValueLeft,proto3" json:"min_usd_value_left,omitempty" yaml:"min_usd_value_left"` - BidFactor github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,6,opt,name=bid_factor,json=bidFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"bid_factor" yaml:"bid_factor"` - //For external apps - LiquidationPenalty github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,7,opt,name=liquidation_penalty,json=liquidationPenalty,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"liquidation_penalty" yaml:"liquidation_penalty"` - AuctionBonus github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=auction_bonus,json=auctionBonus,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"auction_bonus" yaml:"auction_bonus"` -} - -func (m *AuctionParams) Reset() { *m = AuctionParams{} } -func (m *AuctionParams) String() string { return proto.CompactTextString(m) } -func (*AuctionParams) ProtoMessage() {} -func (*AuctionParams) Descriptor() ([]byte, []int) { - return fileDescriptor_627413fbf33ef9e3, []int{2} -} -func (m *AuctionParams) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AuctionParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AuctionParams.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 *AuctionParams) XXX_Merge(src proto.Message) { - xxx_messageInfo_AuctionParams.Merge(m, src) -} -func (m *AuctionParams) XXX_Size() int { - return m.Size() -} -func (m *AuctionParams) XXX_DiscardUnknown() { - xxx_messageInfo_AuctionParams.DiscardUnknown(m) -} - -var xxx_messageInfo_AuctionParams proto.InternalMessageInfo - -func (m *AuctionParams) GetAuctionDurationSeconds() uint64 { - if m != nil { - return m.AuctionDurationSeconds - } - return 0 -} - -func (m *AuctionParams) GetMinUsdValueLeft() uint64 { - if m != nil { - return m.MinUsdValueLeft - } - return 0 -} - -type LimitOrderBidsForUser struct { - BidderAddress string `protobuf:"bytes,1,opt,name=bidder_address,json=bidderAddress,proto3" json:"bidder_address,omitempty" yaml:"bidder"` - LimitOrderBidKey []LimitOrderUserKey `protobuf:"bytes,2,rep,name=limit_order_bid_key,json=limitOrderBidKey,proto3" json:"limit_order_bid_key" yaml:"limit_order_bid_key"` -} - -func (m *LimitOrderBidsForUser) Reset() { *m = LimitOrderBidsForUser{} } -func (m *LimitOrderBidsForUser) String() string { return proto.CompactTextString(m) } -func (*LimitOrderBidsForUser) ProtoMessage() {} -func (*LimitOrderBidsForUser) Descriptor() ([]byte, []int) { - return fileDescriptor_627413fbf33ef9e3, []int{3} -} -func (m *LimitOrderBidsForUser) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *LimitOrderBidsForUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_LimitOrderBidsForUser.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 *LimitOrderBidsForUser) XXX_Merge(src proto.Message) { - xxx_messageInfo_LimitOrderBidsForUser.Merge(m, src) -} -func (m *LimitOrderBidsForUser) XXX_Size() int { - return m.Size() -} -func (m *LimitOrderBidsForUser) XXX_DiscardUnknown() { - xxx_messageInfo_LimitOrderBidsForUser.DiscardUnknown(m) -} - -var xxx_messageInfo_LimitOrderBidsForUser proto.InternalMessageInfo - -func (m *LimitOrderBidsForUser) GetBidderAddress() string { - if m != nil { - return m.BidderAddress - } - return "" -} - -func (m *LimitOrderBidsForUser) GetLimitOrderBidKey() []LimitOrderUserKey { - if m != nil { - return m.LimitOrderBidKey - } - return nil -} - -type LimitOrderUserKey struct { - DebtTokenId uint64 `protobuf:"varint,1,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty" yaml:"debt_token_id"` - CollateralTokenId uint64 `protobuf:"varint,2,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty" yaml:"collateral_token_id"` - PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` - LimitOrderBiddingId uint64 `protobuf:"varint,4,opt,name=limit_order_bidding_id,json=limitOrderBiddingId,proto3" json:"limit_order_bidding_id,omitempty" yaml:"limit_order_bidding_id"` -} - -func (m *LimitOrderUserKey) Reset() { *m = LimitOrderUserKey{} } -func (m *LimitOrderUserKey) String() string { return proto.CompactTextString(m) } -func (*LimitOrderUserKey) ProtoMessage() {} -func (*LimitOrderUserKey) Descriptor() ([]byte, []int) { - return fileDescriptor_627413fbf33ef9e3, []int{4} -} -func (m *LimitOrderUserKey) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *LimitOrderUserKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_LimitOrderUserKey.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 *LimitOrderUserKey) XXX_Merge(src proto.Message) { - xxx_messageInfo_LimitOrderUserKey.Merge(m, src) -} -func (m *LimitOrderUserKey) XXX_Size() int { - return m.Size() -} -func (m *LimitOrderUserKey) XXX_DiscardUnknown() { - xxx_messageInfo_LimitOrderUserKey.DiscardUnknown(m) -} - -var xxx_messageInfo_LimitOrderUserKey proto.InternalMessageInfo - -func (m *LimitOrderUserKey) GetDebtTokenId() uint64 { - if m != nil { - return m.DebtTokenId - } - return 0 -} - -func (m *LimitOrderUserKey) GetCollateralTokenId() uint64 { - if m != nil { - return m.CollateralTokenId - } - return 0 -} - -func (m *LimitOrderUserKey) GetLimitOrderBiddingId() uint64 { - if m != nil { - return m.LimitOrderBiddingId - } - return 0 -} - -type AuctionFeesCollectionFromLimitBidTx struct { - AssetId uint64 `protobuf:"varint,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty" yaml:"asset_id"` - Amount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount" yaml:"amount"` -} - -func (m *AuctionFeesCollectionFromLimitBidTx) Reset() { *m = AuctionFeesCollectionFromLimitBidTx{} } -func (m *AuctionFeesCollectionFromLimitBidTx) String() string { return proto.CompactTextString(m) } -func (*AuctionFeesCollectionFromLimitBidTx) ProtoMessage() {} -func (*AuctionFeesCollectionFromLimitBidTx) Descriptor() ([]byte, []int) { - return fileDescriptor_627413fbf33ef9e3, []int{5} -} -func (m *AuctionFeesCollectionFromLimitBidTx) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AuctionFeesCollectionFromLimitBidTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AuctionFeesCollectionFromLimitBidTx.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 *AuctionFeesCollectionFromLimitBidTx) XXX_Merge(src proto.Message) { - xxx_messageInfo_AuctionFeesCollectionFromLimitBidTx.Merge(m, src) -} -func (m *AuctionFeesCollectionFromLimitBidTx) XXX_Size() int { - return m.Size() -} -func (m *AuctionFeesCollectionFromLimitBidTx) XXX_DiscardUnknown() { - xxx_messageInfo_AuctionFeesCollectionFromLimitBidTx.DiscardUnknown(m) -} - -var xxx_messageInfo_AuctionFeesCollectionFromLimitBidTx proto.InternalMessageInfo - -func (m *AuctionFeesCollectionFromLimitBidTx) GetAssetId() uint64 { - if m != nil { - return m.AssetId - } - return 0 -} - -func init() { - proto.RegisterType((*Bid)(nil), "comdex.auction.v2.Bid") - proto.RegisterType((*LimitOrderBid)(nil), "comdex.auction.v2.LimitOrderBid") - proto.RegisterType((*AuctionParams)(nil), "comdex.auction.v2.AuctionParams") - proto.RegisterType((*LimitOrderBidsForUser)(nil), "comdex.auction.v2.LimitOrderBidsForUser") - proto.RegisterType((*LimitOrderUserKey)(nil), "comdex.auction.v2.LimitOrderUserKey") - proto.RegisterType((*AuctionFeesCollectionFromLimitBidTx)(nil), "comdex.auction.v2.AuctionFeesCollectionFromLimitBidTx") -} - -func init() { proto.RegisterFile("comdex/auction/v2/bid.proto", fileDescriptor_627413fbf33ef9e3) } - -var fileDescriptor_627413fbf33ef9e3 = []byte{ - // 1115 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xc1, 0x6e, 0xdb, 0xb6, - 0x1f, 0x8e, 0x12, 0x27, 0xa9, 0x99, 0xbf, 0x9b, 0x58, 0x49, 0x5a, 0x37, 0x45, 0xad, 0xfc, 0xd9, - 0x62, 0xcb, 0xa5, 0x12, 0x9a, 0xee, 0x30, 0x0c, 0x1b, 0x86, 0x28, 0x81, 0x07, 0xaf, 0x69, 0xd7, - 0x69, 0x69, 0x07, 0x0c, 0x18, 0x04, 0x49, 0xa4, 0x5d, 0x22, 0x92, 0xe8, 0x89, 0x54, 0x52, 0x1f, - 0xb6, 0x67, 0xe8, 0x61, 0x2f, 0xb0, 0x17, 0xd8, 0x2e, 0x7b, 0x88, 0x62, 0xa7, 0x1e, 0x87, 0x0d, - 0xd0, 0x86, 0xe4, 0x01, 0x06, 0xf8, 0xb8, 0xd3, 0x20, 0x92, 0xb6, 0x2c, 0x3b, 0xdd, 0x62, 0x74, - 0x3b, 0x89, 0xfc, 0xfd, 0xc8, 0xef, 0xf7, 0x89, 0xfc, 0xf8, 0x91, 0xe0, 0x66, 0x40, 0x23, 0x84, - 0x9f, 0x5b, 0x5e, 0x1a, 0x70, 0x42, 0x63, 0xeb, 0x64, 0xd7, 0xf2, 0x09, 0x32, 0x7b, 0x09, 0xe5, - 0x54, 0xaf, 0xcb, 0xa4, 0xa9, 0x92, 0xe6, 0xc9, 0xee, 0xd6, 0x46, 0x97, 0x76, 0xa9, 0xc8, 0x5a, - 0x79, 0x4b, 0x0e, 0xdc, 0x32, 0xba, 0x94, 0x76, 0x43, 0x6c, 0x89, 0x9e, 0x9f, 0x76, 0x2c, 0x4e, - 0x22, 0xcc, 0xb8, 0x17, 0xf5, 0xd4, 0x80, 0x66, 0x40, 0x59, 0x44, 0x99, 0xe5, 0x7b, 0x0c, 0x5b, - 0x27, 0xf7, 0x7c, 0xcc, 0xbd, 0x7b, 0x56, 0x40, 0x49, 0x2c, 0xf3, 0xf0, 0x87, 0x45, 0xb0, 0x60, - 0x13, 0xa4, 0xbf, 0x03, 0x80, 0x4f, 0x10, 0x22, 0x71, 0xd7, 0x25, 0xa8, 0xa1, 0x6d, 0x6b, 0x3b, - 0x15, 0x7b, 0x73, 0x90, 0x19, 0xf5, 0xbe, 0x17, 0x85, 0xef, 0xc1, 0x22, 0x07, 0x9d, 0xaa, 0xea, - 0xb4, 0xc5, 0x2c, 0x45, 0x31, 0x9f, 0x35, 0x3f, 0x39, 0xab, 0xc8, 0x41, 0xa7, 0xaa, 0x3a, 0x6d, - 0xa4, 0x7f, 0xa7, 0x81, 0xeb, 0x01, 0x0d, 0x43, 0x8f, 0xe3, 0xc4, 0x0b, 0x5d, 0x4e, 0x8f, 0x71, - 0xec, 0x7a, 0x11, 0x4d, 0x63, 0xde, 0x58, 0xd8, 0xd6, 0x76, 0x56, 0x76, 0x6f, 0x98, 0x92, 0xb6, - 0x99, 0xd3, 0x36, 0x15, 0x6d, 0x73, 0x9f, 0x92, 0xd8, 0x7e, 0xf4, 0x32, 0x33, 0xe6, 0x06, 0x99, - 0x71, 0x53, 0x96, 0xa0, 0x29, 0xef, 0x84, 0xf4, 0xb4, 0x04, 0x02, 0xff, 0xcc, 0x8c, 0xb7, 0xbb, - 0x84, 0x3f, 0x4b, 0x7d, 0x33, 0xa0, 0x91, 0xa5, 0x96, 0x40, 0x7e, 0xee, 0x32, 0x74, 0x6c, 0xf1, - 0x7e, 0x0f, 0x33, 0x81, 0xe7, 0x6c, 0x16, 0x4c, 0x8e, 0x72, 0x8c, 0x3d, 0x01, 0xa1, 0x7f, 0xab, - 0x81, 0x3a, 0xc2, 0x3e, 0x2f, 0xb3, 0xab, 0xfc, 0x13, 0xbb, 0x87, 0x8a, 0xdd, 0x96, 0x64, 0x47, - 0xe2, 0x37, 0x23, 0xb7, 0x9a, 0x53, 0x18, 0xa7, 0xf5, 0x2e, 0xb8, 0x9a, 0xaf, 0x3e, 0x4e, 0x5c, - 0x0f, 0xa1, 0x04, 0x33, 0xd6, 0x58, 0xdc, 0xd6, 0x76, 0xaa, 0x76, 0x7d, 0x90, 0x19, 0xb5, 0x62, - 0xab, 0x70, 0x02, 0x9d, 0x9a, 0x6c, 0xec, 0xc9, 0x71, 0x7a, 0x04, 0xea, 0xc3, 0x4d, 0x1c, 0x69, - 0xa4, 0xb1, 0x24, 0xfe, 0x67, 0xcb, 0x94, 0x2a, 0x32, 0x87, 0x2a, 0x32, 0x8f, 0x86, 0x23, 0xec, - 0x3b, 0xea, 0x87, 0x1a, 0x65, 0x1d, 0x8c, 0x20, 0xe0, 0x8b, 0xdf, 0x0c, 0xcd, 0x59, 0x53, 0xf1, - 0xd1, 0x3c, 0x7d, 0x07, 0x2c, 0x79, 0xbd, 0x5e, 0xae, 0x8a, 0x65, 0xa1, 0x8a, 0x31, 0x82, 0x32, - 0x0e, 0x9d, 0x45, 0xaf, 0xd7, 0x6b, 0x23, 0xdd, 0x04, 0x57, 0x7c, 0x82, 0xdc, 0xfc, 0xaf, 0x1b, - 0x57, 0xc4, 0xcf, 0xac, 0x0f, 0x32, 0x63, 0x75, 0x54, 0x4f, 0x64, 0xa0, 0xb3, 0xec, 0x13, 0x74, - 0x94, 0xb7, 0x7e, 0xad, 0x80, 0xda, 0x21, 0x89, 0x08, 0xff, 0x24, 0x41, 0x38, 0xc9, 0xb5, 0xfb, - 0x14, 0x5c, 0x0b, 0xf3, 0x80, 0x4b, 0xf3, 0x88, 0x3b, 0xa5, 0xe3, 0xff, 0x0f, 0x32, 0xe3, 0x96, - 0xc4, 0xbb, 0x78, 0x1c, 0x74, 0xd6, 0xc3, 0x71, 0x44, 0xa5, 0xee, 0xe9, 0xc5, 0x9e, 0xbf, 0xe4, - 0x62, 0x3f, 0x02, 0xeb, 0x53, 0x02, 0x27, 0x48, 0x88, 0xbb, 0x62, 0x37, 0x0b, 0x7d, 0x5c, 0x30, - 0x08, 0x3a, 0xf5, 0x09, 0x45, 0xb6, 0x91, 0xce, 0xc1, 0x5a, 0x2f, 0xc1, 0x11, 0x49, 0x23, 0x17, - 0x11, 0x16, 0x8c, 0xb4, 0x58, 0xb5, 0xdb, 0xf9, 0xfe, 0xfc, 0x92, 0x19, 0x6f, 0x5d, 0x42, 0x52, - 0xed, 0x98, 0x0f, 0x32, 0xe3, 0xba, 0x2c, 0x3d, 0x89, 0x07, 0x9d, 0x55, 0x15, 0x3a, 0x50, 0x11, - 0xfd, 0x7d, 0x50, 0x1b, 0x3b, 0x02, 0x04, 0x09, 0xad, 0x55, 0xec, 0xc6, 0x20, 0x33, 0x36, 0x24, - 0x48, 0x29, 0x0d, 0x9d, 0x95, 0x91, 0x5c, 0xdb, 0x48, 0xff, 0x06, 0x80, 0x22, 0xad, 0x94, 0xf6, - 0x37, 0x27, 0xe7, 0x40, 0x09, 0xad, 0x3e, 0x89, 0x3c, 0xd3, 0x81, 0xa9, 0x8e, 0x18, 0x4c, 0x38, - 0xda, 0xf2, 0xf6, 0xc2, 0x65, 0x1c, 0x0d, 0xfe, 0xb8, 0x04, 0x6a, 0x7b, 0xd2, 0xa9, 0x1e, 0x7b, - 0x89, 0x17, 0x31, 0xfd, 0x4b, 0xd0, 0x18, 0xfa, 0x18, 0x4a, 0x13, 0x4f, 0x34, 0x18, 0x0e, 0x68, - 0x8c, 0x98, 0xd2, 0xd7, 0xed, 0x41, 0x66, 0x18, 0x65, 0xc7, 0x9b, 0x1c, 0x09, 0x9d, 0x6b, 0x2a, - 0x75, 0xa0, 0x32, 0x9f, 0xc9, 0x84, 0xfe, 0x29, 0xa8, 0x30, 0x8e, 0x7b, 0x4a, 0x5a, 0x1f, 0xcc, - 0xb0, 0x9d, 0x07, 0x38, 0x18, 0x64, 0xc6, 0x8a, 0x2c, 0x9c, 0x63, 0x40, 0x47, 0x40, 0xe9, 0x31, - 0xb8, 0x7a, 0x4a, 0xf8, 0x33, 0x94, 0x78, 0xa7, 0x5e, 0xe8, 0x76, 0x30, 0x16, 0xc2, 0xab, 0xda, - 0x1f, 0xcd, 0x0c, 0xbe, 0x29, 0xc1, 0xcb, 0x68, 0xd0, 0xa9, 0x15, 0x81, 0x16, 0xc6, 0x3a, 0x06, - 0x2b, 0x41, 0x48, 0x59, 0xbe, 0x9a, 0x79, 0x31, 0x29, 0xcc, 0x83, 0x99, 0x8b, 0xe9, 0xea, 0x4c, - 0x14, 0x50, 0xd0, 0x01, 0xaa, 0x97, 0x97, 0xf9, 0x18, 0xe8, 0x11, 0x89, 0xdd, 0x94, 0x21, 0xf7, - 0xc4, 0x0b, 0x53, 0xec, 0x86, 0xb8, 0xc3, 0x95, 0x26, 0x6f, 0x0d, 0x32, 0xe3, 0x86, 0x9c, 0x3f, - 0x3d, 0x06, 0x3a, 0xab, 0x11, 0x89, 0x9f, 0x30, 0xf4, 0x34, 0x0f, 0x1d, 0xe2, 0x0e, 0xd7, 0x7d, - 0x21, 0x0e, 0xb7, 0xe3, 0x05, 0x9c, 0x26, 0x42, 0x9c, 0x55, 0x7b, 0x7f, 0x66, 0xc6, 0x85, 0x94, - 0x14, 0x92, 0x94, 0x52, 0x4b, 0xb4, 0xf5, 0xaf, 0xc1, 0x7a, 0x48, 0xbe, 0x4a, 0x09, 0x92, 0x4a, - 0xe8, 0xe1, 0xd8, 0x0b, 0x79, 0x5f, 0xf8, 0x61, 0xd5, 0x3e, 0x9c, 0xb9, 0xd8, 0xd6, 0xd0, 0xc1, - 0xa6, 0x20, 0xa1, 0xa3, 0x8f, 0x45, 0x1f, 0xcb, 0xa0, 0x7e, 0x0c, 0x6a, 0x43, 0x35, 0xfa, 0x34, - 0x4e, 0x99, 0x32, 0xd7, 0xd6, 0xcc, 0x85, 0x37, 0xca, 0xd2, 0x16, 0x60, 0xd0, 0xf9, 0x9f, 0xea, - 0xdb, 0xa2, 0xfb, 0x93, 0x06, 0x36, 0x4b, 0xa6, 0xcc, 0x5a, 0x34, 0x79, 0xc2, 0x70, 0x72, 0x81, - 0x89, 0x6a, 0x97, 0x34, 0xd1, 0x53, 0xb0, 0x3e, 0x61, 0xd7, 0xee, 0x31, 0xee, 0x37, 0xe6, 0xb7, - 0x17, 0x76, 0x56, 0x76, 0xef, 0x98, 0x53, 0x4f, 0x24, 0xb3, 0x20, 0x90, 0x57, 0x7e, 0x80, 0xfb, - 0x36, 0x2c, 0x5f, 0xc7, 0x17, 0xc0, 0x41, 0x67, 0xad, 0x64, 0xfd, 0x0f, 0x70, 0x1f, 0xfe, 0x31, - 0x0f, 0xea, 0x53, 0x58, 0xd3, 0x6e, 0xa8, 0xcd, 0xe2, 0x86, 0xaf, 0xb9, 0x11, 0xe6, 0xff, 0xcd, - 0x1b, 0x61, 0xe1, 0x3f, 0xbf, 0x11, 0x5e, 0x7f, 0xd3, 0x56, 0xde, 0xe4, 0xa6, 0x85, 0xdf, 0x6b, - 0xe0, 0xb6, 0x72, 0xdd, 0x16, 0xc6, 0x6c, 0x9f, 0x86, 0x21, 0x96, 0xbd, 0x84, 0x46, 0x62, 0x2b, - 0x6c, 0x82, 0x8e, 0x9e, 0xe7, 0x6f, 0x05, 0x8f, 0x31, 0xcc, 0x8b, 0xe5, 0x1f, 0x7b, 0x2b, 0x0c, - 0x33, 0xd0, 0x59, 0x16, 0xcd, 0x36, 0xd2, 0x3f, 0x07, 0x4b, 0xea, 0xe5, 0x26, 0xed, 0xf5, 0xc3, - 0x99, 0xd7, 0x66, 0xf8, 0x66, 0x91, 0x6f, 0x37, 0x47, 0xc1, 0xd9, 0x0f, 0x5f, 0x9e, 0x35, 0xb5, - 0x57, 0x67, 0x4d, 0xed, 0xf7, 0xb3, 0xa6, 0xf6, 0xe2, 0xbc, 0x39, 0xf7, 0xea, 0xbc, 0x39, 0xf7, - 0xf3, 0x79, 0x73, 0xee, 0x8b, 0xfb, 0x25, 0xe8, 0x5c, 0xa2, 0x77, 0x69, 0xa7, 0x43, 0x02, 0xe2, - 0x85, 0xaa, 0x6f, 0x8d, 0x3f, 0xfa, 0x45, 0x2d, 0x7f, 0x49, 0xbc, 0xbc, 0xee, 0xff, 0x15, 0x00, - 0x00, 0xff, 0xff, 0x4d, 0xea, 0x17, 0xec, 0x15, 0x0c, 0x00, 0x00, -} - -func (m *Bid) 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 *Bid) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Bid) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.BidType) > 0 { - i -= len(m.BidType) - copy(dAtA[i:], m.BidType) - i = encodeVarintBid(dAtA, i, uint64(len(m.BidType))) - i-- - dAtA[i] = 0x42 - } - if m.AppId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x38 - } - n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.BiddingTimestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.BiddingTimestamp):]) - if err1 != nil { - return 0, err1 - } - i -= n1 - i = encodeVarintBid(dAtA, i, uint64(n1)) - i-- - dAtA[i] = 0x32 - if len(m.BidderAddress) > 0 { - i -= len(m.BidderAddress) - copy(dAtA[i:], m.BidderAddress) - i = encodeVarintBid(dAtA, i, uint64(len(m.BidderAddress))) - i-- - dAtA[i] = 0x2a - } - { - size, err := m.DebtTokenAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - { - size, err := m.CollateralTokenAmount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if m.AuctionId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.AuctionId)) - i-- - dAtA[i] = 0x10 - } - if m.BiddingId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.BiddingId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *LimitOrderBid) 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 *LimitOrderBid) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *LimitOrderBid) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.BiddingId) > 0 { - dAtA5 := make([]byte, len(m.BiddingId)*10) - var j4 int - for _, num := range m.BiddingId { - for num >= 1<<7 { - dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80) - num >>= 7 - j4++ - } - dAtA5[j4] = uint8(num) - j4++ - } - i -= j4 - copy(dAtA[i:], dAtA5[:j4]) - i = encodeVarintBid(dAtA, i, uint64(j4)) - i-- - dAtA[i] = 0x3a - } - { - size, err := m.DebtToken.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - if m.DebtTokenId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.DebtTokenId)) - i-- - dAtA[i] = 0x28 - } - { - size := m.PremiumDiscount.Size() - i -= size - if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - if m.CollateralTokenId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.CollateralTokenId)) - i-- - dAtA[i] = 0x18 - } - if len(m.BidderAddress) > 0 { - i -= len(m.BidderAddress) - copy(dAtA[i:], m.BidderAddress) - i = encodeVarintBid(dAtA, i, uint64(len(m.BidderAddress))) - i-- - dAtA[i] = 0x12 - } - if m.LimitOrderBiddingId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.LimitOrderBiddingId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *AuctionParams) 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 *AuctionParams) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AuctionParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.AuctionBonus.Size() - i -= size - if _, err := m.AuctionBonus.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x42 - { - size := m.LiquidationPenalty.Size() - i -= size - if _, err := m.LiquidationPenalty.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3a - { - size := m.BidFactor.Size() - i -= size - if _, err := m.BidFactor.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - if m.MinUsdValueLeft != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.MinUsdValueLeft)) - i-- - dAtA[i] = 0x28 - } - { - size := m.ClosingFee.Size() - i -= size - if _, err := m.ClosingFee.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - { - size := m.WithdrawalFee.Size() - i -= size - if _, err := m.WithdrawalFee.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - { - size := m.Step.Size() - i -= size - if _, err := m.Step.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - if m.AuctionDurationSeconds != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.AuctionDurationSeconds)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *LimitOrderBidsForUser) 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 *LimitOrderBidsForUser) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *LimitOrderBidsForUser) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.LimitOrderBidKey) > 0 { - for iNdEx := len(m.LimitOrderBidKey) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.LimitOrderBidKey[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if len(m.BidderAddress) > 0 { - i -= len(m.BidderAddress) - copy(dAtA[i:], m.BidderAddress) - i = encodeVarintBid(dAtA, i, uint64(len(m.BidderAddress))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *LimitOrderUserKey) 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 *LimitOrderUserKey) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *LimitOrderUserKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.LimitOrderBiddingId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.LimitOrderBiddingId)) - i-- - dAtA[i] = 0x20 - } - { - size := m.PremiumDiscount.Size() - i -= size - if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if m.CollateralTokenId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.CollateralTokenId)) - i-- - dAtA[i] = 0x10 - } - if m.DebtTokenId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.DebtTokenId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *AuctionFeesCollectionFromLimitBidTx) 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 *AuctionFeesCollectionFromLimitBidTx) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AuctionFeesCollectionFromLimitBidTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.Amount.Size() - i -= size - if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintBid(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - if m.AssetId != 0 { - i = encodeVarintBid(dAtA, i, uint64(m.AssetId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func encodeVarintBid(dAtA []byte, offset int, v uint64) int { - offset -= sovBid(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *Bid) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.BiddingId != 0 { - n += 1 + sovBid(uint64(m.BiddingId)) - } - if m.AuctionId != 0 { - n += 1 + sovBid(uint64(m.AuctionId)) - } - l = m.CollateralTokenAmount.Size() - n += 1 + l + sovBid(uint64(l)) - l = m.DebtTokenAmount.Size() - n += 1 + l + sovBid(uint64(l)) - l = len(m.BidderAddress) - if l > 0 { - n += 1 + l + sovBid(uint64(l)) - } - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.BiddingTimestamp) - n += 1 + l + sovBid(uint64(l)) - if m.AppId != 0 { - n += 1 + sovBid(uint64(m.AppId)) - } - l = len(m.BidType) - if l > 0 { - n += 1 + l + sovBid(uint64(l)) - } - return n -} - -func (m *LimitOrderBid) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.LimitOrderBiddingId != 0 { - n += 1 + sovBid(uint64(m.LimitOrderBiddingId)) - } - l = len(m.BidderAddress) - if l > 0 { - n += 1 + l + sovBid(uint64(l)) - } - if m.CollateralTokenId != 0 { - n += 1 + sovBid(uint64(m.CollateralTokenId)) - } - l = m.PremiumDiscount.Size() - n += 1 + l + sovBid(uint64(l)) - if m.DebtTokenId != 0 { - n += 1 + sovBid(uint64(m.DebtTokenId)) - } - l = m.DebtToken.Size() - n += 1 + l + sovBid(uint64(l)) - if len(m.BiddingId) > 0 { - l = 0 - for _, e := range m.BiddingId { - l += sovBid(uint64(e)) - } - n += 1 + sovBid(uint64(l)) + l - } - return n -} - -func (m *AuctionParams) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AuctionDurationSeconds != 0 { - n += 1 + sovBid(uint64(m.AuctionDurationSeconds)) - } - l = m.Step.Size() - n += 1 + l + sovBid(uint64(l)) - l = m.WithdrawalFee.Size() - n += 1 + l + sovBid(uint64(l)) - l = m.ClosingFee.Size() - n += 1 + l + sovBid(uint64(l)) - if m.MinUsdValueLeft != 0 { - n += 1 + sovBid(uint64(m.MinUsdValueLeft)) - } - l = m.BidFactor.Size() - n += 1 + l + sovBid(uint64(l)) - l = m.LiquidationPenalty.Size() - n += 1 + l + sovBid(uint64(l)) - l = m.AuctionBonus.Size() - n += 1 + l + sovBid(uint64(l)) - return n -} - -func (m *LimitOrderBidsForUser) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.BidderAddress) - if l > 0 { - n += 1 + l + sovBid(uint64(l)) - } - if len(m.LimitOrderBidKey) > 0 { - for _, e := range m.LimitOrderBidKey { - l = e.Size() - n += 1 + l + sovBid(uint64(l)) - } - } - return n -} - -func (m *LimitOrderUserKey) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DebtTokenId != 0 { - n += 1 + sovBid(uint64(m.DebtTokenId)) - } - if m.CollateralTokenId != 0 { - n += 1 + sovBid(uint64(m.CollateralTokenId)) - } - l = m.PremiumDiscount.Size() - n += 1 + l + sovBid(uint64(l)) - if m.LimitOrderBiddingId != 0 { - n += 1 + sovBid(uint64(m.LimitOrderBiddingId)) - } - return n -} - -func (m *AuctionFeesCollectionFromLimitBidTx) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AssetId != 0 { - n += 1 + sovBid(uint64(m.AssetId)) - } - l = m.Amount.Size() - n += 1 + l + sovBid(uint64(l)) - return n -} - -func sovBid(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozBid(x uint64) (n int) { - return sovBid(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *Bid) 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 ErrIntOverflowBid - } - 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: Bid: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Bid: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field BiddingId", wireType) - } - m.BiddingId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.BiddingId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType) - } - m.AuctionId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AuctionId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenAmount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthBid - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.CollateralTokenAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenAmount", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthBid - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.DebtTokenAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BidderAddress", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.BidderAddress = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BiddingTimestamp", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthBid - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.BiddingTimestamp, dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BidType", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.BidType = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipBid(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBid - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LimitOrderBid) 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 ErrIntOverflowBid - } - 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: LimitOrderBid: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LimitOrderBid: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LimitOrderBiddingId", wireType) - } - m.LimitOrderBiddingId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LimitOrderBiddingId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BidderAddress", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.BidderAddress = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) - } - m.CollateralTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CollateralTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) - } - m.DebtTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebtTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtToken", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthBid - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.DebtToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType == 0 { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.BiddingId = append(m.BiddingId, v) - } else if wireType == 2 { - var packedLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - packedLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if packedLen < 0 { - return ErrInvalidLengthBid - } - postIndex := iNdEx + packedLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - var elementCount int - var count int - for _, integer := range dAtA[iNdEx:postIndex] { - if integer < 128 { - count++ - } - } - elementCount = count - if elementCount != 0 && len(m.BiddingId) == 0 { - m.BiddingId = make([]uint64, 0, elementCount) - } - for iNdEx < postIndex { - var v uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.BiddingId = append(m.BiddingId, v) - } - } else { - return fmt.Errorf("proto: wrong wireType = %d for field BiddingId", wireType) - } - default: - iNdEx = preIndex - skippy, err := skipBid(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBid - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AuctionParams) 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 ErrIntOverflowBid - } - 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: AuctionParams: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AuctionParams: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionDurationSeconds", wireType) - } - m.AuctionDurationSeconds = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AuctionDurationSeconds |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Step.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field WithdrawalFee", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.WithdrawalFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClosingFee", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.ClosingFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MinUsdValueLeft", wireType) - } - m.MinUsdValueLeft = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MinUsdValueLeft |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BidFactor", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.BidFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LiquidationPenalty", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.LiquidationPenalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionBonus", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.AuctionBonus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipBid(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBid - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LimitOrderBidsForUser) 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 ErrIntOverflowBid - } - 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: LimitOrderBidsForUser: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LimitOrderBidsForUser: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BidderAddress", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.BidderAddress = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LimitOrderBidKey", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthBid - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.LimitOrderBidKey = append(m.LimitOrderBidKey, LimitOrderUserKey{}) - if err := m.LimitOrderBidKey[len(m.LimitOrderBidKey)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipBid(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBid - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LimitOrderUserKey) 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 ErrIntOverflowBid - } - 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: LimitOrderUserKey: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LimitOrderUserKey: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) - } - m.DebtTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebtTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) - } - m.CollateralTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CollateralTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LimitOrderBiddingId", wireType) - } - m.LimitOrderBiddingId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LimitOrderBiddingId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipBid(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBid - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AuctionFeesCollectionFromLimitBidTx) 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 ErrIntOverflowBid - } - 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: AuctionFeesCollectionFromLimitBidTx: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AuctionFeesCollectionFromLimitBidTx: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) - } - m.AssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowBid - } - 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 ErrInvalidLengthBid - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthBid - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipBid(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthBid - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipBid(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowBid - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowBid - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowBid - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthBid - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupBid - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthBid - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthBid = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowBid = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupBid = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/auction/v2types/genesis.pb.go b/x/auction/v2types/genesis.pb.go deleted file mode 100644 index 5692e9aab..000000000 --- a/x/auction/v2types/genesis.pb.go +++ /dev/null @@ -1,320 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/auction/v2/genesis.proto - -package v2types - -import ( - fmt "fmt" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type GenesisState struct { - Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` -} - -func (m *GenesisState) Reset() { *m = GenesisState{} } -func (m *GenesisState) String() string { return proto.CompactTextString(m) } -func (*GenesisState) ProtoMessage() {} -func (*GenesisState) Descriptor() ([]byte, []int) { - return fileDescriptor_c2722419d1052c81, []int{0} -} -func (m *GenesisState) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenesisState.Merge(m, src) -} -func (m *GenesisState) XXX_Size() int { - return m.Size() -} -func (m *GenesisState) XXX_DiscardUnknown() { - xxx_messageInfo_GenesisState.DiscardUnknown(m) -} - -var xxx_messageInfo_GenesisState proto.InternalMessageInfo - -func (m *GenesisState) GetParams() Params { - if m != nil { - return m.Params - } - return Params{} -} - -func init() { - proto.RegisterType((*GenesisState)(nil), "comdex.auction.v2.GenesisState") -} - -func init() { proto.RegisterFile("comdex/auction/v2/genesis.proto", fileDescriptor_c2722419d1052c81) } - -var fileDescriptor_c2722419d1052c81 = []byte{ - // 199 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xce, 0xcf, 0x4d, - 0x49, 0xad, 0xd0, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd2, 0x4f, 0x4f, - 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0x28, 0xd0, - 0x83, 0x2a, 0xd0, 0x2b, 0x33, 0x92, 0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0xcb, 0xea, 0x83, 0x58, - 0x10, 0x85, 0x52, 0x72, 0x98, 0x26, 0x15, 0x24, 0x16, 0x25, 0xe6, 0x42, 0x0d, 0x52, 0x72, 0xe7, - 0xe2, 0x71, 0x87, 0x98, 0x1c, 0x5c, 0x92, 0x58, 0x92, 0x2a, 0x64, 0xce, 0xc5, 0x06, 0x91, 0x97, - 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd4, 0xc3, 0xb0, 0x49, 0x2f, 0x00, 0xac, 0xc0, 0x89, - 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0xa8, 0x72, 0x27, 0xdf, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, - 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, - 0x3c, 0x96, 0x63, 0x88, 0x32, 0x4e, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0x02, 0x19, 0xa4, 0x0f, 0x31, - 0x4c, 0x37, 0x3f, 0x2d, 0x2d, 0x33, 0x39, 0x33, 0x31, 0x07, 0xca, 0xd7, 0x47, 0x76, 0x5f, 0x49, - 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x79, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4c, - 0x95, 0x4a, 0x07, 0x0a, 0x01, 0x00, 0x00, -} - -func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GenesisState) 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 = encodeVarintGenesis(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - -func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { - offset -= sovGenesis(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *GenesisState) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.Params.Size() - n += 1 + l + sovGenesis(uint64(l)) - return n -} - -func sovGenesis(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozGenesis(x uint64) (n int) { - return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *GenesisState) 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 ErrIntOverflowGenesis - } - 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: GenesisState: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenesis - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenesis - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenesis - } - 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 := skipGenesis(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGenesis - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipGenesis(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenesis - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenesis - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenesis - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthGenesis - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupGenesis - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthGenesis - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/auction/v2types/gov.pb.go b/x/auction/v2types/gov.pb.go deleted file mode 100644 index 6c2bea019..000000000 --- a/x/auction/v2types/gov.pb.go +++ /dev/null @@ -1,427 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/auction/v2/gov.proto - -package v2types - -import ( - fmt "fmt" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type DutchAutoBidParamsProposal struct { - Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty" yaml:"title"` - Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"` - AuctionParams AuctionParams `protobuf:"bytes,3,opt,name=auctionParams,proto3" json:"auctionParams"` -} - -func (m *DutchAutoBidParamsProposal) Reset() { *m = DutchAutoBidParamsProposal{} } -func (m *DutchAutoBidParamsProposal) String() string { return proto.CompactTextString(m) } -func (*DutchAutoBidParamsProposal) ProtoMessage() {} -func (*DutchAutoBidParamsProposal) Descriptor() ([]byte, []int) { - return fileDescriptor_c6a564b40d36e1e6, []int{0} -} -func (m *DutchAutoBidParamsProposal) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DutchAutoBidParamsProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DutchAutoBidParamsProposal.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 *DutchAutoBidParamsProposal) XXX_Merge(src proto.Message) { - xxx_messageInfo_DutchAutoBidParamsProposal.Merge(m, src) -} -func (m *DutchAutoBidParamsProposal) XXX_Size() int { - return m.Size() -} -func (m *DutchAutoBidParamsProposal) XXX_DiscardUnknown() { - xxx_messageInfo_DutchAutoBidParamsProposal.DiscardUnknown(m) -} - -var xxx_messageInfo_DutchAutoBidParamsProposal proto.InternalMessageInfo - -func (m *DutchAutoBidParamsProposal) GetTitle() string { - if m != nil { - return m.Title - } - return "" -} - -func (m *DutchAutoBidParamsProposal) GetDescription() string { - if m != nil { - return m.Description - } - return "" -} - -func (m *DutchAutoBidParamsProposal) GetAuctionParams() AuctionParams { - if m != nil { - return m.AuctionParams - } - return AuctionParams{} -} - -func init() { - proto.RegisterType((*DutchAutoBidParamsProposal)(nil), "comdex.auction.v2.DutchAutoBidParamsProposal") -} - -func init() { proto.RegisterFile("comdex/auction/v2/gov.proto", fileDescriptor_c6a564b40d36e1e6) } - -var fileDescriptor_c6a564b40d36e1e6 = []byte{ - // 277 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0xce, 0xcf, 0x4d, - 0x49, 0xad, 0xd0, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd2, 0x4f, 0xcf, - 0x2f, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0x48, 0xea, 0x41, 0x25, 0xf5, 0xca, - 0x8c, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xb2, 0xfa, 0x20, 0x16, 0x44, 0xa1, 0x14, 0x16, - 0x53, 0x92, 0x32, 0x53, 0x20, 0x92, 0x4a, 0x67, 0x18, 0xb9, 0xa4, 0x5c, 0x4a, 0x4b, 0x92, 0x33, - 0x1c, 0x4b, 0x4b, 0xf2, 0x9d, 0x32, 0x53, 0x02, 0x12, 0x8b, 0x12, 0x73, 0x8b, 0x03, 0x8a, 0xf2, - 0x0b, 0xf2, 0x8b, 0x13, 0x73, 0x84, 0xd4, 0xb8, 0x58, 0x4b, 0x32, 0x4b, 0x72, 0x52, 0x25, 0x18, - 0x15, 0x18, 0x35, 0x38, 0x9d, 0x04, 0x3e, 0xdd, 0x93, 0xe7, 0xa9, 0x4c, 0xcc, 0xcd, 0xb1, 0x52, - 0x02, 0x0b, 0x2b, 0x05, 0x41, 0xa4, 0x85, 0x2c, 0xb8, 0xb8, 0x53, 0x52, 0x8b, 0x93, 0x8b, 0x32, - 0x0b, 0x40, 0x56, 0x48, 0x30, 0x81, 0x55, 0x8b, 0x7d, 0xba, 0x27, 0x2f, 0x04, 0x51, 0x8d, 0x24, - 0xa9, 0x14, 0x84, 0xac, 0x54, 0xc8, 0x87, 0x8b, 0x17, 0xea, 0x30, 0x88, 0xd5, 0x12, 0xcc, 0x0a, - 0x8c, 0x1a, 0xdc, 0x46, 0x0a, 0x7a, 0x18, 0xde, 0xd3, 0x73, 0x44, 0x56, 0xe7, 0xc4, 0x72, 0xe2, - 0x9e, 0x3c, 0x43, 0x10, 0xaa, 0x66, 0x27, 0xdf, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, - 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, - 0x63, 0x88, 0x32, 0x4e, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0x02, 0x19, 0xab, 0x0f, 0x31, 0x5a, 0x37, - 0x3f, 0x2d, 0x2d, 0x33, 0x39, 0x33, 0x31, 0x07, 0xca, 0xd7, 0x47, 0x0e, 0xa2, 0x92, 0xca, 0x82, - 0xd4, 0xe2, 0x24, 0x36, 0x70, 0x20, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xdd, 0x3b, 0x16, - 0xd9, 0x89, 0x01, 0x00, 0x00, -} - -func (m *DutchAutoBidParamsProposal) 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 *DutchAutoBidParamsProposal) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DutchAutoBidParamsProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.AuctionParams.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGov(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if len(m.Description) > 0 { - i -= len(m.Description) - copy(dAtA[i:], m.Description) - i = encodeVarintGov(dAtA, i, uint64(len(m.Description))) - i-- - dAtA[i] = 0x12 - } - if len(m.Title) > 0 { - i -= len(m.Title) - copy(dAtA[i:], m.Title) - i = encodeVarintGov(dAtA, i, uint64(len(m.Title))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func encodeVarintGov(dAtA []byte, offset int, v uint64) int { - offset -= sovGov(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *DutchAutoBidParamsProposal) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Title) - if l > 0 { - n += 1 + l + sovGov(uint64(l)) - } - l = len(m.Description) - if l > 0 { - n += 1 + l + sovGov(uint64(l)) - } - l = m.AuctionParams.Size() - n += 1 + l + sovGov(uint64(l)) - return n -} - -func sovGov(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozGov(x uint64) (n int) { - return sovGov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *DutchAutoBidParamsProposal) 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 ErrIntOverflowGov - } - 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: DutchAutoBidParamsProposal: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DutchAutoBidParamsProposal: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGov - } - 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 ErrInvalidLengthGov - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGov - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Title = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGov - } - 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 ErrInvalidLengthGov - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGov - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Description = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionParams", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGov - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGov - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGov - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.AuctionParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGov(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGov - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipGov(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGov - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGov - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGov - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthGov - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupGov - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthGov - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthGov = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowGov = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupGov = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/auction/v2types/params.pb.go b/x/auction/v2types/params.pb.go deleted file mode 100644 index 645788a51..000000000 --- a/x/auction/v2types/params.pb.go +++ /dev/null @@ -1,263 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/auction/v2/params.proto - -package v2types - -import ( - fmt "fmt" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type Params struct { -} - -func (m *Params) Reset() { *m = Params{} } -func (*Params) ProtoMessage() {} -func (*Params) Descriptor() ([]byte, []int) { - return fileDescriptor_3762e770d0a19ed4, []int{0} -} -func (m *Params) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { - xxx_messageInfo_Params.Merge(m, src) -} -func (m *Params) XXX_Size() int { - return m.Size() -} -func (m *Params) XXX_DiscardUnknown() { - xxx_messageInfo_Params.DiscardUnknown(m) -} - -var xxx_messageInfo_Params proto.InternalMessageInfo - -func init() { - proto.RegisterType((*Params)(nil), "comdex.auction.v2.Params") -} - -func init() { proto.RegisterFile("comdex/auction/v2/params.proto", fileDescriptor_3762e770d0a19ed4) } - -var fileDescriptor_3762e770d0a19ed4 = []byte{ - // 159 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xce, 0xcf, 0x4d, - 0x49, 0xad, 0xd0, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd2, 0x2f, 0x48, - 0x2c, 0x4a, 0xcc, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0xc8, 0xeb, 0x41, - 0xe5, 0xf5, 0xca, 0x8c, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xb2, 0xfa, 0x20, 0x16, 0x44, - 0xa1, 0x12, 0x1f, 0x17, 0x5b, 0x00, 0x58, 0xa3, 0x15, 0xcb, 0x8c, 0x05, 0xf2, 0x0c, 0x4e, 0xbe, - 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, - 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0x65, 0x9c, 0x9e, 0x59, 0x92, 0x51, - 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x0f, 0x31, 0x5d, 0x37, 0x3f, 0x2d, 0x2d, 0x33, 0x39, 0x33, - 0x31, 0x07, 0xca, 0xd7, 0x47, 0x76, 0x4f, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x16, - 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe2, 0x93, 0x78, 0x84, 0xb0, 0x00, 0x00, 0x00, -} - -func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func encodeVarintParams(dAtA []byte, offset int, v uint64) int { - offset -= sovParams(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *Params) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func sovParams(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozParams(x uint64) (n int) { - return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *Params) 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 ErrIntOverflowParams - } - 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: Params: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipParams(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthParams - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipParams(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowParams - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowParams - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowParams - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthParams - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupParams - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthParams - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthParams = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowParams = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/auction/v2types/query.pb.go b/x/auction/v2types/query.pb.go deleted file mode 100644 index 94fe43549..000000000 --- a/x/auction/v2types/query.pb.go +++ /dev/null @@ -1,530 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/auction/v2/query.proto - -package v2types - -import ( - context "context" - fmt "fmt" - _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" - _ "google.golang.org/genproto/googleapis/api/annotations" - grpc "google.golang.org/grpc" - codes "google.golang.org/grpc/codes" - status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type QueryParamsRequest struct { -} - -func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } -func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } -func (*QueryParamsRequest) ProtoMessage() {} -func (*QueryParamsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_1b7e08455d3f955e, []int{0} -} -func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_QueryParamsRequest.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 *QueryParamsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryParamsRequest.Merge(m, src) -} -func (m *QueryParamsRequest) XXX_Size() int { - return m.Size() -} -func (m *QueryParamsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo - -type QueryParamsResponse struct { - Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` -} - -func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } -func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } -func (*QueryParamsResponse) ProtoMessage() {} -func (*QueryParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_1b7e08455d3f955e, []int{1} -} -func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_QueryParamsResponse.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 *QueryParamsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryParamsResponse.Merge(m, src) -} -func (m *QueryParamsResponse) XXX_Size() int { - return m.Size() -} -func (m *QueryParamsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo - -func (m *QueryParamsResponse) GetParams() Params { - if m != nil { - return m.Params - } - return Params{} -} - -func init() { - proto.RegisterType((*QueryParamsRequest)(nil), "comdex.auction.v2.QueryParamsRequest") - proto.RegisterType((*QueryParamsResponse)(nil), "comdex.auction.v2.QueryParamsResponse") -} - -func init() { proto.RegisterFile("comdex/auction/v2/query.proto", fileDescriptor_1b7e08455d3f955e) } - -var fileDescriptor_1b7e08455d3f955e = []byte{ - // 284 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4d, 0xce, 0xcf, 0x4d, - 0x49, 0xad, 0xd0, 0x4f, 0x2c, 0x4d, 0x2e, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, 0x33, 0xd2, 0x2f, 0x2c, - 0x4d, 0x2d, 0xaa, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0x48, 0xeb, 0x41, 0xa5, - 0xf5, 0xca, 0x8c, 0xa4, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0xb2, 0xfa, 0x20, 0x16, 0x44, 0xa1, - 0x94, 0x4c, 0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x7e, 0x62, 0x41, 0xa6, 0x7e, 0x62, 0x5e, 0x5e, - 0x7e, 0x49, 0x22, 0x48, 0x7d, 0x31, 0x54, 0x56, 0x0e, 0xd3, 0x96, 0x82, 0xc4, 0xa2, 0xc4, 0x5c, - 0xa8, 0xbc, 0x92, 0x08, 0x97, 0x50, 0x20, 0xc8, 0xd6, 0x00, 0xb0, 0x60, 0x50, 0x6a, 0x61, 0x69, - 0x6a, 0x71, 0x89, 0x92, 0x1f, 0x97, 0x30, 0x8a, 0x68, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0x90, - 0x39, 0x17, 0x1b, 0x44, 0xb3, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb7, 0x91, 0xa4, 0x1e, 0x86, 0x23, - 0xf5, 0x20, 0x5a, 0x9c, 0x58, 0x4e, 0xdc, 0x93, 0x67, 0x08, 0x82, 0x2a, 0x37, 0x9a, 0xc0, 0xc8, - 0xc5, 0x0a, 0x36, 0x50, 0xa8, 0x8d, 0x91, 0x8b, 0x0d, 0xa2, 0x44, 0x48, 0x15, 0x8b, 0x6e, 0x4c, - 0xb7, 0x48, 0xa9, 0x11, 0x52, 0x06, 0x71, 0x9c, 0x92, 0x6e, 0xd3, 0xe5, 0x27, 0x93, 0x99, 0xd4, - 0x85, 0x54, 0xf5, 0x21, 0xea, 0x75, 0xf3, 0xd3, 0xd2, 0x32, 0x93, 0x33, 0x13, 0x73, 0xa0, 0x7c, - 0xfd, 0xbc, 0xd4, 0xf2, 0xc4, 0xd2, 0x64, 0xa8, 0xf7, 0x9d, 0x7c, 0x4f, 0x3c, 0x92, 0x63, 0xbc, - 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, - 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0xca, 0x38, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x09, 0x64, 0x2d, 0x2e, - 0xa3, 0x90, 0xc3, 0xb3, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c, 0x9c, 0xc6, 0x80, 0x00, - 0x00, 0x00, 0xff, 0xff, 0x56, 0x18, 0x7e, 0x53, 0xd6, 0x01, 0x00, 0x00, -} - -// 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 - -// QueryClient is the client API for Query service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type QueryClient interface { - Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) -} - -type queryClient struct { - cc grpc1.ClientConn -} - -func NewQueryClient(cc grpc1.ClientConn) QueryClient { - return &queryClient{cc} -} - -func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { - out := new(QueryParamsResponse) - err := c.cc.Invoke(ctx, "/comdex.auction.v2.Query/Params", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// QueryServer is the server API for Query service. -type QueryServer interface { - Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) -} - -// UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} - -func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") -} - -func RegisterQueryServer(s grpc1.Server, srv QueryServer) { - s.RegisterService(&_Query_serviceDesc, srv) -} - -func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(QueryParamsRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(QueryServer).Params(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.auction.v2.Query/Params", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) - } - return interceptor(ctx, in, info, handler) -} - -var _Query_serviceDesc = grpc.ServiceDesc{ - ServiceName: "comdex.auction.v2.Query", - HandlerType: (*QueryServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "Params", - Handler: _Query_Params_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "comdex/auction/v2/query.proto", -} - -func (m *QueryParamsRequest) 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 *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *QueryParamsResponse) 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 *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *QueryParamsResponse) 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 = encodeVarintQuery(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - -func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { - offset -= sovQuery(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *QueryParamsRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *QueryParamsResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.Params.Size() - n += 1 + l + sovQuery(uint64(l)) - return n -} - -func sovQuery(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozQuery(x uint64) (n int) { - return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQuery - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipQuery(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthQuery - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQuery - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQuery - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthQuery - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthQuery - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipQuery(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthQuery - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipQuery(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQuery - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQuery - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQuery - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthQuery - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupQuery - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthQuery - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/auction/v2types/query.pb.gw.go b/x/auction/v2types/query.pb.gw.go deleted file mode 100644 index a0b4282e0..000000000 --- a/x/auction/v2types/query.pb.gw.go +++ /dev/null @@ -1,153 +0,0 @@ -// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. -// source: comdex/auction/v2/query.proto - -/* -Package v2types is a reverse proxy. - -It translates gRPC into RESTful JSON APIs. -*/ -package v2types - -import ( - "context" - "io" - "net/http" - - "github.com/golang/protobuf/descriptor" - "github.com/golang/protobuf/proto" - "github.com/grpc-ecosystem/grpc-gateway/runtime" - "github.com/grpc-ecosystem/grpc-gateway/utilities" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/grpclog" - "google.golang.org/grpc/metadata" - "google.golang.org/grpc/status" -) - -// Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = descriptor.ForMessage -var _ = metadata.Join - -func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryParamsRequest - var metadata runtime.ServerMetadata - - msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryParamsRequest - var metadata runtime.ServerMetadata - - msg, err := server.Params(ctx, &protoReq) - return msg, metadata, err - -} - -// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". -// UnaryRPC :call QueryServer directly. -// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. -// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. -func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { - - mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - return nil -} - -// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but -// automatically dials to "endpoint" and closes the connection when "ctx" gets done. -func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { - conn, err := grpc.Dial(endpoint, opts...) - if err != nil { - return err - } - defer func() { - if err != nil { - if cerr := conn.Close(); cerr != nil { - grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) - } - return - } - go func() { - <-ctx.Done() - if cerr := conn.Close(); cerr != nil { - grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) - } - }() - }() - - return RegisterQueryHandler(ctx, mux, conn) -} - -// RegisterQueryHandler registers the http handlers for service Query to "mux". -// The handlers forward requests to the grpc endpoint over "conn". -func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { - return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) -} - -// RegisterQueryHandlerClient registers the http handlers for service Query -// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". -// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" -// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "QueryClient" to call the correct interceptors. -func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { - - mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateContext(ctx, mux, req) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - return nil -} - -var ( - pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"comdex-official", "comdex", "newauc", "params"}, "", runtime.AssumeColonVerbOpt(false))) -) - -var ( - forward_Query_Params_0 = runtime.ForwardResponseMessage -) diff --git a/x/auction/v2types/tx.pb.go b/x/auction/v2types/tx.pb.go deleted file mode 100644 index 18335081a..000000000 --- a/x/auction/v2types/tx.pb.go +++ /dev/null @@ -1,1968 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/auction/v2/tx.proto - -package v2types - -import ( - context "context" - fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" - grpc "google.golang.org/grpc" - codes "google.golang.org/grpc/codes" - status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type MsgPlaceMarketBidRequest struct { - AuctionId uint64 `protobuf:"varint,1,opt,name=auction_id,json=auctionId,proto3" json:"auction_id,omitempty"` - Bidder string `protobuf:"bytes,2,opt,name=bidder,proto3" json:"bidder,omitempty"` - Amount types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"` -} - -func (m *MsgPlaceMarketBidRequest) Reset() { *m = MsgPlaceMarketBidRequest{} } -func (m *MsgPlaceMarketBidRequest) String() string { return proto.CompactTextString(m) } -func (*MsgPlaceMarketBidRequest) ProtoMessage() {} -func (*MsgPlaceMarketBidRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_f9a3512929bb96f1, []int{0} -} -func (m *MsgPlaceMarketBidRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgPlaceMarketBidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgPlaceMarketBidRequest.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 *MsgPlaceMarketBidRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgPlaceMarketBidRequest.Merge(m, src) -} -func (m *MsgPlaceMarketBidRequest) XXX_Size() int { - return m.Size() -} -func (m *MsgPlaceMarketBidRequest) XXX_DiscardUnknown() { - xxx_messageInfo_MsgPlaceMarketBidRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgPlaceMarketBidRequest proto.InternalMessageInfo - -type MsgPlaceMarketBidResponse struct { -} - -func (m *MsgPlaceMarketBidResponse) Reset() { *m = MsgPlaceMarketBidResponse{} } -func (m *MsgPlaceMarketBidResponse) String() string { return proto.CompactTextString(m) } -func (*MsgPlaceMarketBidResponse) ProtoMessage() {} -func (*MsgPlaceMarketBidResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_f9a3512929bb96f1, []int{1} -} -func (m *MsgPlaceMarketBidResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgPlaceMarketBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgPlaceMarketBidResponse.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 *MsgPlaceMarketBidResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgPlaceMarketBidResponse.Merge(m, src) -} -func (m *MsgPlaceMarketBidResponse) XXX_Size() int { - return m.Size() -} -func (m *MsgPlaceMarketBidResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgPlaceMarketBidResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgPlaceMarketBidResponse proto.InternalMessageInfo - -type MsgDepositLimitBidRequest struct { - CollateralTokenId uint64 `protobuf:"varint,1,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty"` - DebtTokenId uint64 `protobuf:"varint,2,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty"` - PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` - Bidder string `protobuf:"bytes,4,opt,name=bidder,proto3" json:"bidder,omitempty"` - Amount types.Coin `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount"` -} - -func (m *MsgDepositLimitBidRequest) Reset() { *m = MsgDepositLimitBidRequest{} } -func (m *MsgDepositLimitBidRequest) String() string { return proto.CompactTextString(m) } -func (*MsgDepositLimitBidRequest) ProtoMessage() {} -func (*MsgDepositLimitBidRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_f9a3512929bb96f1, []int{2} -} -func (m *MsgDepositLimitBidRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgDepositLimitBidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgDepositLimitBidRequest.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 *MsgDepositLimitBidRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDepositLimitBidRequest.Merge(m, src) -} -func (m *MsgDepositLimitBidRequest) XXX_Size() int { - return m.Size() -} -func (m *MsgDepositLimitBidRequest) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDepositLimitBidRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgDepositLimitBidRequest proto.InternalMessageInfo - -type MsgDepositLimitBidResponse struct { -} - -func (m *MsgDepositLimitBidResponse) Reset() { *m = MsgDepositLimitBidResponse{} } -func (m *MsgDepositLimitBidResponse) String() string { return proto.CompactTextString(m) } -func (*MsgDepositLimitBidResponse) ProtoMessage() {} -func (*MsgDepositLimitBidResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_f9a3512929bb96f1, []int{3} -} -func (m *MsgDepositLimitBidResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgDepositLimitBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgDepositLimitBidResponse.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 *MsgDepositLimitBidResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgDepositLimitBidResponse.Merge(m, src) -} -func (m *MsgDepositLimitBidResponse) XXX_Size() int { - return m.Size() -} -func (m *MsgDepositLimitBidResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgDepositLimitBidResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgDepositLimitBidResponse proto.InternalMessageInfo - -type MsgCancelLimitBidRequest struct { - CollateralTokenId uint64 `protobuf:"varint,1,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty"` - DebtTokenId uint64 `protobuf:"varint,2,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty"` - PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` - Bidder string `protobuf:"bytes,4,opt,name=bidder,proto3" json:"bidder,omitempty"` -} - -func (m *MsgCancelLimitBidRequest) Reset() { *m = MsgCancelLimitBidRequest{} } -func (m *MsgCancelLimitBidRequest) String() string { return proto.CompactTextString(m) } -func (*MsgCancelLimitBidRequest) ProtoMessage() {} -func (*MsgCancelLimitBidRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_f9a3512929bb96f1, []int{4} -} -func (m *MsgCancelLimitBidRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgCancelLimitBidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgCancelLimitBidRequest.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 *MsgCancelLimitBidRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgCancelLimitBidRequest.Merge(m, src) -} -func (m *MsgCancelLimitBidRequest) XXX_Size() int { - return m.Size() -} -func (m *MsgCancelLimitBidRequest) XXX_DiscardUnknown() { - xxx_messageInfo_MsgCancelLimitBidRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgCancelLimitBidRequest proto.InternalMessageInfo - -type MsgCancelLimitBidResponse struct { -} - -func (m *MsgCancelLimitBidResponse) Reset() { *m = MsgCancelLimitBidResponse{} } -func (m *MsgCancelLimitBidResponse) String() string { return proto.CompactTextString(m) } -func (*MsgCancelLimitBidResponse) ProtoMessage() {} -func (*MsgCancelLimitBidResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_f9a3512929bb96f1, []int{5} -} -func (m *MsgCancelLimitBidResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgCancelLimitBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgCancelLimitBidResponse.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 *MsgCancelLimitBidResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgCancelLimitBidResponse.Merge(m, src) -} -func (m *MsgCancelLimitBidResponse) XXX_Size() int { - return m.Size() -} -func (m *MsgCancelLimitBidResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgCancelLimitBidResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgCancelLimitBidResponse proto.InternalMessageInfo - -type MsgWithdrawLimitBidRequest struct { - CollateralTokenId uint64 `protobuf:"varint,1,opt,name=collateral_token_id,json=collateralTokenId,proto3" json:"collateral_token_id,omitempty"` - DebtTokenId uint64 `protobuf:"varint,2,opt,name=debt_token_id,json=debtTokenId,proto3" json:"debt_token_id,omitempty"` - PremiumDiscount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=premium_discount,json=premiumDiscount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"premium_discount" yaml:"premium_discount"` - Bidder string `protobuf:"bytes,4,opt,name=bidder,proto3" json:"bidder,omitempty"` - Amount types.Coin `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount"` -} - -func (m *MsgWithdrawLimitBidRequest) Reset() { *m = MsgWithdrawLimitBidRequest{} } -func (m *MsgWithdrawLimitBidRequest) String() string { return proto.CompactTextString(m) } -func (*MsgWithdrawLimitBidRequest) ProtoMessage() {} -func (*MsgWithdrawLimitBidRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_f9a3512929bb96f1, []int{6} -} -func (m *MsgWithdrawLimitBidRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgWithdrawLimitBidRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgWithdrawLimitBidRequest.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 *MsgWithdrawLimitBidRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgWithdrawLimitBidRequest.Merge(m, src) -} -func (m *MsgWithdrawLimitBidRequest) XXX_Size() int { - return m.Size() -} -func (m *MsgWithdrawLimitBidRequest) XXX_DiscardUnknown() { - xxx_messageInfo_MsgWithdrawLimitBidRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgWithdrawLimitBidRequest proto.InternalMessageInfo - -type MsgWithdrawLimitBidResponse struct { -} - -func (m *MsgWithdrawLimitBidResponse) Reset() { *m = MsgWithdrawLimitBidResponse{} } -func (m *MsgWithdrawLimitBidResponse) String() string { return proto.CompactTextString(m) } -func (*MsgWithdrawLimitBidResponse) ProtoMessage() {} -func (*MsgWithdrawLimitBidResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_f9a3512929bb96f1, []int{7} -} -func (m *MsgWithdrawLimitBidResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgWithdrawLimitBidResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgWithdrawLimitBidResponse.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 *MsgWithdrawLimitBidResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgWithdrawLimitBidResponse.Merge(m, src) -} -func (m *MsgWithdrawLimitBidResponse) XXX_Size() int { - return m.Size() -} -func (m *MsgWithdrawLimitBidResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgWithdrawLimitBidResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgWithdrawLimitBidResponse proto.InternalMessageInfo - -func init() { - proto.RegisterType((*MsgPlaceMarketBidRequest)(nil), "comdex.auction.v2.MsgPlaceMarketBidRequest") - proto.RegisterType((*MsgPlaceMarketBidResponse)(nil), "comdex.auction.v2.MsgPlaceMarketBidResponse") - proto.RegisterType((*MsgDepositLimitBidRequest)(nil), "comdex.auction.v2.MsgDepositLimitBidRequest") - proto.RegisterType((*MsgDepositLimitBidResponse)(nil), "comdex.auction.v2.MsgDepositLimitBidResponse") - proto.RegisterType((*MsgCancelLimitBidRequest)(nil), "comdex.auction.v2.MsgCancelLimitBidRequest") - proto.RegisterType((*MsgCancelLimitBidResponse)(nil), "comdex.auction.v2.MsgCancelLimitBidResponse") - proto.RegisterType((*MsgWithdrawLimitBidRequest)(nil), "comdex.auction.v2.MsgWithdrawLimitBidRequest") - proto.RegisterType((*MsgWithdrawLimitBidResponse)(nil), "comdex.auction.v2.MsgWithdrawLimitBidResponse") -} - -func init() { proto.RegisterFile("comdex/auction/v2/tx.proto", fileDescriptor_f9a3512929bb96f1) } - -var fileDescriptor_f9a3512929bb96f1 = []byte{ - // 558 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x55, 0xc1, 0x6e, 0xd3, 0x30, - 0x18, 0x4e, 0xba, 0x52, 0xa9, 0x9e, 0x10, 0xd4, 0x43, 0xd0, 0x65, 0x2c, 0xad, 0x72, 0x40, 0x95, - 0xa0, 0x8e, 0xd6, 0x1d, 0x90, 0x38, 0x76, 0xbb, 0x54, 0xa2, 0x12, 0xaa, 0x40, 0x48, 0x5c, 0x2a, - 0x27, 0xf6, 0x3a, 0xab, 0x49, 0xdc, 0xc5, 0x4e, 0xd9, 0x5e, 0x81, 0x13, 0x8f, 0xc1, 0x13, 0xc0, - 0x2b, 0xf4, 0x84, 0x76, 0x44, 0x1c, 0x2a, 0x68, 0xdf, 0x80, 0x33, 0x07, 0x94, 0xd8, 0xb0, 0x6e, - 0x4d, 0xa4, 0x72, 0x86, 0x53, 0xe2, 0xff, 0xfb, 0xe4, 0xff, 0xfb, 0x3f, 0x7d, 0xb6, 0x81, 0xe5, - 0xf3, 0x90, 0xd0, 0x73, 0x17, 0x27, 0xbe, 0x64, 0x3c, 0x72, 0xa7, 0x1d, 0x57, 0x9e, 0xa3, 0x49, - 0xcc, 0x25, 0x87, 0x35, 0x85, 0x21, 0x8d, 0xa1, 0x69, 0xc7, 0xba, 0x37, 0xe2, 0x23, 0x9e, 0xa1, - 0x6e, 0xfa, 0xa7, 0x88, 0x96, 0xed, 0x73, 0x11, 0x72, 0xe1, 0x7a, 0x58, 0x50, 0x77, 0x7a, 0xe0, - 0x51, 0x89, 0x0f, 0x5c, 0x9f, 0xb3, 0x48, 0xe1, 0xce, 0x3b, 0x13, 0xd4, 0xfb, 0x62, 0xf4, 0x22, - 0xc0, 0x3e, 0xed, 0xe3, 0x78, 0x4c, 0x65, 0x97, 0x91, 0x01, 0x3d, 0x4b, 0xa8, 0x90, 0x70, 0x1f, - 0x00, 0xdd, 0x60, 0xc8, 0x48, 0xdd, 0x6c, 0x9a, 0xad, 0xf2, 0xa0, 0xaa, 0x2b, 0x3d, 0x02, 0xef, - 0x83, 0x8a, 0xc7, 0x08, 0xa1, 0x71, 0xbd, 0xd4, 0x34, 0x5b, 0xd5, 0x81, 0x5e, 0xc1, 0xa7, 0xa0, - 0x82, 0x43, 0x9e, 0x44, 0xb2, 0xbe, 0xd5, 0x34, 0x5b, 0xdb, 0x9d, 0x5d, 0xa4, 0x44, 0xa0, 0x54, - 0x04, 0xd2, 0x22, 0xd0, 0x11, 0x67, 0x51, 0xb7, 0x3c, 0x9b, 0x37, 0x8c, 0x81, 0xa6, 0x3b, 0x7b, - 0x60, 0x37, 0x47, 0x8b, 0x98, 0xf0, 0x48, 0x50, 0xe7, 0x63, 0x29, 0x43, 0x8f, 0xe9, 0x84, 0x0b, - 0x26, 0x9f, 0xb3, 0x90, 0xad, 0x4a, 0x45, 0x60, 0xc7, 0xe7, 0x41, 0x80, 0x25, 0x8d, 0x71, 0x30, - 0x94, 0x7c, 0x4c, 0x57, 0x34, 0xd7, 0xae, 0xa0, 0x97, 0x29, 0xd2, 0x23, 0xd0, 0x01, 0xb7, 0x09, - 0xf5, 0xe4, 0x15, 0xb3, 0x94, 0x31, 0xb7, 0xd3, 0xe2, 0x6f, 0x8e, 0x04, 0x77, 0x27, 0x31, 0x0d, - 0x59, 0x12, 0x0e, 0x09, 0x13, 0xfe, 0x9f, 0x89, 0xaa, 0xdd, 0x5e, 0x2a, 0xfb, 0xeb, 0xbc, 0xf1, - 0x68, 0xc4, 0xe4, 0x69, 0xe2, 0x21, 0x9f, 0x87, 0xae, 0x36, 0x5a, 0x7d, 0xda, 0x82, 0x8c, 0x5d, - 0x79, 0x31, 0xa1, 0x02, 0xf5, 0x22, 0xf9, 0x63, 0xde, 0x78, 0x70, 0x81, 0xc3, 0xe0, 0x99, 0x73, - 0x73, 0x3f, 0x67, 0x70, 0x47, 0x97, 0x8e, 0x75, 0x65, 0xc5, 0xd5, 0x72, 0x81, 0xab, 0xb7, 0xfe, - 0xce, 0xd5, 0x87, 0xc0, 0xca, 0xf3, 0x4d, 0xdb, 0xfa, 0x53, 0x05, 0xe0, 0x08, 0x47, 0x3e, 0x0d, - 0xfe, 0x39, 0x57, 0x75, 0xe4, 0x6e, 0x4e, 0xaf, 0xbd, 0xf9, 0x54, 0xca, 0xac, 0x7b, 0xcd, 0xe4, - 0x29, 0x89, 0xf1, 0xdb, 0xff, 0x99, 0xdb, 0x38, 0x73, 0xfb, 0x60, 0x2f, 0xd7, 0x38, 0x65, 0x6c, - 0xe7, 0xf3, 0x16, 0xd8, 0xea, 0x8b, 0x11, 0x8c, 0x40, 0x6d, 0xed, 0xc0, 0xc3, 0xc7, 0x68, 0xed, - 0x72, 0x43, 0x45, 0x57, 0x94, 0xf5, 0x64, 0x33, 0xb2, 0xea, 0x0b, 0xcf, 0x00, 0x5c, 0x3f, 0x0a, - 0xb0, 0x60, 0x8f, 0xfc, 0x9b, 0xc6, 0x6a, 0x6f, 0xc8, 0xd6, 0x2d, 0xd5, 0x88, 0xd7, 0x03, 0x56, - 0x34, 0x62, 0xee, 0x21, 0x2c, 0x1a, 0x31, 0x3f, 0xb3, 0x50, 0x82, 0x9d, 0x1c, 0xe7, 0x61, 0x81, - 0xea, 0x82, 0x68, 0x5b, 0x68, 0x53, 0xba, 0xea, 0xda, 0x7d, 0x35, 0xfb, 0x6e, 0x1b, 0x1f, 0x16, - 0xb6, 0x31, 0x5b, 0xd8, 0xe6, 0xe5, 0xc2, 0x36, 0xbf, 0x2d, 0x6c, 0xf3, 0xfd, 0xd2, 0x36, 0x2e, - 0x97, 0xb6, 0xf1, 0x65, 0x69, 0x1b, 0x6f, 0x0e, 0xaf, 0xc5, 0x36, 0xdd, 0xbb, 0xcd, 0x4f, 0x4e, - 0x98, 0xcf, 0x70, 0xa0, 0xd7, 0xee, 0xea, 0x53, 0x97, 0xe5, 0xd8, 0xab, 0x64, 0x8f, 0xd4, 0xe1, - 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, 0x58, 0xf1, 0x3f, 0x0b, 0x07, 0x00, 0x00, -} - -// 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 { - MsgPlaceMarketBid(ctx context.Context, in *MsgPlaceMarketBidRequest, opts ...grpc.CallOption) (*MsgPlaceMarketBidResponse, error) - MsgDepositLimitBid(ctx context.Context, in *MsgDepositLimitBidRequest, opts ...grpc.CallOption) (*MsgDepositLimitBidResponse, error) - MsgCancelLimitBid(ctx context.Context, in *MsgCancelLimitBidRequest, opts ...grpc.CallOption) (*MsgCancelLimitBidResponse, error) - MsgWithdrawLimitBid(ctx context.Context, in *MsgWithdrawLimitBidRequest, opts ...grpc.CallOption) (*MsgWithdrawLimitBidResponse, error) -} - -type msgClient struct { - cc grpc1.ClientConn -} - -func NewMsgClient(cc grpc1.ClientConn) MsgClient { - return &msgClient{cc} -} - -func (c *msgClient) MsgPlaceMarketBid(ctx context.Context, in *MsgPlaceMarketBidRequest, opts ...grpc.CallOption) (*MsgPlaceMarketBidResponse, error) { - out := new(MsgPlaceMarketBidResponse) - err := c.cc.Invoke(ctx, "/comdex.auction.v2.Msg/MsgPlaceMarketBid", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) MsgDepositLimitBid(ctx context.Context, in *MsgDepositLimitBidRequest, opts ...grpc.CallOption) (*MsgDepositLimitBidResponse, error) { - out := new(MsgDepositLimitBidResponse) - err := c.cc.Invoke(ctx, "/comdex.auction.v2.Msg/MsgDepositLimitBid", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) MsgCancelLimitBid(ctx context.Context, in *MsgCancelLimitBidRequest, opts ...grpc.CallOption) (*MsgCancelLimitBidResponse, error) { - out := new(MsgCancelLimitBidResponse) - err := c.cc.Invoke(ctx, "/comdex.auction.v2.Msg/MsgCancelLimitBid", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) MsgWithdrawLimitBid(ctx context.Context, in *MsgWithdrawLimitBidRequest, opts ...grpc.CallOption) (*MsgWithdrawLimitBidResponse, error) { - out := new(MsgWithdrawLimitBidResponse) - err := c.cc.Invoke(ctx, "/comdex.auction.v2.Msg/MsgWithdrawLimitBid", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// MsgServer is the server API for Msg service. -type MsgServer interface { - MsgPlaceMarketBid(context.Context, *MsgPlaceMarketBidRequest) (*MsgPlaceMarketBidResponse, error) - MsgDepositLimitBid(context.Context, *MsgDepositLimitBidRequest) (*MsgDepositLimitBidResponse, error) - MsgCancelLimitBid(context.Context, *MsgCancelLimitBidRequest) (*MsgCancelLimitBidResponse, error) - MsgWithdrawLimitBid(context.Context, *MsgWithdrawLimitBidRequest) (*MsgWithdrawLimitBidResponse, error) -} - -// UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} - -func (*UnimplementedMsgServer) MsgPlaceMarketBid(ctx context.Context, req *MsgPlaceMarketBidRequest) (*MsgPlaceMarketBidResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MsgPlaceMarketBid not implemented") -} -func (*UnimplementedMsgServer) MsgDepositLimitBid(ctx context.Context, req *MsgDepositLimitBidRequest) (*MsgDepositLimitBidResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MsgDepositLimitBid not implemented") -} -func (*UnimplementedMsgServer) MsgCancelLimitBid(ctx context.Context, req *MsgCancelLimitBidRequest) (*MsgCancelLimitBidResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MsgCancelLimitBid not implemented") -} -func (*UnimplementedMsgServer) MsgWithdrawLimitBid(ctx context.Context, req *MsgWithdrawLimitBidRequest) (*MsgWithdrawLimitBidResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MsgWithdrawLimitBid not implemented") -} - -func RegisterMsgServer(s grpc1.Server, srv MsgServer) { - s.RegisterService(&_Msg_serviceDesc, srv) -} - -func _Msg_MsgPlaceMarketBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgPlaceMarketBidRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).MsgPlaceMarketBid(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.auction.v2.Msg/MsgPlaceMarketBid", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MsgPlaceMarketBid(ctx, req.(*MsgPlaceMarketBidRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_MsgDepositLimitBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgDepositLimitBidRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).MsgDepositLimitBid(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.auction.v2.Msg/MsgDepositLimitBid", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MsgDepositLimitBid(ctx, req.(*MsgDepositLimitBidRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_MsgCancelLimitBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgCancelLimitBidRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).MsgCancelLimitBid(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.auction.v2.Msg/MsgCancelLimitBid", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MsgCancelLimitBid(ctx, req.(*MsgCancelLimitBidRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_MsgWithdrawLimitBid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgWithdrawLimitBidRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).MsgWithdrawLimitBid(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.auction.v2.Msg/MsgWithdrawLimitBid", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MsgWithdrawLimitBid(ctx, req.(*MsgWithdrawLimitBidRequest)) - } - return interceptor(ctx, in, info, handler) -} - -var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "comdex.auction.v2.Msg", - HandlerType: (*MsgServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "MsgPlaceMarketBid", - Handler: _Msg_MsgPlaceMarketBid_Handler, - }, - { - MethodName: "MsgDepositLimitBid", - Handler: _Msg_MsgDepositLimitBid_Handler, - }, - { - MethodName: "MsgCancelLimitBid", - Handler: _Msg_MsgCancelLimitBid_Handler, - }, - { - MethodName: "MsgWithdrawLimitBid", - Handler: _Msg_MsgWithdrawLimitBid_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "comdex/auction/v2/tx.proto", -} - -func (m *MsgPlaceMarketBidRequest) 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 *MsgPlaceMarketBidRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgPlaceMarketBidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if len(m.Bidder) > 0 { - i -= len(m.Bidder) - copy(dAtA[i:], m.Bidder) - i = encodeVarintTx(dAtA, i, uint64(len(m.Bidder))) - i-- - dAtA[i] = 0x12 - } - if m.AuctionId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.AuctionId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *MsgPlaceMarketBidResponse) 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 *MsgPlaceMarketBidResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgPlaceMarketBidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *MsgDepositLimitBidRequest) 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 *MsgDepositLimitBidRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgDepositLimitBidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - if len(m.Bidder) > 0 { - i -= len(m.Bidder) - copy(dAtA[i:], m.Bidder) - i = encodeVarintTx(dAtA, i, uint64(len(m.Bidder))) - i-- - dAtA[i] = 0x22 - } - { - size := m.PremiumDiscount.Size() - i -= size - if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if m.DebtTokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.DebtTokenId)) - i-- - dAtA[i] = 0x10 - } - if m.CollateralTokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.CollateralTokenId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *MsgDepositLimitBidResponse) 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 *MsgDepositLimitBidResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgDepositLimitBidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *MsgCancelLimitBidRequest) 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 *MsgCancelLimitBidRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgCancelLimitBidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Bidder) > 0 { - i -= len(m.Bidder) - copy(dAtA[i:], m.Bidder) - i = encodeVarintTx(dAtA, i, uint64(len(m.Bidder))) - i-- - dAtA[i] = 0x22 - } - { - size := m.PremiumDiscount.Size() - i -= size - if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if m.DebtTokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.DebtTokenId)) - i-- - dAtA[i] = 0x10 - } - if m.CollateralTokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.CollateralTokenId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *MsgCancelLimitBidResponse) 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 *MsgCancelLimitBidResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgCancelLimitBidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *MsgWithdrawLimitBidRequest) 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 *MsgWithdrawLimitBidRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgWithdrawLimitBidRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - if len(m.Bidder) > 0 { - i -= len(m.Bidder) - copy(dAtA[i:], m.Bidder) - i = encodeVarintTx(dAtA, i, uint64(len(m.Bidder))) - i-- - dAtA[i] = 0x22 - } - { - size := m.PremiumDiscount.Size() - i -= size - if _, err := m.PremiumDiscount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if m.DebtTokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.DebtTokenId)) - i-- - dAtA[i] = 0x10 - } - if m.CollateralTokenId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.CollateralTokenId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *MsgWithdrawLimitBidResponse) 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 *MsgWithdrawLimitBidResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgWithdrawLimitBidResponse) 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 *MsgPlaceMarketBidRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AuctionId != 0 { - n += 1 + sovTx(uint64(m.AuctionId)) - } - l = len(m.Bidder) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n -} - -func (m *MsgPlaceMarketBidResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *MsgDepositLimitBidRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.CollateralTokenId != 0 { - n += 1 + sovTx(uint64(m.CollateralTokenId)) - } - if m.DebtTokenId != 0 { - n += 1 + sovTx(uint64(m.DebtTokenId)) - } - l = m.PremiumDiscount.Size() - n += 1 + l + sovTx(uint64(l)) - l = len(m.Bidder) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n -} - -func (m *MsgDepositLimitBidResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *MsgCancelLimitBidRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.CollateralTokenId != 0 { - n += 1 + sovTx(uint64(m.CollateralTokenId)) - } - if m.DebtTokenId != 0 { - n += 1 + sovTx(uint64(m.DebtTokenId)) - } - l = m.PremiumDiscount.Size() - n += 1 + l + sovTx(uint64(l)) - l = len(m.Bidder) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n -} - -func (m *MsgCancelLimitBidResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *MsgWithdrawLimitBidRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.CollateralTokenId != 0 { - n += 1 + sovTx(uint64(m.CollateralTokenId)) - } - if m.DebtTokenId != 0 { - n += 1 + sovTx(uint64(m.DebtTokenId)) - } - l = m.PremiumDiscount.Size() - n += 1 + l + sovTx(uint64(l)) - l = len(m.Bidder) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = m.Amount.Size() - n += 1 + l + sovTx(uint64(l)) - return n -} - -func (m *MsgWithdrawLimitBidResponse) 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 *MsgPlaceMarketBidRequest) 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: MsgPlaceMarketBidRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgPlaceMarketBidRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionId", wireType) - } - m.AuctionId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AuctionId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bidder", 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.Bidder = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 err := m.Amount.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 *MsgPlaceMarketBidResponse) 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: MsgPlaceMarketBidResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgPlaceMarketBidResponse: 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 *MsgDepositLimitBidRequest) 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: MsgDepositLimitBidRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDepositLimitBidRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) - } - m.CollateralTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CollateralTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) - } - m.DebtTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebtTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", 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.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bidder", 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.Bidder = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 err := m.Amount.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 *MsgDepositLimitBidResponse) 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: MsgDepositLimitBidResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgDepositLimitBidResponse: 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 *MsgCancelLimitBidRequest) 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: MsgCancelLimitBidRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelLimitBidRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) - } - m.CollateralTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CollateralTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) - } - m.DebtTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebtTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", 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.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bidder", 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.Bidder = 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 *MsgCancelLimitBidResponse) 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: MsgCancelLimitBidResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCancelLimitBidResponse: 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 *MsgWithdrawLimitBidRequest) 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: MsgWithdrawLimitBidRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgWithdrawLimitBidRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralTokenId", wireType) - } - m.CollateralTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CollateralTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtTokenId", wireType) - } - m.DebtTokenId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebtTokenId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PremiumDiscount", 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.PremiumDiscount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Bidder", 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.Bidder = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Amount", 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 err := m.Amount.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 *MsgWithdrawLimitBidResponse) 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: MsgWithdrawLimitBidResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgWithdrawLimitBidResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTx - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipTx(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTx - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTx - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTx - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthTx - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupTx - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthTx - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/liquidation/v2types/genesis.pb.go b/x/liquidation/v2types/genesis.pb.go deleted file mode 100644 index 91ea2e080..000000000 --- a/x/liquidation/v2types/genesis.pb.go +++ /dev/null @@ -1,322 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/liquidation/v2/genesis.proto - -package v2types - -import ( - fmt "fmt" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type GenesisState struct { - Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` -} - -func (m *GenesisState) Reset() { *m = GenesisState{} } -func (m *GenesisState) String() string { return proto.CompactTextString(m) } -func (*GenesisState) ProtoMessage() {} -func (*GenesisState) Descriptor() ([]byte, []int) { - return fileDescriptor_9f9021f2fff7cb6b, []int{0} -} -func (m *GenesisState) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenesisState.Merge(m, src) -} -func (m *GenesisState) XXX_Size() int { - return m.Size() -} -func (m *GenesisState) XXX_DiscardUnknown() { - xxx_messageInfo_GenesisState.DiscardUnknown(m) -} - -var xxx_messageInfo_GenesisState proto.InternalMessageInfo - -func (m *GenesisState) GetParams() Params { - if m != nil { - return m.Params - } - return Params{} -} - -func init() { - proto.RegisterType((*GenesisState)(nil), "comdex.liquidation.v2.GenesisState") -} - -func init() { - proto.RegisterFile("comdex/liquidation/v2/genesis.proto", fileDescriptor_9f9021f2fff7cb6b) -} - -var fileDescriptor_9f9021f2fff7cb6b = []byte{ - // 203 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4e, 0xce, 0xcf, 0x4d, - 0x49, 0xad, 0xd0, 0xcf, 0xc9, 0x2c, 0x2c, 0xcd, 0x4c, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, - 0x33, 0xd2, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, - 0x12, 0x85, 0x28, 0xd2, 0x43, 0x52, 0xa4, 0x57, 0x66, 0x24, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, - 0x56, 0xa1, 0x0f, 0x62, 0x41, 0x14, 0x4b, 0x29, 0x61, 0x37, 0xb1, 0x20, 0xb1, 0x28, 0x31, 0x17, - 0x6a, 0xa0, 0x92, 0x37, 0x17, 0x8f, 0x3b, 0xc4, 0x86, 0xe0, 0x92, 0xc4, 0x92, 0x54, 0x21, 0x6b, - 0x2e, 0x36, 0x88, 0xbc, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb7, 0x91, 0xac, 0x1e, 0x56, 0x1b, 0xf5, - 0x02, 0xc0, 0x8a, 0x9c, 0x58, 0x4e, 0xdc, 0x93, 0x67, 0x08, 0x82, 0x6a, 0x71, 0x0a, 0x3c, 0xf1, - 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, - 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xf3, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, - 0x90, 0x61, 0xfa, 0x10, 0x03, 0x75, 0xf3, 0xd3, 0xd2, 0x32, 0x93, 0x33, 0x13, 0x73, 0xa0, 0x7c, - 0x7d, 0x74, 0x77, 0x96, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x9d, 0x69, 0x0c, 0x08, 0x00, - 0x00, 0xff, 0xff, 0xea, 0x8a, 0xa0, 0xd1, 0x1e, 0x01, 0x00, 0x00, -} - -func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GenesisState) 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 = encodeVarintGenesis(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - -func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { - offset -= sovGenesis(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *GenesisState) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.Params.Size() - n += 1 + l + sovGenesis(uint64(l)) - return n -} - -func sovGenesis(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozGenesis(x uint64) (n int) { - return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *GenesisState) 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 ErrIntOverflowGenesis - } - 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: GenesisState: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenesis - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenesis - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenesis - } - 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 := skipGenesis(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGenesis - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipGenesis(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenesis - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenesis - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGenesis - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthGenesis - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupGenesis - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthGenesis - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/liquidation/v2types/gov.pb.go b/x/liquidation/v2types/gov.pb.go deleted file mode 100644 index 6431b349a..000000000 --- a/x/liquidation/v2types/gov.pb.go +++ /dev/null @@ -1,407 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/liquidation/v2/gov.proto - -package v2types - -import ( - fmt "fmt" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type WhitelistLiquidationProposal struct { - Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty" yaml:"title"` - Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"` - Whitelisting LiquidationWhiteListing `protobuf:"bytes,3,opt,name=whitelisting,proto3" json:"whitelisting"` -} - -func (m *WhitelistLiquidationProposal) Reset() { *m = WhitelistLiquidationProposal{} } -func (m *WhitelistLiquidationProposal) String() string { return proto.CompactTextString(m) } -func (*WhitelistLiquidationProposal) ProtoMessage() {} -func (*WhitelistLiquidationProposal) Descriptor() ([]byte, []int) { - return fileDescriptor_a3d7b286df81d8d3, []int{0} -} -func (m *WhitelistLiquidationProposal) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *WhitelistLiquidationProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_WhitelistLiquidationProposal.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 *WhitelistLiquidationProposal) XXX_Merge(src proto.Message) { - xxx_messageInfo_WhitelistLiquidationProposal.Merge(m, src) -} -func (m *WhitelistLiquidationProposal) XXX_Size() int { - return m.Size() -} -func (m *WhitelistLiquidationProposal) XXX_DiscardUnknown() { - xxx_messageInfo_WhitelistLiquidationProposal.DiscardUnknown(m) -} - -var xxx_messageInfo_WhitelistLiquidationProposal proto.InternalMessageInfo - -func init() { - proto.RegisterType((*WhitelistLiquidationProposal)(nil), "comdex.liquidation.v2.WhitelistLiquidationProposal") -} - -func init() { proto.RegisterFile("comdex/liquidation/v2/gov.proto", fileDescriptor_a3d7b286df81d8d3) } - -var fileDescriptor_a3d7b286df81d8d3 = []byte{ - // 291 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xce, 0xcf, 0x4d, - 0x49, 0xad, 0xd0, 0xcf, 0xc9, 0x2c, 0x2c, 0xcd, 0x4c, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, - 0x33, 0xd2, 0x4f, 0xcf, 0x2f, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x85, 0x28, 0xd0, - 0x43, 0x52, 0xa0, 0x57, 0x66, 0x24, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, 0x56, 0xa1, 0x0f, 0x62, - 0x41, 0x14, 0x4b, 0xa9, 0x62, 0x37, 0x0d, 0xc6, 0x4d, 0x85, 0x28, 0x53, 0xba, 0xc5, 0xc8, 0x25, - 0x13, 0x9e, 0x91, 0x59, 0x92, 0x9a, 0x93, 0x59, 0x5c, 0xe2, 0x83, 0x50, 0x1b, 0x50, 0x94, 0x5f, - 0x90, 0x5f, 0x9c, 0x98, 0x23, 0xa4, 0xc6, 0xc5, 0x5a, 0x92, 0x59, 0x92, 0x93, 0x2a, 0xc1, 0xa8, - 0xc0, 0xa8, 0xc1, 0xe9, 0x24, 0xf0, 0xe9, 0x9e, 0x3c, 0x4f, 0x65, 0x62, 0x6e, 0x8e, 0x95, 0x12, - 0x58, 0x58, 0x29, 0x08, 0x22, 0x2d, 0x64, 0xc1, 0xc5, 0x9d, 0x92, 0x5a, 0x9c, 0x5c, 0x94, 0x59, - 0x00, 0xd2, 0x2e, 0xc1, 0x04, 0x56, 0x2d, 0xf6, 0xe9, 0x9e, 0xbc, 0x10, 0x44, 0x35, 0x92, 0xa4, - 0x52, 0x10, 0xb2, 0x52, 0xa1, 0x08, 0x2e, 0x9e, 0x72, 0x98, 0x0b, 0x32, 0xf3, 0xd2, 0x25, 0x98, - 0x15, 0x18, 0x35, 0xb8, 0x8d, 0xf4, 0xf4, 0xb0, 0xfa, 0x56, 0x0f, 0xc9, 0x8d, 0x60, 0x77, 0xfb, - 0x40, 0x74, 0x39, 0xb1, 0x9c, 0xb8, 0x27, 0xcf, 0x10, 0x84, 0x62, 0x92, 0x53, 0xe4, 0x89, 0x87, - 0x72, 0x0c, 0x2b, 0x1e, 0xc9, 0x31, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, - 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, - 0x94, 0x79, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x12, 0xc8, 0x2e, 0x7d, 0x88, 0x7d, 0xba, 0xf9, 0x69, - 0x69, 0x99, 0xc9, 0x99, 0x89, 0x39, 0x50, 0xbe, 0x3e, 0x7a, 0x10, 0x96, 0x54, 0x16, 0xa4, 0x16, - 0x27, 0xb1, 0x81, 0x83, 0xcf, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x1c, 0xbb, 0x82, 0xb5, - 0x01, 0x00, 0x00, -} - -func (m *WhitelistLiquidationProposal) 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 *WhitelistLiquidationProposal) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *WhitelistLiquidationProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.Whitelisting.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGov(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if len(m.Description) > 0 { - i -= len(m.Description) - copy(dAtA[i:], m.Description) - i = encodeVarintGov(dAtA, i, uint64(len(m.Description))) - i-- - dAtA[i] = 0x12 - } - if len(m.Title) > 0 { - i -= len(m.Title) - copy(dAtA[i:], m.Title) - i = encodeVarintGov(dAtA, i, uint64(len(m.Title))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func encodeVarintGov(dAtA []byte, offset int, v uint64) int { - offset -= sovGov(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *WhitelistLiquidationProposal) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Title) - if l > 0 { - n += 1 + l + sovGov(uint64(l)) - } - l = len(m.Description) - if l > 0 { - n += 1 + l + sovGov(uint64(l)) - } - l = m.Whitelisting.Size() - n += 1 + l + sovGov(uint64(l)) - return n -} - -func sovGov(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozGov(x uint64) (n int) { - return sovGov(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *WhitelistLiquidationProposal) 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 ErrIntOverflowGov - } - 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: WhitelistLiquidationProposal: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: WhitelistLiquidationProposal: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGov - } - 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 ErrInvalidLengthGov - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGov - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Title = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGov - } - 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 ErrInvalidLengthGov - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGov - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Description = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Whitelisting", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGov - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGov - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGov - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Whitelisting.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGov(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthGov - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipGov(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGov - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGov - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowGov - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthGov - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupGov - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthGov - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthGov = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowGov = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupGov = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/liquidation/v2types/liquidate.pb.go b/x/liquidation/v2types/liquidate.pb.go deleted file mode 100644 index f8290d147..000000000 --- a/x/liquidation/v2types/liquidate.pb.go +++ /dev/null @@ -1,2867 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/liquidation/v2/liquidate.proto - -package v2types - -import ( - fmt "fmt" - _ "github.com/cosmos/cosmos-sdk/types" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" - _ "google.golang.org/protobuf/types/known/timestamppb" - io "io" - math "math" - math_bits "math/bits" - time "time" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf -var _ = time.Kitchen - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type LiquidationWhiteListing struct { - AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` - //AuctionTriggerer - //External Apps -------------> If external triggerer , then some params will be used from Comdex base app // If internal app triggerrer then params to be used from base app - //Comdex Apps - //bool param - //true - comdex apps - //false external apps - Initiator bool `protobuf:"varint,6,opt,name=initiator,proto3" json:"initiator,omitempty" yaml:"initiator"` - //Sets of Params for Dutch Auction - IsDutchActivated bool `protobuf:"varint,7,opt,name=is_dutch_activated,json=isDutchActivated,proto3" json:"is_dutch_activated,omitempty" yaml:"is_dutch_activated"` - DutchAuctionParam *DutchAuctionParam `protobuf:"bytes,8,opt,name=dutch_auction_param,json=dutchAuctionParam,proto3" json:"dutch_auction_param,omitempty" yaml:"dutch_auction_param"` - //Sets of Params for English Auction - IsEnglishActivated bool `protobuf:"varint,9,opt,name=is_english_activated,json=isEnglishActivated,proto3" json:"is_english_activated,omitempty" yaml:"is_english_activated"` - EnglishAuctionParam *EnglishAuctionParam `protobuf:"bytes,10,opt,name=english_auction_param,json=englishAuctionParam,proto3" json:"english_auction_param,omitempty" yaml:"english_auction_param"` - KeeeperIncentive github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,11,opt,name=keeeper_incentive,json=keeeperIncentive,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"keeeper_incentive" yaml:"keeper_incentive"` -} - -func (m *LiquidationWhiteListing) Reset() { *m = LiquidationWhiteListing{} } -func (m *LiquidationWhiteListing) String() string { return proto.CompactTextString(m) } -func (*LiquidationWhiteListing) ProtoMessage() {} -func (*LiquidationWhiteListing) Descriptor() ([]byte, []int) { - return fileDescriptor_5b5ec44ce2c32c8b, []int{0} -} -func (m *LiquidationWhiteListing) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *LiquidationWhiteListing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_LiquidationWhiteListing.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 *LiquidationWhiteListing) XXX_Merge(src proto.Message) { - xxx_messageInfo_LiquidationWhiteListing.Merge(m, src) -} -func (m *LiquidationWhiteListing) XXX_Size() int { - return m.Size() -} -func (m *LiquidationWhiteListing) XXX_DiscardUnknown() { - xxx_messageInfo_LiquidationWhiteListing.DiscardUnknown(m) -} - -var xxx_messageInfo_LiquidationWhiteListing proto.InternalMessageInfo - -type AppReserveFunds struct { - AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` - AssetId uint64 `protobuf:"varint,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty" yaml:"asset_id"` - TokenQuantity github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=token_quantity,json=tokenQuantity,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"token_quantity" yaml:"token_quantity"` -} - -func (m *AppReserveFunds) Reset() { *m = AppReserveFunds{} } -func (m *AppReserveFunds) String() string { return proto.CompactTextString(m) } -func (*AppReserveFunds) ProtoMessage() {} -func (*AppReserveFunds) Descriptor() ([]byte, []int) { - return fileDescriptor_5b5ec44ce2c32c8b, []int{1} -} -func (m *AppReserveFunds) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AppReserveFunds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AppReserveFunds.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 *AppReserveFunds) XXX_Merge(src proto.Message) { - xxx_messageInfo_AppReserveFunds.Merge(m, src) -} -func (m *AppReserveFunds) XXX_Size() int { - return m.Size() -} -func (m *AppReserveFunds) XXX_DiscardUnknown() { - xxx_messageInfo_AppReserveFunds.DiscardUnknown(m) -} - -var xxx_messageInfo_AppReserveFunds proto.InternalMessageInfo - -type AppReserveFundsTxData struct { - AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` - AssetTxData []AssetTxData `protobuf:"bytes,2,rep,name=asset_tx_data,json=assetTxData,proto3" json:"asset_tx_data" yaml:"asset_tx_data"` -} - -func (m *AppReserveFundsTxData) Reset() { *m = AppReserveFundsTxData{} } -func (m *AppReserveFundsTxData) String() string { return proto.CompactTextString(m) } -func (*AppReserveFundsTxData) ProtoMessage() {} -func (*AppReserveFundsTxData) Descriptor() ([]byte, []int) { - return fileDescriptor_5b5ec44ce2c32c8b, []int{2} -} -func (m *AppReserveFundsTxData) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AppReserveFundsTxData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AppReserveFundsTxData.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 *AppReserveFundsTxData) XXX_Merge(src proto.Message) { - xxx_messageInfo_AppReserveFundsTxData.Merge(m, src) -} -func (m *AppReserveFundsTxData) XXX_Size() int { - return m.Size() -} -func (m *AppReserveFundsTxData) XXX_DiscardUnknown() { - xxx_messageInfo_AppReserveFundsTxData.DiscardUnknown(m) -} - -var xxx_messageInfo_AppReserveFundsTxData proto.InternalMessageInfo - -type AssetTxData struct { - AssetId uint64 `protobuf:"varint,1,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty" yaml:"asset_id"` - TxType string `protobuf:"bytes,2,opt,name=tx_type,json=txType,proto3" json:"tx_type,omitempty" yaml:"tx_type"` - TokenQuantity github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,3,opt,name=token_quantity,json=tokenQuantity,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"token_quantity" yaml:"token_quantity"` -} - -func (m *AssetTxData) Reset() { *m = AssetTxData{} } -func (m *AssetTxData) String() string { return proto.CompactTextString(m) } -func (*AssetTxData) ProtoMessage() {} -func (*AssetTxData) Descriptor() ([]byte, []int) { - return fileDescriptor_5b5ec44ce2c32c8b, []int{3} -} -func (m *AssetTxData) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *AssetTxData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_AssetTxData.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 *AssetTxData) XXX_Merge(src proto.Message) { - xxx_messageInfo_AssetTxData.Merge(m, src) -} -func (m *AssetTxData) XXX_Size() int { - return m.Size() -} -func (m *AssetTxData) XXX_DiscardUnknown() { - xxx_messageInfo_AssetTxData.DiscardUnknown(m) -} - -var xxx_messageInfo_AssetTxData proto.InternalMessageInfo - -type DutchAuctionParam struct { - Premium github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=premium,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"premium" yaml:"premium"` - Discount github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=discount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"discount" yaml:"discount"` - DecrementFactor github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=decrement_factor,json=decrementFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"decrement_factor" yaml:"decrement_factor"` -} - -func (m *DutchAuctionParam) Reset() { *m = DutchAuctionParam{} } -func (m *DutchAuctionParam) String() string { return proto.CompactTextString(m) } -func (*DutchAuctionParam) ProtoMessage() {} -func (*DutchAuctionParam) Descriptor() ([]byte, []int) { - return fileDescriptor_5b5ec44ce2c32c8b, []int{4} -} -func (m *DutchAuctionParam) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DutchAuctionParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DutchAuctionParam.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 *DutchAuctionParam) XXX_Merge(src proto.Message) { - xxx_messageInfo_DutchAuctionParam.Merge(m, src) -} -func (m *DutchAuctionParam) XXX_Size() int { - return m.Size() -} -func (m *DutchAuctionParam) XXX_DiscardUnknown() { - xxx_messageInfo_DutchAuctionParam.DiscardUnknown(m) -} - -var xxx_messageInfo_DutchAuctionParam proto.InternalMessageInfo - -type EnglishAuctionParam struct { - DecrementFactor github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=decrement_factor,json=decrementFactor,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"decrement_factor" yaml:"decrement_factor"` -} - -func (m *EnglishAuctionParam) Reset() { *m = EnglishAuctionParam{} } -func (m *EnglishAuctionParam) String() string { return proto.CompactTextString(m) } -func (*EnglishAuctionParam) ProtoMessage() {} -func (*EnglishAuctionParam) Descriptor() ([]byte, []int) { - return fileDescriptor_5b5ec44ce2c32c8b, []int{5} -} -func (m *EnglishAuctionParam) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *EnglishAuctionParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_EnglishAuctionParam.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 *EnglishAuctionParam) XXX_Merge(src proto.Message) { - xxx_messageInfo_EnglishAuctionParam.Merge(m, src) -} -func (m *EnglishAuctionParam) XXX_Size() int { - return m.Size() -} -func (m *EnglishAuctionParam) XXX_DiscardUnknown() { - xxx_messageInfo_EnglishAuctionParam.DiscardUnknown(m) -} - -var xxx_messageInfo_EnglishAuctionParam proto.InternalMessageInfo - -type LiquidationOffsetHolder struct { - AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"id"` - CurrentOffset uint64 `protobuf:"varint,2,opt,name=current_offset,json=currentOffset,proto3" json:"current_offset,omitempty"` -} - -func (m *LiquidationOffsetHolder) Reset() { *m = LiquidationOffsetHolder{} } -func (m *LiquidationOffsetHolder) String() string { return proto.CompactTextString(m) } -func (*LiquidationOffsetHolder) ProtoMessage() {} -func (*LiquidationOffsetHolder) Descriptor() ([]byte, []int) { - return fileDescriptor_5b5ec44ce2c32c8b, []int{6} -} -func (m *LiquidationOffsetHolder) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *LiquidationOffsetHolder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_LiquidationOffsetHolder.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 *LiquidationOffsetHolder) XXX_Merge(src proto.Message) { - xxx_messageInfo_LiquidationOffsetHolder.Merge(m, src) -} -func (m *LiquidationOffsetHolder) XXX_Size() int { - return m.Size() -} -func (m *LiquidationOffsetHolder) XXX_DiscardUnknown() { - xxx_messageInfo_LiquidationOffsetHolder.DiscardUnknown(m) -} - -var xxx_messageInfo_LiquidationOffsetHolder proto.InternalMessageInfo - -type LockedVault struct { - LockedVaultId uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" yaml:"id"` - AppId uint64 `protobuf:"varint,2,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"id"` - OriginalVaultId uint64 `protobuf:"varint,3,opt,name=original_vault_id,json=originalVaultId,proto3" json:"original_vault_id,omitempty" yaml:"id"` - ExtendedPairId uint64 `protobuf:"varint,4,opt,name=extended_pair_vault_id,json=extendedPairVaultId,proto3" json:"extended_pair_vault_id,omitempty" yaml:"extended_pair_vault_id"` - Owner string `protobuf:"bytes,5,opt,name=owner,proto3" json:"owner,omitempty" yaml:"owner"` - CollateralToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,6,opt,name=collateral_token,json=collateralToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_token" yaml:"collateral_token"` - DebtToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,7,opt,name=debt_token,json=debtToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token" yaml:"debt_token"` - CurrentCollaterlisationRatio github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,8,opt,name=current_collateralisation_ratio,json=currentCollateralisationRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"current_collateralisation_ratio" yaml:"current_collateralisation_ratio"` - CollateralToBeAuctioned github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,9,opt,name=collateral_to_be_auctioned,json=collateralToBeAuctioned,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_to_be_auctioned" yaml:"CollateralToBeAuctioned"` - TargetDebt github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,10,opt,name=target_debt,json=targetDebt,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"target_debt" yaml:"target_debt"` - LiquidationTimestamp time.Time `protobuf:"bytes,11,opt,name=liquidation_timestamp,json=liquidationTimestamp,proto3,stdtime" json:"liquidation_timestamp" yaml:"liquidation_timestamp"` - // true for internal liquidator through bot , false if abci initiated liquidation - IsInternalKeeper bool `protobuf:"varint,12,opt,name=is_internal_keeper,json=isInternalKeeper,proto3" json:"is_internal_keeper,omitempty" yaml:"is_intenal_keeper"` - InternalKeeperAddress string `protobuf:"bytes,13,opt,name=internal_keeper_address,json=internalKeeperAddress,proto3" json:"internal_keeper_address,omitempty" yaml:"internal_keeper_address"` - //To return funds to the external app back - ExternalKeeperAddress string `protobuf:"bytes,15,opt,name=external_keeper_address,json=externalKeeperAddress,proto3" json:"external_keeper_address,omitempty" yaml:"external_keeper_address"` - FeeToBeCollected github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,16,opt,name=fee_to_be_collected,json=feeToBeCollected,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"fee_to_be_collected" yaml:"fee_to_be_collected"` - BonusToBeGiven github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,17,opt,name=bonus_to_be_given,json=bonusToBeGiven,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"bonus_to_be_given" yaml:"bonus_to_be_given"` - InitiatorType string `protobuf:"bytes,18,opt,name=initiator_type,json=initiatorType,proto3" json:"initiator_type,omitempty" yaml:"initiator_type"` - AuctionType bool `protobuf:"varint,19,opt,name=auction_type,json=auctionType,proto3" json:"auction_type,omitempty" yaml:"auction_type"` - IsDebtCmst bool `protobuf:"varint,20,opt,name=is_debt_cmst,json=isDebtCmst,proto3" json:"is_debt_cmst,omitempty" yaml:"is_debt_cmst"` - // uint64 pair_id = 21 [ - // (gogoproto.customname) = "PairId", - // (gogoproto.moretags) = "yaml:\"pair_id\""]; - CollateralAssetId uint64 `protobuf:"varint,21,opt,name=collateral_asset_id,json=collateralAssetId,proto3" json:"collateral_asset_id,omitempty" yaml:"collateral_asset_id"` - DebtAssetId uint64 `protobuf:"varint,22,opt,name=debt_asset_id,json=debtAssetId,proto3" json:"debt_asset_id,omitempty" yaml:"debt_asset_id"` -} - -func (m *LockedVault) Reset() { *m = LockedVault{} } -func (m *LockedVault) String() string { return proto.CompactTextString(m) } -func (*LockedVault) ProtoMessage() {} -func (*LockedVault) Descriptor() ([]byte, []int) { - return fileDescriptor_5b5ec44ce2c32c8b, []int{7} -} -func (m *LockedVault) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *LockedVault) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_LockedVault.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 *LockedVault) XXX_Merge(src proto.Message) { - xxx_messageInfo_LockedVault.Merge(m, src) -} -func (m *LockedVault) XXX_Size() int { - return m.Size() -} -func (m *LockedVault) XXX_DiscardUnknown() { - xxx_messageInfo_LockedVault.DiscardUnknown(m) -} - -var xxx_messageInfo_LockedVault proto.InternalMessageInfo - -func init() { - proto.RegisterType((*LiquidationWhiteListing)(nil), "comdex.liquidation.v2.LiquidationWhiteListing") - proto.RegisterType((*AppReserveFunds)(nil), "comdex.liquidation.v2.AppReserveFunds") - proto.RegisterType((*AppReserveFundsTxData)(nil), "comdex.liquidation.v2.AppReserveFundsTxData") - proto.RegisterType((*AssetTxData)(nil), "comdex.liquidation.v2.AssetTxData") - proto.RegisterType((*DutchAuctionParam)(nil), "comdex.liquidation.v2.DutchAuctionParam") - proto.RegisterType((*EnglishAuctionParam)(nil), "comdex.liquidation.v2.EnglishAuctionParam") - proto.RegisterType((*LiquidationOffsetHolder)(nil), "comdex.liquidation.v2.LiquidationOffsetHolder") - proto.RegisterType((*LockedVault)(nil), "comdex.liquidation.v2.LockedVault") -} - -func init() { - proto.RegisterFile("comdex/liquidation/v2/liquidate.proto", fileDescriptor_5b5ec44ce2c32c8b) -} - -var fileDescriptor_5b5ec44ce2c32c8b = []byte{ - // 1597 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x5d, 0x6f, 0x1b, 0x45, - 0x17, 0xce, 0x3a, 0xcd, 0x87, 0xc7, 0x71, 0x62, 0x4f, 0xe2, 0xc6, 0xcd, 0xdb, 0x7a, 0xf3, 0xae, - 0xd4, 0xbe, 0x51, 0xab, 0xda, 0x6f, 0x52, 0xa1, 0x8a, 0x0f, 0x09, 0xe2, 0x24, 0x6d, 0x0d, 0x11, - 0x6d, 0x57, 0x11, 0x88, 0x0a, 0x58, 0xc6, 0xbb, 0x63, 0x67, 0x14, 0x7b, 0xd7, 0xdd, 0x1d, 0x1b, - 0xe7, 0x06, 0x09, 0x6e, 0x90, 0xf8, 0x10, 0xe5, 0x8a, 0xbf, 0x00, 0xbf, 0x02, 0x2e, 0xb8, 0xa8, - 0xb8, 0xea, 0x25, 0xe2, 0x62, 0x81, 0xed, 0x3f, 0xf0, 0x1d, 0x5c, 0xa1, 0xf9, 0x58, 0xef, 0xda, - 0xd9, 0x84, 0xba, 0x12, 0x12, 0x37, 0x75, 0x77, 0xce, 0x79, 0x9e, 0x73, 0xe6, 0xcc, 0x99, 0x33, - 0xe7, 0x04, 0x5c, 0x36, 0x9d, 0xb6, 0x85, 0xfb, 0x95, 0x16, 0x79, 0xd8, 0x25, 0x16, 0xa2, 0xc4, - 0xb1, 0x2b, 0xbd, 0xad, 0xe1, 0x27, 0x2e, 0x77, 0x5c, 0x87, 0x3a, 0xb0, 0x20, 0xd4, 0xca, 0x31, - 0xb5, 0x72, 0x6f, 0x6b, 0x6d, 0xa5, 0xe9, 0x34, 0x1d, 0xae, 0x51, 0x61, 0xff, 0x13, 0xca, 0x6b, - 0x6a, 0xd3, 0x71, 0x9a, 0x2d, 0x5c, 0xe1, 0x5f, 0xf5, 0x6e, 0xa3, 0x42, 0x49, 0x1b, 0x7b, 0x14, - 0xb5, 0x3b, 0x52, 0xa1, 0x64, 0x3a, 0x5e, 0xdb, 0xf1, 0x2a, 0x75, 0xe4, 0xe1, 0x4a, 0x6f, 0xb3, - 0x8e, 0x29, 0xda, 0xac, 0x98, 0x0e, 0xb1, 0x85, 0x5c, 0xfb, 0x63, 0x06, 0xac, 0xee, 0x47, 0x96, - 0xde, 0x3e, 0x24, 0x14, 0xef, 0x13, 0x8f, 0x12, 0xbb, 0x09, 0x37, 0xc1, 0x2c, 0xea, 0x74, 0x0c, - 0x62, 0x15, 0x95, 0x75, 0x65, 0xe3, 0x5c, 0x75, 0x2d, 0xf0, 0xd5, 0x99, 0xed, 0x4e, 0xa7, 0x66, - 0x0d, 0x7c, 0x35, 0x7b, 0x8c, 0xda, 0xad, 0x97, 0x34, 0xa1, 0xa0, 0xe9, 0x33, 0x88, 0xad, 0xc3, - 0x57, 0x41, 0x9a, 0xd8, 0x84, 0x12, 0x44, 0x1d, 0xb7, 0x38, 0xbb, 0xae, 0x6c, 0xcc, 0x57, 0xff, - 0x1b, 0xf8, 0x6a, 0xba, 0x16, 0x2e, 0x0e, 0x7c, 0x35, 0x27, 0x90, 0x43, 0x3d, 0x4d, 0x8f, 0x30, - 0xd0, 0x00, 0x90, 0x78, 0x86, 0xd5, 0xa5, 0xe6, 0xa1, 0x81, 0x4c, 0x4a, 0x7a, 0x88, 0x62, 0xab, - 0x38, 0xc7, 0x99, 0x36, 0x03, 0x5f, 0xcd, 0xd5, 0xbc, 0x5d, 0x26, 0xdc, 0x0e, 0x65, 0x03, 0x5f, - 0xbd, 0x20, 0x09, 0x4f, 0xe0, 0x34, 0x3d, 0x47, 0xc6, 0xd4, 0xe1, 0x97, 0x0a, 0x58, 0x96, 0x6a, - 0x5d, 0x93, 0x6d, 0xd9, 0xe8, 0x20, 0x17, 0xb5, 0x8b, 0xf3, 0xeb, 0xca, 0x46, 0x66, 0x6b, 0xa3, - 0x9c, 0x18, 0xfd, 0xb2, 0x20, 0x11, 0x80, 0x7b, 0x4c, 0xbf, 0x7a, 0x23, 0xf0, 0xd5, 0xfc, 0x89, - 0xe5, 0x81, 0xaf, 0xae, 0x09, 0x6f, 0x12, 0x6c, 0x68, 0x7a, 0xde, 0x1a, 0x07, 0xc0, 0x26, 0x58, - 0x21, 0x9e, 0x81, 0xed, 0x66, 0x8b, 0x78, 0xf1, 0x2d, 0xa7, 0xf9, 0x96, 0x5f, 0x08, 0x7c, 0x15, - 0xd6, 0xbc, 0x3d, 0x21, 0x8e, 0x6f, 0xfa, 0x3f, 0xc3, 0x4d, 0x9f, 0xc0, 0x6a, 0x3a, 0x24, 0x27, - 0x20, 0xf0, 0x1b, 0x05, 0x14, 0x86, 0xaa, 0x23, 0x5b, 0x07, 0x7c, 0xeb, 0x57, 0x4f, 0xd9, 0x7a, - 0x48, 0x14, 0xdf, 0xfc, 0xcd, 0xc0, 0x57, 0x97, 0x13, 0x04, 0x03, 0x5f, 0xbd, 0x28, 0xfc, 0x4a, - 0xb4, 0xa4, 0xe9, 0xcb, 0xf8, 0x24, 0x08, 0xf6, 0x40, 0xfe, 0x08, 0x63, 0xdc, 0xc1, 0xae, 0x41, - 0x6c, 0x13, 0xdb, 0x94, 0xf4, 0x70, 0x31, 0xb3, 0xae, 0x6c, 0xa4, 0xab, 0xb5, 0xc7, 0xbe, 0x3a, - 0xf5, 0x8b, 0xaf, 0x5e, 0x69, 0x12, 0x7a, 0xd8, 0xad, 0x33, 0x17, 0x2b, 0x32, 0xa3, 0xc5, 0xcf, - 0x75, 0xcf, 0x3a, 0xaa, 0xd0, 0xe3, 0x0e, 0xf6, 0xca, 0xbb, 0xd8, 0x1c, 0xf8, 0xea, 0xaa, 0xb0, - 0x7f, 0x34, 0xc6, 0xa7, 0xe9, 0x39, 0x69, 0xa3, 0x36, 0x5c, 0xfa, 0x22, 0x05, 0x96, 0xb6, 0x3b, - 0x1d, 0x1d, 0x7b, 0xd8, 0xed, 0xe1, 0x5b, 0x5d, 0xdb, 0xf2, 0x9e, 0x27, 0xe7, 0x5f, 0x04, 0xf3, - 0xc8, 0xf3, 0x30, 0x65, 0xa0, 0x14, 0x07, 0x95, 0x02, 0x5f, 0x9d, 0xdb, 0x66, 0x6b, 0x1c, 0xb6, - 0x24, 0x61, 0x52, 0x49, 0xd3, 0xe7, 0x90, 0x90, 0xc1, 0xcf, 0x14, 0xb0, 0x48, 0x9d, 0x23, 0x6c, - 0x1b, 0x0f, 0xbb, 0xc8, 0xa6, 0x84, 0x1e, 0x17, 0xa7, 0xf9, 0x61, 0x5c, 0x28, 0x8b, 0xed, 0x95, - 0xd9, 0xbd, 0x2d, 0xcb, 0x7b, 0x5b, 0xde, 0x71, 0x88, 0x5d, 0xbd, 0xc3, 0x42, 0x32, 0xf0, 0xd5, - 0x82, 0x60, 0x1d, 0x85, 0x6b, 0x7f, 0xfa, 0xea, 0xff, 0x9e, 0x21, 0x56, 0x8c, 0x49, 0xcf, 0x72, - 0xec, 0xfd, 0x10, 0xfa, 0xbd, 0x02, 0x0a, 0x63, 0xe1, 0x38, 0xe8, 0xef, 0x22, 0x8a, 0x9e, 0x27, - 0x28, 0x1e, 0xc8, 0x8a, 0xfd, 0xd2, 0xbe, 0x61, 0x21, 0x8a, 0x8a, 0xa9, 0xf5, 0xe9, 0x8d, 0xcc, - 0x96, 0x76, 0x4a, 0x92, 0xf1, 0x60, 0x09, 0x6b, 0xd5, 0x6b, 0x6c, 0x83, 0x81, 0xaf, 0x66, 0x62, - 0x8b, 0x03, 0x5f, 0x5d, 0x89, 0x47, 0x51, 0xb2, 0x6a, 0x7a, 0x06, 0x45, 0x4a, 0xda, 0x27, 0x29, - 0x10, 0x07, 0x8d, 0x9c, 0x8c, 0x32, 0xd9, 0xc9, 0x5c, 0x03, 0x73, 0xb4, 0x6f, 0xb0, 0x60, 0xf1, - 0x33, 0x4d, 0x57, 0xe1, 0xc0, 0x57, 0x17, 0x65, 0xc8, 0x85, 0x40, 0xd3, 0x67, 0x69, 0xff, 0xe0, - 0xb8, 0x83, 0xff, 0x5d, 0xc7, 0xf8, 0x63, 0x0a, 0x9c, 0xac, 0x4b, 0xf0, 0x01, 0x98, 0xeb, 0xb8, - 0xb8, 0x4d, 0xba, 0x6d, 0x1e, 0x89, 0x74, 0xf5, 0xb5, 0x89, 0x6f, 0x96, 0xdc, 0xbd, 0xa4, 0xd1, - 0xf4, 0x90, 0x10, 0xbe, 0x07, 0xe6, 0x2d, 0xe2, 0x99, 0x4e, 0xd7, 0xa6, 0x32, 0x58, 0xdb, 0x13, - 0x93, 0xcb, 0x93, 0x08, 0x79, 0x34, 0x7d, 0x48, 0x09, 0x29, 0xc8, 0x59, 0xd8, 0x74, 0x71, 0x1b, - 0xdb, 0xd4, 0x68, 0x20, 0x93, 0x3d, 0x2d, 0xd3, 0x13, 0x57, 0x87, 0x9a, 0x4d, 0xa3, 0xea, 0x30, - 0xce, 0xa7, 0xe9, 0x4b, 0xc3, 0xa5, 0x5b, 0x62, 0xe5, 0x73, 0x05, 0x24, 0x55, 0xb8, 0x44, 0x6f, - 0x94, 0x7f, 0xdc, 0x1b, 0x67, 0xe4, 0x95, 0xbe, 0xdb, 0x68, 0x78, 0x98, 0xde, 0x71, 0x5a, 0x16, - 0x76, 0xe1, 0xf5, 0xb1, 0xcb, 0x79, 0x3e, 0x7e, 0x39, 0xd3, 0xf2, 0x95, 0x88, 0x2e, 0xe6, 0x65, - 0xb0, 0x68, 0x76, 0x5d, 0x97, 0x59, 0x73, 0x38, 0x8d, 0xa8, 0x59, 0x7a, 0x56, 0xae, 0x0a, 0x6e, - 0xed, 0xa7, 0x3c, 0xc8, 0xec, 0x3b, 0xe6, 0x11, 0xb6, 0xde, 0x42, 0xdd, 0x16, 0x85, 0x65, 0x90, - 0x1a, 0xb9, 0x44, 0xd9, 0x98, 0x70, 0xdc, 0x52, 0x8a, 0x58, 0x31, 0xaf, 0x52, 0xcf, 0xe2, 0xd5, - 0x3e, 0xc8, 0x3b, 0x2e, 0x69, 0x12, 0x1b, 0xb5, 0x8c, 0x1e, 0xe3, 0x64, 0xc8, 0x69, 0x8e, 0x5c, - 0x0f, 0x7c, 0x75, 0xe9, 0xae, 0x14, 0x26, 0xda, 0x5b, 0x72, 0x46, 0xa5, 0xf0, 0x10, 0x9c, 0xc7, - 0x7d, 0x8a, 0x6d, 0x0b, 0x5b, 0x46, 0x07, 0x11, 0x37, 0xa2, 0x3c, 0xc7, 0x29, 0xd9, 0xdb, 0xbd, - 0xb8, 0x27, 0x35, 0xee, 0x21, 0xe2, 0x72, 0xc6, 0x4b, 0xf2, 0xe5, 0x4a, 0x44, 0xb2, 0xa7, 0x2b, - 0x06, 0x08, 0x2d, 0x55, 0xc0, 0x8c, 0xf3, 0xa1, 0x8d, 0xdd, 0xe2, 0x0c, 0x4f, 0x81, 0x0b, 0x6c, - 0x97, 0x77, 0xd9, 0xc2, 0xc0, 0x57, 0x17, 0x04, 0x1f, 0x97, 0x6b, 0xba, 0xd0, 0x83, 0x8f, 0x14, - 0x90, 0x33, 0x9d, 0x56, 0x0b, 0x51, 0xec, 0xa2, 0x96, 0xc1, 0xaf, 0x2e, 0x6f, 0x94, 0xce, 0x2c, - 0x16, 0xaf, 0xcb, 0x62, 0x21, 0x13, 0x66, 0x9c, 0x60, 0xa2, 0x72, 0xb1, 0x14, 0xa1, 0x0f, 0x18, - 0x18, 0x7e, 0x04, 0x80, 0x85, 0xeb, 0x54, 0xfa, 0x32, 0xf7, 0x77, 0xbe, 0xec, 0x4a, 0x5f, 0xf2, - 0x61, 0xf2, 0x86, 0xd0, 0x89, 0xbc, 0x48, 0x33, 0x9c, 0xb0, 0xff, 0x83, 0x02, 0xd4, 0x30, 0x25, - 0x23, 0xdf, 0x88, 0xc7, 0x53, 0xdd, 0x70, 0xd9, 0x0f, 0xef, 0xce, 0xd2, 0xd5, 0xfe, 0x64, 0x65, - 0x25, 0xf0, 0xd5, 0x8b, 0x3b, 0x82, 0x78, 0x47, 0xf2, 0x86, 0xb4, 0x3a, 0xfb, 0x77, 0xe0, 0xab, - 0x57, 0x64, 0x40, 0xcf, 0x36, 0xaf, 0xe9, 0x97, 0xcc, 0x51, 0x1e, 0x34, 0x42, 0x04, 0xbf, 0x53, - 0xc0, 0xda, 0xc8, 0xa1, 0x18, 0x75, 0x1c, 0xb6, 0x3e, 0xb2, 0x97, 0x3b, 0x33, 0xa6, 0xf7, 0x65, - 0x4c, 0x4b, 0xc2, 0x9d, 0x9d, 0xd8, 0x09, 0x55, 0xf1, 0x76, 0xc8, 0x33, 0x51, 0x80, 0x57, 0xcd, - 0x64, 0x12, 0xf8, 0xb1, 0x02, 0x32, 0x14, 0xb9, 0x4d, 0x4c, 0x0d, 0x76, 0x06, 0xb2, 0xfb, 0x3b, - 0xc3, 0xb9, 0x3d, 0xe9, 0x1c, 0x94, 0x2f, 0x55, 0x84, 0x9d, 0xc8, 0x21, 0x20, 0x80, 0xbb, 0xb8, - 0x4e, 0xe1, 0xd7, 0x0a, 0x28, 0xc4, 0x3a, 0x00, 0x63, 0x38, 0xb5, 0xf0, 0xb6, 0x2f, 0xb3, 0xb5, - 0x56, 0x16, 0x73, 0x4d, 0x39, 0x9c, 0x6b, 0xca, 0x07, 0xa1, 0x86, 0x78, 0xb8, 0x02, 0x5f, 0x5d, - 0x89, 0x15, 0xc4, 0xa1, 0x34, 0x6a, 0x40, 0x13, 0xe9, 0xb5, 0x47, 0xbf, 0xaa, 0x8a, 0xbe, 0xd2, - 0x4a, 0x40, 0xc2, 0xf7, 0xf9, 0xe4, 0x41, 0x6c, 0x8a, 0x5d, 0x56, 0x85, 0x44, 0x03, 0x59, 0x5c, - 0xe0, 0x6d, 0xf8, 0xff, 0xc5, 0xe4, 0x51, 0x93, 0xc2, 0x37, 0xb8, 0x6c, 0xe0, 0xab, 0xc5, 0x61, - 0x13, 0xce, 0x70, 0x11, 0x8c, 0x0f, 0x1e, 0xa3, 0xda, 0xd0, 0x03, 0xab, 0x63, 0xe4, 0x06, 0xb2, - 0x2c, 0x17, 0x7b, 0x5e, 0x31, 0xcb, 0xb3, 0xfb, 0xe5, 0xc0, 0x57, 0x0b, 0xa3, 0xa0, 0x6d, 0xa1, - 0x10, 0x65, 0xc6, 0x29, 0x0c, 0x9a, 0x5e, 0x20, 0x49, 0x40, 0x66, 0x94, 0x95, 0xad, 0x24, 0xa3, - 0x4b, 0x91, 0xd1, 0xbd, 0xfe, 0x99, 0x46, 0x4f, 0x61, 0xd0, 0xf4, 0x02, 0x4e, 0x02, 0xc2, 0xaf, - 0x14, 0xb0, 0xdc, 0xc0, 0x58, 0x5e, 0x03, 0x96, 0x87, 0xd8, 0x64, 0x23, 0x4d, 0x8e, 0x5b, 0xfc, - 0x60, 0xb2, 0x67, 0x92, 0x45, 0xfe, 0x16, 0xc6, 0x2c, 0x87, 0x77, 0x42, 0xa6, 0x68, 0xca, 0x4a, - 0x30, 0xa3, 0xe9, 0xb9, 0xc6, 0x98, 0x3e, 0xfc, 0x54, 0x01, 0xf9, 0xba, 0x63, 0x77, 0x3d, 0xa9, - 0xdc, 0x24, 0x3d, 0x6c, 0x17, 0xf3, 0xdc, 0x9f, 0x77, 0x27, 0xf6, 0x67, 0xb1, 0xca, 0xa8, 0x98, - 0x85, 0xdb, 0x8c, 0x27, 0xca, 0x83, 0x13, 0x26, 0x34, 0x7d, 0xb1, 0x3e, 0xa2, 0x0b, 0xef, 0x83, - 0xc5, 0xe1, 0xb0, 0x2b, 0xda, 0x4b, 0xc8, 0xbd, 0xb8, 0xca, 0xde, 0xd4, 0xe1, 0x94, 0xcc, 0xba, - 0xca, 0xa8, 0x37, 0x1c, 0x05, 0x68, 0x7a, 0x96, 0xc4, 0xf5, 0x60, 0x0d, 0x2c, 0x84, 0x53, 0x16, - 0x27, 0x5c, 0xe6, 0x29, 0x7b, 0x85, 0x77, 0xd0, 0x62, 0x5d, 0xd2, 0x2d, 0xcb, 0x6e, 0x37, 0xa6, - 0xcc, 0x1a, 0xe8, 0x48, 0x07, 0xde, 0x06, 0x0b, 0x6c, 0x8a, 0x66, 0x25, 0xdd, 0x6c, 0x7b, 0xb4, - 0xb8, 0xc2, 0xa9, 0x2e, 0x07, 0xbe, 0x0a, 0x6a, 0x1e, 0xbb, 0xb9, 0x3b, 0x6d, 0x8f, 0x46, 0x4c, - 0x71, 0x5d, 0x4d, 0x07, 0x64, 0xa8, 0x02, 0xdf, 0x04, 0xcb, 0xb1, 0x7a, 0x38, 0x6c, 0xc2, 0x0b, - 0xa2, 0x7f, 0x88, 0xce, 0x2f, 0x41, 0x49, 0xd3, 0xf3, 0xd1, 0xaa, 0x6c, 0xd5, 0xe1, 0x2b, 0x20, - 0xcb, 0x2d, 0x0d, 0x99, 0xce, 0x73, 0xa6, 0x62, 0x34, 0x17, 0x8c, 0x88, 0x35, 0x3d, 0xc3, 0xbe, - 0x25, 0xba, 0xfa, 0xce, 0xe3, 0xdf, 0x4b, 0x53, 0xdf, 0x06, 0xa5, 0xa9, 0xc7, 0x41, 0x49, 0x79, - 0x12, 0x94, 0x94, 0xdf, 0x82, 0x92, 0xf2, 0xe8, 0x69, 0x69, 0xea, 0xc9, 0xd3, 0xd2, 0xd4, 0xcf, - 0x4f, 0x4b, 0x53, 0x0f, 0x6e, 0x8e, 0x1c, 0x3e, 0x9b, 0x50, 0xae, 0x3b, 0x8d, 0x06, 0x31, 0x09, - 0x6a, 0xc9, 0xef, 0xca, 0xf8, 0x1f, 0x6e, 0x78, 0x46, 0xd4, 0x67, 0x79, 0x85, 0xba, 0xf1, 0x57, - 0x00, 0x00, 0x00, 0xff, 0xff, 0x5d, 0x9f, 0xeb, 0xef, 0xdd, 0x11, 0x00, 0x00, -} - -func (m *LiquidationWhiteListing) 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 *LiquidationWhiteListing) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *LiquidationWhiteListing) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.KeeeperIncentive.Size() - i -= size - if _, err := m.KeeeperIncentive.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x5a - if m.EnglishAuctionParam != nil { - { - size, err := m.EnglishAuctionParam.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x52 - } - if m.IsEnglishActivated { - i-- - if m.IsEnglishActivated { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x48 - } - if m.DutchAuctionParam != nil { - { - size, err := m.DutchAuctionParam.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x42 - } - if m.IsDutchActivated { - i-- - if m.IsDutchActivated { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x38 - } - if m.Initiator { - i-- - if m.Initiator { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x30 - } - if m.AppId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *AppReserveFunds) 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 *AppReserveFunds) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AppReserveFunds) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.TokenQuantity.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if m.AssetId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.AssetId)) - i-- - dAtA[i] = 0x10 - } - if m.AppId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *AppReserveFundsTxData) 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 *AppReserveFundsTxData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AppReserveFundsTxData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.AssetTxData) > 0 { - for iNdEx := len(m.AssetTxData) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.AssetTxData[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if m.AppId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *AssetTxData) 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 *AssetTxData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *AssetTxData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size, err := m.TokenQuantity.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if len(m.TxType) > 0 { - i -= len(m.TxType) - copy(dAtA[i:], m.TxType) - i = encodeVarintLiquidate(dAtA, i, uint64(len(m.TxType))) - i-- - dAtA[i] = 0x12 - } - if m.AssetId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.AssetId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *DutchAuctionParam) 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 *DutchAuctionParam) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DutchAuctionParam) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.DecrementFactor.Size() - i -= size - if _, err := m.DecrementFactor.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - { - size := m.Discount.Size() - i -= size - if _, err := m.Discount.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - { - size := m.Premium.Size() - i -= size - if _, err := m.Premium.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - -func (m *EnglishAuctionParam) 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 *EnglishAuctionParam) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *EnglishAuctionParam) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - { - size := m.DecrementFactor.Size() - i -= size - if _, err := m.DecrementFactor.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - -func (m *LiquidationOffsetHolder) 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 *LiquidationOffsetHolder) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *LiquidationOffsetHolder) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.CurrentOffset != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.CurrentOffset)) - i-- - dAtA[i] = 0x10 - } - if m.AppId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *LockedVault) 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 *LockedVault) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *LockedVault) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.DebtAssetId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.DebtAssetId)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xb0 - } - if m.CollateralAssetId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.CollateralAssetId)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa8 - } - if m.IsDebtCmst { - i-- - if m.IsDebtCmst { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xa0 - } - if m.AuctionType { - i-- - if m.AuctionType { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x98 - } - if len(m.InitiatorType) > 0 { - i -= len(m.InitiatorType) - copy(dAtA[i:], m.InitiatorType) - i = encodeVarintLiquidate(dAtA, i, uint64(len(m.InitiatorType))) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x92 - } - { - size := m.BonusToBeGiven.Size() - i -= size - if _, err := m.BonusToBeGiven.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x8a - { - size := m.FeeToBeCollected.Size() - i -= size - if _, err := m.FeeToBeCollected.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0x82 - if len(m.ExternalKeeperAddress) > 0 { - i -= len(m.ExternalKeeperAddress) - copy(dAtA[i:], m.ExternalKeeperAddress) - i = encodeVarintLiquidate(dAtA, i, uint64(len(m.ExternalKeeperAddress))) - i-- - dAtA[i] = 0x7a - } - if len(m.InternalKeeperAddress) > 0 { - i -= len(m.InternalKeeperAddress) - copy(dAtA[i:], m.InternalKeeperAddress) - i = encodeVarintLiquidate(dAtA, i, uint64(len(m.InternalKeeperAddress))) - i-- - dAtA[i] = 0x6a - } - if m.IsInternalKeeper { - i-- - if m.IsInternalKeeper { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x60 - } - n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LiquidationTimestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LiquidationTimestamp):]) - if err5 != nil { - return 0, err5 - } - i -= n5 - i = encodeVarintLiquidate(dAtA, i, uint64(n5)) - i-- - dAtA[i] = 0x5a - { - size, err := m.TargetDebt.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x52 - { - size, err := m.CollateralToBeAuctioned.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x4a - { - size := m.CurrentCollaterlisationRatio.Size() - i -= size - if _, err := m.CurrentCollaterlisationRatio.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x42 - { - size, err := m.DebtToken.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x3a - { - size, err := m.CollateralToken.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintLiquidate(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x32 - if len(m.Owner) > 0 { - i -= len(m.Owner) - copy(dAtA[i:], m.Owner) - i = encodeVarintLiquidate(dAtA, i, uint64(len(m.Owner))) - i-- - dAtA[i] = 0x2a - } - if m.ExtendedPairId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.ExtendedPairId)) - i-- - dAtA[i] = 0x20 - } - if m.OriginalVaultId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.OriginalVaultId)) - i-- - dAtA[i] = 0x18 - } - if m.AppId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x10 - } - if m.LockedVaultId != 0 { - i = encodeVarintLiquidate(dAtA, i, uint64(m.LockedVaultId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func encodeVarintLiquidate(dAtA []byte, offset int, v uint64) int { - offset -= sovLiquidate(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *LiquidationWhiteListing) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AppId != 0 { - n += 1 + sovLiquidate(uint64(m.AppId)) - } - if m.Initiator { - n += 2 - } - if m.IsDutchActivated { - n += 2 - } - if m.DutchAuctionParam != nil { - l = m.DutchAuctionParam.Size() - n += 1 + l + sovLiquidate(uint64(l)) - } - if m.IsEnglishActivated { - n += 2 - } - if m.EnglishAuctionParam != nil { - l = m.EnglishAuctionParam.Size() - n += 1 + l + sovLiquidate(uint64(l)) - } - l = m.KeeeperIncentive.Size() - n += 1 + l + sovLiquidate(uint64(l)) - return n -} - -func (m *AppReserveFunds) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AppId != 0 { - n += 1 + sovLiquidate(uint64(m.AppId)) - } - if m.AssetId != 0 { - n += 1 + sovLiquidate(uint64(m.AssetId)) - } - l = m.TokenQuantity.Size() - n += 1 + l + sovLiquidate(uint64(l)) - return n -} - -func (m *AppReserveFundsTxData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AppId != 0 { - n += 1 + sovLiquidate(uint64(m.AppId)) - } - if len(m.AssetTxData) > 0 { - for _, e := range m.AssetTxData { - l = e.Size() - n += 1 + l + sovLiquidate(uint64(l)) - } - } - return n -} - -func (m *AssetTxData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AssetId != 0 { - n += 1 + sovLiquidate(uint64(m.AssetId)) - } - l = len(m.TxType) - if l > 0 { - n += 1 + l + sovLiquidate(uint64(l)) - } - l = m.TokenQuantity.Size() - n += 1 + l + sovLiquidate(uint64(l)) - return n -} - -func (m *DutchAuctionParam) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.Premium.Size() - n += 1 + l + sovLiquidate(uint64(l)) - l = m.Discount.Size() - n += 1 + l + sovLiquidate(uint64(l)) - l = m.DecrementFactor.Size() - n += 1 + l + sovLiquidate(uint64(l)) - return n -} - -func (m *EnglishAuctionParam) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.DecrementFactor.Size() - n += 1 + l + sovLiquidate(uint64(l)) - return n -} - -func (m *LiquidationOffsetHolder) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AppId != 0 { - n += 1 + sovLiquidate(uint64(m.AppId)) - } - if m.CurrentOffset != 0 { - n += 1 + sovLiquidate(uint64(m.CurrentOffset)) - } - return n -} - -func (m *LockedVault) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.LockedVaultId != 0 { - n += 1 + sovLiquidate(uint64(m.LockedVaultId)) - } - if m.AppId != 0 { - n += 1 + sovLiquidate(uint64(m.AppId)) - } - if m.OriginalVaultId != 0 { - n += 1 + sovLiquidate(uint64(m.OriginalVaultId)) - } - if m.ExtendedPairId != 0 { - n += 1 + sovLiquidate(uint64(m.ExtendedPairId)) - } - l = len(m.Owner) - if l > 0 { - n += 1 + l + sovLiquidate(uint64(l)) - } - l = m.CollateralToken.Size() - n += 1 + l + sovLiquidate(uint64(l)) - l = m.DebtToken.Size() - n += 1 + l + sovLiquidate(uint64(l)) - l = m.CurrentCollaterlisationRatio.Size() - n += 1 + l + sovLiquidate(uint64(l)) - l = m.CollateralToBeAuctioned.Size() - n += 1 + l + sovLiquidate(uint64(l)) - l = m.TargetDebt.Size() - n += 1 + l + sovLiquidate(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LiquidationTimestamp) - n += 1 + l + sovLiquidate(uint64(l)) - if m.IsInternalKeeper { - n += 2 - } - l = len(m.InternalKeeperAddress) - if l > 0 { - n += 1 + l + sovLiquidate(uint64(l)) - } - l = len(m.ExternalKeeperAddress) - if l > 0 { - n += 1 + l + sovLiquidate(uint64(l)) - } - l = m.FeeToBeCollected.Size() - n += 2 + l + sovLiquidate(uint64(l)) - l = m.BonusToBeGiven.Size() - n += 2 + l + sovLiquidate(uint64(l)) - l = len(m.InitiatorType) - if l > 0 { - n += 2 + l + sovLiquidate(uint64(l)) - } - if m.AuctionType { - n += 3 - } - if m.IsDebtCmst { - n += 3 - } - if m.CollateralAssetId != 0 { - n += 2 + sovLiquidate(uint64(m.CollateralAssetId)) - } - if m.DebtAssetId != 0 { - n += 2 + sovLiquidate(uint64(m.DebtAssetId)) - } - return n -} - -func sovLiquidate(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozLiquidate(x uint64) (n int) { - return sovLiquidate(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *LiquidationWhiteListing) 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 ErrIntOverflowLiquidate - } - 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: LiquidationWhiteListing: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LiquidationWhiteListing: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Initiator", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.Initiator = bool(v != 0) - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsDutchActivated", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IsDutchActivated = bool(v != 0) - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DutchAuctionParam", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.DutchAuctionParam == nil { - m.DutchAuctionParam = &DutchAuctionParam{} - } - if err := m.DutchAuctionParam.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 9: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsEnglishActivated", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IsEnglishActivated = bool(v != 0) - case 10: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EnglishAuctionParam", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.EnglishAuctionParam == nil { - m.EnglishAuctionParam = &EnglishAuctionParam{} - } - if err := m.EnglishAuctionParam.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 11: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field KeeeperIncentive", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.KeeeperIncentive.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipLiquidate(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLiquidate - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AppReserveFunds) 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 ErrIntOverflowLiquidate - } - 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: AppReserveFunds: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AppReserveFunds: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) - } - m.AssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TokenQuantity", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.TokenQuantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipLiquidate(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLiquidate - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AppReserveFundsTxData) 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 ErrIntOverflowLiquidate - } - 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: AppReserveFundsTxData: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AppReserveFundsTxData: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetTxData", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.AssetTxData = append(m.AssetTxData, AssetTxData{}) - if err := m.AssetTxData[len(m.AssetTxData)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipLiquidate(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLiquidate - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *AssetTxData) 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 ErrIntOverflowLiquidate - } - 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: AssetTxData: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: AssetTxData: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) - } - m.AssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TxType", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.TxType = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TokenQuantity", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.TokenQuantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipLiquidate(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLiquidate - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DutchAuctionParam) 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 ErrIntOverflowLiquidate - } - 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: DutchAuctionParam: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DutchAuctionParam: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Premium", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Premium.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Discount", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Discount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DecrementFactor", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.DecrementFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipLiquidate(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLiquidate - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *EnglishAuctionParam) 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 ErrIntOverflowLiquidate - } - 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: EnglishAuctionParam: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: EnglishAuctionParam: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DecrementFactor", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.DecrementFactor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipLiquidate(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLiquidate - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LiquidationOffsetHolder) 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 ErrIntOverflowLiquidate - } - 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: LiquidationOffsetHolder: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LiquidationOffsetHolder: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CurrentOffset", wireType) - } - m.CurrentOffset = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CurrentOffset |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipLiquidate(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLiquidate - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LockedVault) 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 ErrIntOverflowLiquidate - } - 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: LockedVault: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LockedVault: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LockedVaultId", wireType) - } - m.LockedVaultId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LockedVaultId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field OriginalVaultId", wireType) - } - m.OriginalVaultId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.OriginalVaultId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ExtendedPairId", wireType) - } - m.ExtendedPairId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.ExtendedPairId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Owner = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralToken", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.CollateralToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 7: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtToken", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.DebtToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CurrentCollaterlisationRatio", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.CurrentCollaterlisationRatio.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 9: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralToBeAuctioned", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.CollateralToBeAuctioned.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 10: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TargetDebt", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.TargetDebt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 11: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LiquidationTimestamp", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthLiquidate - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LiquidationTimestamp, dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 12: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsInternalKeeper", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IsInternalKeeper = bool(v != 0) - case 13: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InternalKeeperAddress", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.InternalKeeperAddress = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 15: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ExternalKeeperAddress", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ExternalKeeperAddress = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 16: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FeeToBeCollected", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.FeeToBeCollected.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 17: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field BonusToBeGiven", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.BonusToBeGiven.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 18: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field InitiatorType", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - 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 ErrInvalidLengthLiquidate - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthLiquidate - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.InitiatorType = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 19: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AuctionType", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.AuctionType = bool(v != 0) - case 20: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsDebtCmst", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IsDebtCmst = bool(v != 0) - case 21: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralAssetId", wireType) - } - m.CollateralAssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CollateralAssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 22: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtAssetId", wireType) - } - m.DebtAssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowLiquidate - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebtAssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipLiquidate(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthLiquidate - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipLiquidate(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowLiquidate - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowLiquidate - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowLiquidate - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthLiquidate - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupLiquidate - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthLiquidate - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthLiquidate = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowLiquidate = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupLiquidate = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/liquidation/v2types/params.pb.go b/x/liquidation/v2types/params.pb.go deleted file mode 100644 index 8c8951909..000000000 --- a/x/liquidation/v2types/params.pb.go +++ /dev/null @@ -1,302 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/liquidation/v2/params.proto - -package v2types - -import ( - fmt "fmt" - proto "github.com/gogo/protobuf/proto" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type Params struct { - LiquidationBatchSize uint64 `protobuf:"varint,1,opt,name=liquidation_batch_size,json=liquidationBatchSize,proto3" json:"liquidation_batch_size,omitempty"` -} - -func (m *Params) Reset() { *m = Params{} } -func (m *Params) String() string { return proto.CompactTextString(m) } -func (*Params) ProtoMessage() {} -func (*Params) Descriptor() ([]byte, []int) { - return fileDescriptor_67185986e5384794, []int{0} -} -func (m *Params) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Params.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 *Params) XXX_Merge(src proto.Message) { - xxx_messageInfo_Params.Merge(m, src) -} -func (m *Params) XXX_Size() int { - return m.Size() -} -func (m *Params) XXX_DiscardUnknown() { - xxx_messageInfo_Params.DiscardUnknown(m) -} - -var xxx_messageInfo_Params proto.InternalMessageInfo - -func (m *Params) GetLiquidationBatchSize() uint64 { - if m != nil { - return m.LiquidationBatchSize - } - return 0 -} - -func init() { - proto.RegisterType((*Params)(nil), "comdex.liquidation.v2.Params") -} - -func init() { - proto.RegisterFile("comdex/liquidation/v2/params.proto", fileDescriptor_67185986e5384794) -} - -var fileDescriptor_67185986e5384794 = []byte{ - // 178 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4a, 0xce, 0xcf, 0x4d, - 0x49, 0xad, 0xd0, 0xcf, 0xc9, 0x2c, 0x2c, 0xcd, 0x4c, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, - 0x33, 0xd2, 0x2f, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, - 0x85, 0xa8, 0xd1, 0x43, 0x52, 0xa3, 0x57, 0x66, 0xa4, 0x64, 0xc7, 0xc5, 0x16, 0x00, 0x56, 0x26, - 0x64, 0xc2, 0x25, 0x86, 0x24, 0x17, 0x9f, 0x94, 0x58, 0x92, 0x9c, 0x11, 0x5f, 0x9c, 0x59, 0x95, - 0x2a, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x12, 0x24, 0x82, 0x24, 0xeb, 0x04, 0x92, 0x0c, 0xce, 0xac, - 0x4a, 0x75, 0x0a, 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, - 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xf3, 0xf4, - 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x88, 0xdd, 0xba, 0xf9, 0x69, 0x69, - 0x99, 0xc9, 0x99, 0x89, 0x39, 0x50, 0xbe, 0x3e, 0xba, 0x8b, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, - 0xd8, 0xc0, 0x0e, 0x36, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x48, 0x45, 0xc6, 0x61, 0xd6, 0x00, - 0x00, 0x00, -} - -func (m *Params) 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 *Params) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.LiquidationBatchSize != 0 { - i = encodeVarintParams(dAtA, i, uint64(m.LiquidationBatchSize)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func encodeVarintParams(dAtA []byte, offset int, v uint64) int { - offset -= sovParams(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *Params) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.LiquidationBatchSize != 0 { - n += 1 + sovParams(uint64(m.LiquidationBatchSize)) - } - return n -} - -func sovParams(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozParams(x uint64) (n int) { - return sovParams(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *Params) 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 ErrIntOverflowParams - } - 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: Params: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LiquidationBatchSize", wireType) - } - m.LiquidationBatchSize = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowParams - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LiquidationBatchSize |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - default: - iNdEx = preIndex - skippy, err := skipParams(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthParams - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipParams(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowParams - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowParams - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowParams - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthParams - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupParams - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthParams - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthParams = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowParams = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupParams = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/liquidation/v2types/query.pb.go b/x/liquidation/v2types/query.pb.go deleted file mode 100644 index 104ef67f1..000000000 --- a/x/liquidation/v2types/query.pb.go +++ /dev/null @@ -1,530 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/liquidation/v2/query.proto - -package v2types - -import ( - context "context" - fmt "fmt" - _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" - _ "google.golang.org/genproto/googleapis/api/annotations" - grpc "google.golang.org/grpc" - codes "google.golang.org/grpc/codes" - status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type QueryParamsRequest struct { -} - -func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } -func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } -func (*QueryParamsRequest) ProtoMessage() {} -func (*QueryParamsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_3dcfcfd5101fa7f1, []int{0} -} -func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_QueryParamsRequest.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 *QueryParamsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryParamsRequest.Merge(m, src) -} -func (m *QueryParamsRequest) XXX_Size() int { - return m.Size() -} -func (m *QueryParamsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo - -type QueryParamsResponse struct { - Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` -} - -func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } -func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } -func (*QueryParamsResponse) ProtoMessage() {} -func (*QueryParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_3dcfcfd5101fa7f1, []int{1} -} -func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_QueryParamsResponse.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 *QueryParamsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_QueryParamsResponse.Merge(m, src) -} -func (m *QueryParamsResponse) XXX_Size() int { - return m.Size() -} -func (m *QueryParamsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo - -func (m *QueryParamsResponse) GetParams() Params { - if m != nil { - return m.Params - } - return Params{} -} - -func init() { - proto.RegisterType((*QueryParamsRequest)(nil), "comdex.liquidation.v2.QueryParamsRequest") - proto.RegisterType((*QueryParamsResponse)(nil), "comdex.liquidation.v2.QueryParamsResponse") -} - -func init() { proto.RegisterFile("comdex/liquidation/v2/query.proto", fileDescriptor_3dcfcfd5101fa7f1) } - -var fileDescriptor_3dcfcfd5101fa7f1 = []byte{ - // 280 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4c, 0xce, 0xcf, 0x4d, - 0x49, 0xad, 0xd0, 0xcf, 0xc9, 0x2c, 0x2c, 0xcd, 0x4c, 0x49, 0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x2f, - 0x33, 0xd2, 0x2f, 0x2c, 0x4d, 0x2d, 0xaa, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x85, - 0x28, 0xd1, 0x43, 0x52, 0xa2, 0x57, 0x66, 0x24, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, 0x56, 0xa1, - 0x0f, 0x62, 0x41, 0x14, 0x4b, 0xc9, 0xa4, 0xe7, 0xe7, 0xa7, 0xe7, 0xa4, 0xea, 0x27, 0x16, 0x64, - 0xea, 0x27, 0xe6, 0xe5, 0xe5, 0x97, 0x80, 0xd5, 0x17, 0x43, 0x65, 0x95, 0xb0, 0xdb, 0x56, 0x90, - 0x58, 0x94, 0x98, 0x0b, 0x55, 0xa3, 0x24, 0xc2, 0x25, 0x14, 0x08, 0xb2, 0x3d, 0x00, 0x2c, 0x18, - 0x94, 0x5a, 0x58, 0x9a, 0x5a, 0x5c, 0xa2, 0x14, 0xc4, 0x25, 0x8c, 0x22, 0x5a, 0x5c, 0x90, 0x9f, - 0x57, 0x9c, 0x2a, 0x64, 0xcd, 0xc5, 0x06, 0xd1, 0x2c, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x6d, 0x24, - 0xab, 0x87, 0xd5, 0xb1, 0x7a, 0x10, 0x6d, 0x4e, 0x2c, 0x27, 0xee, 0xc9, 0x33, 0x04, 0x41, 0xb5, - 0x18, 0x2d, 0x60, 0xe4, 0x62, 0x05, 0x1b, 0x2a, 0x34, 0x8d, 0x91, 0x8b, 0x0d, 0xa2, 0x44, 0x48, - 0x13, 0x87, 0x09, 0x98, 0x6e, 0x92, 0xd2, 0x22, 0x46, 0x29, 0xc4, 0xa1, 0x4a, 0xa6, 0x4d, 0x97, - 0x9f, 0x4c, 0x66, 0xd2, 0x17, 0xd2, 0xd5, 0x87, 0xe8, 0xd1, 0xcd, 0x4f, 0x4b, 0xcb, 0x4c, 0xce, - 0x4c, 0xcc, 0xd1, 0xc7, 0x17, 0x24, 0x4e, 0x81, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, - 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, - 0xc7, 0x10, 0x65, 0x9e, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0x04, 0x72, 0x02, 0x2e, 0x23, 0xd1, 0x0d, - 0x2d, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62, 0x03, 0x07, 0xb3, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, - 0xd5, 0xc7, 0x67, 0x30, 0xfa, 0x01, 0x00, 0x00, -} - -// 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 - -// QueryClient is the client API for Query service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type QueryClient interface { - Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) -} - -type queryClient struct { - cc grpc1.ClientConn -} - -func NewQueryClient(cc grpc1.ClientConn) QueryClient { - return &queryClient{cc} -} - -func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { - out := new(QueryParamsResponse) - err := c.cc.Invoke(ctx, "/comdex.liquidation.v2.Query/Params", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// QueryServer is the server API for Query service. -type QueryServer interface { - Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) -} - -// UnimplementedQueryServer can be embedded to have forward compatible implementations. -type UnimplementedQueryServer struct { -} - -func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") -} - -func RegisterQueryServer(s grpc1.Server, srv QueryServer) { - s.RegisterService(&_Query_serviceDesc, srv) -} - -func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(QueryParamsRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(QueryServer).Params(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.liquidation.v2.Query/Params", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) - } - return interceptor(ctx, in, info, handler) -} - -var _Query_serviceDesc = grpc.ServiceDesc{ - ServiceName: "comdex.liquidation.v2.Query", - HandlerType: (*QueryServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "Params", - Handler: _Query_Params_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "comdex/liquidation/v2/query.proto", -} - -func (m *QueryParamsRequest) 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 *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *QueryParamsResponse) 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 *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *QueryParamsResponse) 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 = encodeVarintQuery(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - return len(dAtA) - i, nil -} - -func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { - offset -= sovQuery(v) - base := offset - for v >= 1<<7 { - dAtA[offset] = uint8(v&0x7f | 0x80) - v >>= 7 - offset++ - } - dAtA[offset] = uint8(v) - return base -} -func (m *QueryParamsRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *QueryParamsResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = m.Params.Size() - n += 1 + l + sovQuery(uint64(l)) - return n -} - -func sovQuery(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 -} -func sozQuery(x uint64) (n int) { - return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) -} -func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQuery - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipQuery(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthQuery - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQuery - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowQuery - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthQuery - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthQuery - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipQuery(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthQuery - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipQuery(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQuery - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQuery - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowQuery - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthQuery - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupQuery - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthQuery - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") -) diff --git a/x/liquidation/v2types/query.pb.gw.go b/x/liquidation/v2types/query.pb.gw.go deleted file mode 100644 index 70313c703..000000000 --- a/x/liquidation/v2types/query.pb.gw.go +++ /dev/null @@ -1,153 +0,0 @@ -// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. -// source: comdex/liquidation/v2/query.proto - -/* -Package v2types is a reverse proxy. - -It translates gRPC into RESTful JSON APIs. -*/ -package v2types - -import ( - "context" - "io" - "net/http" - - "github.com/golang/protobuf/descriptor" - "github.com/golang/protobuf/proto" - "github.com/grpc-ecosystem/grpc-gateway/runtime" - "github.com/grpc-ecosystem/grpc-gateway/utilities" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/grpclog" - "google.golang.org/grpc/metadata" - "google.golang.org/grpc/status" -) - -// Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = descriptor.ForMessage -var _ = metadata.Join - -func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryParamsRequest - var metadata runtime.ServerMetadata - - msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) - return msg, metadata, err - -} - -func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq QueryParamsRequest - var metadata runtime.ServerMetadata - - msg, err := server.Params(ctx, &protoReq) - return msg, metadata, err - -} - -// RegisterQueryHandlerServer registers the http handlers for service Query to "mux". -// UnaryRPC :call QueryServer directly. -// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. -// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. -func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { - - mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - var stream runtime.ServerTransportStream - ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) - md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - return nil -} - -// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but -// automatically dials to "endpoint" and closes the connection when "ctx" gets done. -func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { - conn, err := grpc.Dial(endpoint, opts...) - if err != nil { - return err - } - defer func() { - if err != nil { - if cerr := conn.Close(); cerr != nil { - grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) - } - return - } - go func() { - <-ctx.Done() - if cerr := conn.Close(); cerr != nil { - grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) - } - }() - }() - - return RegisterQueryHandler(ctx, mux, conn) -} - -// RegisterQueryHandler registers the http handlers for service Query to "mux". -// The handlers forward requests to the grpc endpoint over "conn". -func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { - return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) -} - -// RegisterQueryHandlerClient registers the http handlers for service Query -// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". -// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" -// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "QueryClient" to call the correct interceptors. -func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { - - mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateContext(ctx, mux, req) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) - - }) - - return nil -} - -var ( - pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"comdex-official", "comdex", "liquidation", "v2", "params"}, "", runtime.AssumeColonVerbOpt(false))) -) - -var ( - forward_Query_Params_0 = runtime.ForwardResponseMessage -) diff --git a/x/liquidation/v2types/tx.pb.go b/x/liquidation/v2types/tx.pb.go deleted file mode 100644 index 66b93ece1..000000000 --- a/x/liquidation/v2types/tx.pb.go +++ /dev/null @@ -1,1598 +0,0 @@ -// Code generated by protoc-gen-gogo. DO NOT EDIT. -// source: comdex/liquidation/v2/tx.proto - -package v2types - -import ( - context "context" - fmt "fmt" - github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" - grpc "google.golang.org/grpc" - codes "google.golang.org/grpc/codes" - status "google.golang.org/grpc/status" - io "io" - math "math" - math_bits "math/bits" -) - -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package - -type MsgLiquidateInternalKeeperRequest struct { - From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"` - LiqType uint64 `protobuf:"varint,2,opt,name=liq_type,json=liqType,proto3" json:"liq_type,omitempty" yaml:"liq_type"` - Id uint64 `protobuf:"varint,3,opt,name=id,proto3" json:"id,omitempty" yaml:"id"` -} - -func (m *MsgLiquidateInternalKeeperRequest) Reset() { *m = MsgLiquidateInternalKeeperRequest{} } -func (m *MsgLiquidateInternalKeeperRequest) String() string { return proto.CompactTextString(m) } -func (*MsgLiquidateInternalKeeperRequest) ProtoMessage() {} -func (*MsgLiquidateInternalKeeperRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6183e44c40ceafc9, []int{0} -} -func (m *MsgLiquidateInternalKeeperRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgLiquidateInternalKeeperRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgLiquidateInternalKeeperRequest.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 *MsgLiquidateInternalKeeperRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgLiquidateInternalKeeperRequest.Merge(m, src) -} -func (m *MsgLiquidateInternalKeeperRequest) XXX_Size() int { - return m.Size() -} -func (m *MsgLiquidateInternalKeeperRequest) XXX_DiscardUnknown() { - xxx_messageInfo_MsgLiquidateInternalKeeperRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgLiquidateInternalKeeperRequest proto.InternalMessageInfo - -type MsgLiquidateInternalKeeperResponse struct { -} - -func (m *MsgLiquidateInternalKeeperResponse) Reset() { *m = MsgLiquidateInternalKeeperResponse{} } -func (m *MsgLiquidateInternalKeeperResponse) String() string { return proto.CompactTextString(m) } -func (*MsgLiquidateInternalKeeperResponse) ProtoMessage() {} -func (*MsgLiquidateInternalKeeperResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6183e44c40ceafc9, []int{1} -} -func (m *MsgLiquidateInternalKeeperResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgLiquidateInternalKeeperResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgLiquidateInternalKeeperResponse.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 *MsgLiquidateInternalKeeperResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgLiquidateInternalKeeperResponse.Merge(m, src) -} -func (m *MsgLiquidateInternalKeeperResponse) XXX_Size() int { - return m.Size() -} -func (m *MsgLiquidateInternalKeeperResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgLiquidateInternalKeeperResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgLiquidateInternalKeeperResponse proto.InternalMessageInfo - -type MsgAppReserveFundsRequest struct { - AppId uint64 `protobuf:"varint,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` - AssetId uint64 `protobuf:"varint,2,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty" yaml:"asset_id"` - TokenQuantity types.Coin `protobuf:"bytes,3,opt,name=token_quantity,json=tokenQuantity,proto3" json:"token_quantity"` - From string `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty" yaml:"from"` -} - -func (m *MsgAppReserveFundsRequest) Reset() { *m = MsgAppReserveFundsRequest{} } -func (m *MsgAppReserveFundsRequest) String() string { return proto.CompactTextString(m) } -func (*MsgAppReserveFundsRequest) ProtoMessage() {} -func (*MsgAppReserveFundsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6183e44c40ceafc9, []int{2} -} -func (m *MsgAppReserveFundsRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgAppReserveFundsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgAppReserveFundsRequest.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 *MsgAppReserveFundsRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgAppReserveFundsRequest.Merge(m, src) -} -func (m *MsgAppReserveFundsRequest) XXX_Size() int { - return m.Size() -} -func (m *MsgAppReserveFundsRequest) XXX_DiscardUnknown() { - xxx_messageInfo_MsgAppReserveFundsRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgAppReserveFundsRequest proto.InternalMessageInfo - -type MsgAppReserveFundsResponse struct { -} - -func (m *MsgAppReserveFundsResponse) Reset() { *m = MsgAppReserveFundsResponse{} } -func (m *MsgAppReserveFundsResponse) String() string { return proto.CompactTextString(m) } -func (*MsgAppReserveFundsResponse) ProtoMessage() {} -func (*MsgAppReserveFundsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6183e44c40ceafc9, []int{3} -} -func (m *MsgAppReserveFundsResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgAppReserveFundsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgAppReserveFundsResponse.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 *MsgAppReserveFundsResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgAppReserveFundsResponse.Merge(m, src) -} -func (m *MsgAppReserveFundsResponse) XXX_Size() int { - return m.Size() -} -func (m *MsgAppReserveFundsResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgAppReserveFundsResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgAppReserveFundsResponse proto.InternalMessageInfo - -type MsgLiquidateExternalKeeperRequest struct { - From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty" yaml:"from"` - AppId uint64 `protobuf:"varint,2,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty" yaml:"app_id"` - Owner string `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty" yaml:"owner"` - CollateralToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,4,opt,name=collateral_token,json=collateralToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"collateral_token" yaml:"collateral_token"` - DebtToken github_com_cosmos_cosmos_sdk_types.Coin `protobuf:"bytes,5,opt,name=debt_token,json=debtToken,proto3,casttype=github.com/cosmos/cosmos-sdk/types.Coin" json:"debt_token" yaml:"debt_token"` - CollateralAssetId uint64 `protobuf:"varint,6,opt,name=collateral_asset_id,json=collateralAssetId,proto3" json:"collateral_asset_id,omitempty" yaml:"collateral_asset_id"` - DebtAssetId uint64 `protobuf:"varint,7,opt,name=debt_asset_id,json=debtAssetId,proto3" json:"debt_asset_id,omitempty" yaml:"debt_asset_id"` - IsDebtCmst bool `protobuf:"varint,8,opt,name=isDebtCmst,proto3" json:"isDebtCmst,omitempty" yaml:"debt_asset_id"` -} - -func (m *MsgLiquidateExternalKeeperRequest) Reset() { *m = MsgLiquidateExternalKeeperRequest{} } -func (m *MsgLiquidateExternalKeeperRequest) String() string { return proto.CompactTextString(m) } -func (*MsgLiquidateExternalKeeperRequest) ProtoMessage() {} -func (*MsgLiquidateExternalKeeperRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_6183e44c40ceafc9, []int{4} -} -func (m *MsgLiquidateExternalKeeperRequest) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgLiquidateExternalKeeperRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgLiquidateExternalKeeperRequest.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 *MsgLiquidateExternalKeeperRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgLiquidateExternalKeeperRequest.Merge(m, src) -} -func (m *MsgLiquidateExternalKeeperRequest) XXX_Size() int { - return m.Size() -} -func (m *MsgLiquidateExternalKeeperRequest) XXX_DiscardUnknown() { - xxx_messageInfo_MsgLiquidateExternalKeeperRequest.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgLiquidateExternalKeeperRequest proto.InternalMessageInfo - -type MsgLiquidateExternalKeeperResponse struct { -} - -func (m *MsgLiquidateExternalKeeperResponse) Reset() { *m = MsgLiquidateExternalKeeperResponse{} } -func (m *MsgLiquidateExternalKeeperResponse) String() string { return proto.CompactTextString(m) } -func (*MsgLiquidateExternalKeeperResponse) ProtoMessage() {} -func (*MsgLiquidateExternalKeeperResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_6183e44c40ceafc9, []int{5} -} -func (m *MsgLiquidateExternalKeeperResponse) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *MsgLiquidateExternalKeeperResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_MsgLiquidateExternalKeeperResponse.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 *MsgLiquidateExternalKeeperResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgLiquidateExternalKeeperResponse.Merge(m, src) -} -func (m *MsgLiquidateExternalKeeperResponse) XXX_Size() int { - return m.Size() -} -func (m *MsgLiquidateExternalKeeperResponse) XXX_DiscardUnknown() { - xxx_messageInfo_MsgLiquidateExternalKeeperResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_MsgLiquidateExternalKeeperResponse proto.InternalMessageInfo - -func init() { - proto.RegisterType((*MsgLiquidateInternalKeeperRequest)(nil), "comdex.liquidation.v2.MsgLiquidateInternalKeeperRequest") - proto.RegisterType((*MsgLiquidateInternalKeeperResponse)(nil), "comdex.liquidation.v2.MsgLiquidateInternalKeeperResponse") - proto.RegisterType((*MsgAppReserveFundsRequest)(nil), "comdex.liquidation.v2.MsgAppReserveFundsRequest") - proto.RegisterType((*MsgAppReserveFundsResponse)(nil), "comdex.liquidation.v2.MsgAppReserveFundsResponse") - proto.RegisterType((*MsgLiquidateExternalKeeperRequest)(nil), "comdex.liquidation.v2.MsgLiquidateExternalKeeperRequest") - proto.RegisterType((*MsgLiquidateExternalKeeperResponse)(nil), "comdex.liquidation.v2.MsgLiquidateExternalKeeperResponse") -} - -func init() { proto.RegisterFile("comdex/liquidation/v2/tx.proto", fileDescriptor_6183e44c40ceafc9) } - -var fileDescriptor_6183e44c40ceafc9 = []byte{ - // 735 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x55, 0xbf, 0x52, 0xdb, 0x4e, - 0x10, 0xb6, 0x8c, 0x8d, 0xf1, 0xf1, 0xe3, 0x47, 0x10, 0x64, 0x62, 0x3c, 0x19, 0x89, 0x88, 0xcc, - 0x84, 0x06, 0x29, 0x76, 0x8a, 0x40, 0x26, 0x0d, 0x86, 0x30, 0x43, 0x02, 0xc9, 0x44, 0x43, 0x93, - 0x34, 0x9e, 0xb3, 0x75, 0x38, 0x37, 0xc8, 0x3a, 0x59, 0x77, 0x76, 0x70, 0x93, 0x36, 0x2d, 0x79, - 0x0b, 0x1e, 0x85, 0x92, 0x32, 0x95, 0x26, 0x11, 0x6f, 0xa0, 0x22, 0x45, 0xaa, 0xcc, 0xdd, 0xc9, - 0xd8, 0x18, 0x63, 0xfe, 0x54, 0xb6, 0x76, 0xf7, 0xdb, 0xdd, 0xef, 0xdb, 0x5d, 0x09, 0x68, 0x75, - 0xd2, 0x74, 0xd0, 0x91, 0xe5, 0xe2, 0x56, 0x1b, 0x3b, 0x90, 0x61, 0xe2, 0x59, 0x9d, 0xb2, 0xc5, - 0x8e, 0x4c, 0x3f, 0x20, 0x8c, 0xa8, 0x0f, 0xa5, 0xdf, 0x1c, 0xf0, 0x9b, 0x9d, 0x72, 0x71, 0xa1, - 0x41, 0x1a, 0x44, 0x44, 0x58, 0xfc, 0x9f, 0x0c, 0x2e, 0x6a, 0x75, 0x42, 0x9b, 0x84, 0x5a, 0x35, - 0x48, 0x91, 0xd5, 0x29, 0xd5, 0x10, 0x83, 0x25, 0xab, 0x4e, 0xb0, 0x27, 0xfd, 0xc6, 0x89, 0x02, - 0x9e, 0xec, 0xd1, 0xc6, 0x6e, 0x92, 0x0b, 0xed, 0x78, 0x0c, 0x05, 0x1e, 0x74, 0xdf, 0x21, 0xe4, - 0xa3, 0xc0, 0x46, 0xad, 0x36, 0xa2, 0x4c, 0x5d, 0x06, 0x99, 0x83, 0x80, 0x34, 0x0b, 0xca, 0x92, - 0xb2, 0x92, 0xaf, 0xcc, 0xc6, 0xa1, 0x3e, 0xdd, 0x85, 0x4d, 0xf7, 0x95, 0xc1, 0xad, 0x86, 0x2d, - 0x9c, 0xea, 0x3a, 0x98, 0x72, 0x71, 0xab, 0xca, 0xba, 0x3e, 0x2a, 0xa4, 0x97, 0x94, 0x95, 0x4c, - 0x45, 0x8b, 0x42, 0x3d, 0xb7, 0x8b, 0x5b, 0xfb, 0x5d, 0x1f, 0xc5, 0xa1, 0x3e, 0x2b, 0x31, 0xbd, - 0x20, 0xc3, 0xce, 0xb9, 0xd2, 0xa7, 0x2e, 0x83, 0x34, 0x76, 0x0a, 0x13, 0x02, 0x34, 0x1f, 0x85, - 0x7a, 0x7a, 0xc7, 0x89, 0x43, 0x3d, 0x2f, 0xe3, 0xb1, 0x63, 0xd8, 0x69, 0xec, 0x18, 0x4f, 0x81, - 0x31, 0xae, 0x53, 0xea, 0x13, 0x8f, 0x22, 0xe3, 0x8f, 0x02, 0x16, 0xf7, 0x68, 0x63, 0xc3, 0xf7, - 0x6d, 0x44, 0x51, 0xd0, 0x41, 0xdb, 0x6d, 0xcf, 0xa1, 0x3d, 0x22, 0x25, 0x30, 0x09, 0x7d, 0xbf, - 0x8a, 0x1d, 0x41, 0x25, 0x53, 0x29, 0x46, 0xa1, 0x9e, 0xdd, 0xf0, 0x7d, 0x51, 0x6f, 0x46, 0xd6, - 0x93, 0x01, 0x86, 0x9d, 0x85, 0xdc, 0xce, 0x69, 0x41, 0x4a, 0x11, 0xe3, 0xa0, 0x01, 0x5a, 0x1b, - 0xdc, 0x26, 0x60, 0x09, 0xad, 0x5e, 0x90, 0x61, 0xe7, 0xa0, 0xf4, 0xa9, 0xdb, 0xe0, 0x7f, 0x46, - 0x0e, 0x91, 0x57, 0x6d, 0xb5, 0xa1, 0xc7, 0x30, 0xeb, 0x0a, 0x8a, 0xd3, 0xe5, 0x45, 0x53, 0x4e, - 0xc5, 0xe4, 0x53, 0x31, 0x93, 0xa9, 0x98, 0x9b, 0x04, 0x7b, 0x95, 0xcc, 0x69, 0xa8, 0xa7, 0xec, - 0x19, 0x01, 0xfb, 0x98, 0xa0, 0x2e, 0xe4, 0xcf, 0x8c, 0x91, 0xdf, 0x78, 0x0c, 0x8a, 0xa3, 0x78, - 0x27, 0xb2, 0x7c, 0xcf, 0x5e, 0x9e, 0xf3, 0x9b, 0xa3, 0x7b, 0xcf, 0xb9, 0xaf, 0x61, 0xfa, 0xb6, - 0x1a, 0x5a, 0x20, 0x4b, 0xbe, 0x7a, 0x28, 0x10, 0xfc, 0xf3, 0x95, 0x45, 0x8e, 0xf8, 0xc0, 0x0d, - 0x71, 0xa8, 0xff, 0x27, 0x11, 0xc2, 0x6f, 0xd8, 0x32, 0x4e, 0x3d, 0x56, 0xc0, 0x83, 0x3a, 0x71, - 0x5d, 0xc8, 0x50, 0x00, 0xdd, 0xaa, 0x90, 0x43, 0xd0, 0x1f, 0x2b, 0xde, 0x5b, 0x2e, 0x5e, 0x1c, - 0xea, 0x8f, 0x64, 0xca, 0xe1, 0x04, 0xc6, 0xdf, 0x50, 0x7f, 0xd6, 0xc0, 0xec, 0x4b, 0xbb, 0x66, - 0xd6, 0x49, 0xd3, 0x4a, 0x4e, 0x43, 0xfe, 0xac, 0x52, 0xe7, 0xd0, 0xe2, 0x6b, 0x49, 0x45, 0x2e, - 0x7b, 0xb6, 0x8f, 0xde, 0xe7, 0x60, 0xf5, 0x1b, 0x00, 0x0e, 0xaa, 0xb1, 0xa4, 0x97, 0xec, 0x4d, - 0xbd, 0x6c, 0x25, 0xbd, 0xcc, 0xc9, 0x5e, 0xfa, 0xd0, 0x3b, 0x75, 0x91, 0xe7, 0x38, 0x59, 0xff, - 0x3d, 0x98, 0x1f, 0x20, 0x74, 0xb1, 0x92, 0x93, 0x72, 0x25, 0xe3, 0x50, 0x2f, 0x5e, 0x61, 0xdd, - 0x5f, 0xc9, 0xb9, 0xbe, 0x35, 0x59, 0x5c, 0xf5, 0x35, 0x98, 0x11, 0x4d, 0x5d, 0x64, 0xca, 0x89, - 0x4c, 0x85, 0x38, 0xd4, 0x17, 0x06, 0x7a, 0xee, 0xe7, 0x98, 0xe6, 0xcf, 0x3d, 0xf4, 0x1a, 0x00, - 0x98, 0x6e, 0xa1, 0x1a, 0xdb, 0x6c, 0x52, 0x56, 0x98, 0x5a, 0x52, 0x56, 0xa6, 0xc6, 0x40, 0x07, - 0x62, 0x87, 0xcf, 0x78, 0x78, 0x11, 0xe5, 0xbe, 0x96, 0x4f, 0x26, 0xc0, 0xc4, 0x1e, 0x6d, 0xa8, - 0x3f, 0x14, 0xb1, 0xd6, 0xd7, 0x5c, 0xbd, 0xba, 0x66, 0x8e, 0x7c, 0x19, 0x9a, 0x37, 0xbe, 0xd2, - 0x8a, 0xeb, 0xf7, 0x40, 0xca, 0xde, 0xd4, 0x2e, 0x50, 0xaf, 0x5e, 0x9a, 0xfa, 0xfc, 0xfa, 0x84, - 0xa3, 0x5f, 0x46, 0xc5, 0xd2, 0x1d, 0x10, 0x49, 0xe9, 0x61, 0x39, 0x2e, 0xab, 0x77, 0x2b, 0x39, - 0x46, 0x5e, 0xfe, 0xad, 0xe4, 0x18, 0x3d, 0xaa, 0xca, 0xa7, 0xd3, 0xdf, 0x5a, 0xea, 0x24, 0xd2, - 0x52, 0xa7, 0x91, 0xa6, 0x9c, 0x45, 0x9a, 0xf2, 0x2b, 0xd2, 0x94, 0xe3, 0x73, 0x2d, 0x75, 0x76, - 0xae, 0xa5, 0x7e, 0x9e, 0x6b, 0xa9, 0xcf, 0x2f, 0x2f, 0xad, 0x3b, 0x2f, 0xb3, 0x4a, 0x0e, 0x0e, - 0x70, 0x1d, 0x43, 0x37, 0x79, 0xb6, 0x86, 0x3f, 0x77, 0xe2, 0x06, 0x6a, 0x93, 0xe2, 0x23, 0xf5, - 0xe2, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfa, 0x4e, 0x84, 0x10, 0x13, 0x07, 0x00, 0x00, -} - -// 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 { - MsgLiquidateInternalKeeper(ctx context.Context, in *MsgLiquidateInternalKeeperRequest, opts ...grpc.CallOption) (*MsgLiquidateInternalKeeperResponse, error) - MsgAppReserveFunds(ctx context.Context, in *MsgAppReserveFundsRequest, opts ...grpc.CallOption) (*MsgAppReserveFundsResponse, error) - MsgLiquidateExternalKeeper(ctx context.Context, in *MsgLiquidateExternalKeeperRequest, opts ...grpc.CallOption) (*MsgLiquidateExternalKeeperResponse, error) -} - -type msgClient struct { - cc grpc1.ClientConn -} - -func NewMsgClient(cc grpc1.ClientConn) MsgClient { - return &msgClient{cc} -} - -func (c *msgClient) MsgLiquidateInternalKeeper(ctx context.Context, in *MsgLiquidateInternalKeeperRequest, opts ...grpc.CallOption) (*MsgLiquidateInternalKeeperResponse, error) { - out := new(MsgLiquidateInternalKeeperResponse) - err := c.cc.Invoke(ctx, "/comdex.liquidation.v2.Msg/MsgLiquidateInternalKeeper", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) MsgAppReserveFunds(ctx context.Context, in *MsgAppReserveFundsRequest, opts ...grpc.CallOption) (*MsgAppReserveFundsResponse, error) { - out := new(MsgAppReserveFundsResponse) - err := c.cc.Invoke(ctx, "/comdex.liquidation.v2.Msg/MsgAppReserveFunds", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -func (c *msgClient) MsgLiquidateExternalKeeper(ctx context.Context, in *MsgLiquidateExternalKeeperRequest, opts ...grpc.CallOption) (*MsgLiquidateExternalKeeperResponse, error) { - out := new(MsgLiquidateExternalKeeperResponse) - err := c.cc.Invoke(ctx, "/comdex.liquidation.v2.Msg/MsgLiquidateExternalKeeper", in, out, opts...) - if err != nil { - return nil, err - } - return out, nil -} - -// MsgServer is the server API for Msg service. -type MsgServer interface { - MsgLiquidateInternalKeeper(context.Context, *MsgLiquidateInternalKeeperRequest) (*MsgLiquidateInternalKeeperResponse, error) - MsgAppReserveFunds(context.Context, *MsgAppReserveFundsRequest) (*MsgAppReserveFundsResponse, error) - MsgLiquidateExternalKeeper(context.Context, *MsgLiquidateExternalKeeperRequest) (*MsgLiquidateExternalKeeperResponse, error) -} - -// UnimplementedMsgServer can be embedded to have forward compatible implementations. -type UnimplementedMsgServer struct { -} - -func (*UnimplementedMsgServer) MsgLiquidateInternalKeeper(ctx context.Context, req *MsgLiquidateInternalKeeperRequest) (*MsgLiquidateInternalKeeperResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MsgLiquidateInternalKeeper not implemented") -} -func (*UnimplementedMsgServer) MsgAppReserveFunds(ctx context.Context, req *MsgAppReserveFundsRequest) (*MsgAppReserveFundsResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MsgAppReserveFunds not implemented") -} -func (*UnimplementedMsgServer) MsgLiquidateExternalKeeper(ctx context.Context, req *MsgLiquidateExternalKeeperRequest) (*MsgLiquidateExternalKeeperResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method MsgLiquidateExternalKeeper not implemented") -} - -func RegisterMsgServer(s grpc1.Server, srv MsgServer) { - s.RegisterService(&_Msg_serviceDesc, srv) -} - -func _Msg_MsgLiquidateInternalKeeper_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgLiquidateInternalKeeperRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).MsgLiquidateInternalKeeper(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.liquidation.v2.Msg/MsgLiquidateInternalKeeper", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MsgLiquidateInternalKeeper(ctx, req.(*MsgLiquidateInternalKeeperRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_MsgAppReserveFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgAppReserveFundsRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).MsgAppReserveFunds(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.liquidation.v2.Msg/MsgAppReserveFunds", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MsgAppReserveFunds(ctx, req.(*MsgAppReserveFundsRequest)) - } - return interceptor(ctx, in, info, handler) -} - -func _Msg_MsgLiquidateExternalKeeper_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(MsgLiquidateExternalKeeperRequest) - if err := dec(in); err != nil { - return nil, err - } - if interceptor == nil { - return srv.(MsgServer).MsgLiquidateExternalKeeper(ctx, in) - } - info := &grpc.UnaryServerInfo{ - Server: srv, - FullMethod: "/comdex.liquidation.v2.Msg/MsgLiquidateExternalKeeper", - } - handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MsgServer).MsgLiquidateExternalKeeper(ctx, req.(*MsgLiquidateExternalKeeperRequest)) - } - return interceptor(ctx, in, info, handler) -} - -var _Msg_serviceDesc = grpc.ServiceDesc{ - ServiceName: "comdex.liquidation.v2.Msg", - HandlerType: (*MsgServer)(nil), - Methods: []grpc.MethodDesc{ - { - MethodName: "MsgLiquidateInternalKeeper", - Handler: _Msg_MsgLiquidateInternalKeeper_Handler, - }, - { - MethodName: "MsgAppReserveFunds", - Handler: _Msg_MsgAppReserveFunds_Handler, - }, - { - MethodName: "MsgLiquidateExternalKeeper", - Handler: _Msg_MsgLiquidateExternalKeeper_Handler, - }, - }, - Streams: []grpc.StreamDesc{}, - Metadata: "comdex/liquidation/v2/tx.proto", -} - -func (m *MsgLiquidateInternalKeeperRequest) 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 *MsgLiquidateInternalKeeperRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgLiquidateInternalKeeperRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Id != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.Id)) - i-- - dAtA[i] = 0x18 - } - if m.LiqType != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.LiqType)) - i-- - dAtA[i] = 0x10 - } - if len(m.From) > 0 { - i -= len(m.From) - copy(dAtA[i:], m.From) - i = encodeVarintTx(dAtA, i, uint64(len(m.From))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *MsgLiquidateInternalKeeperResponse) 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 *MsgLiquidateInternalKeeperResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgLiquidateInternalKeeperResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *MsgAppReserveFundsRequest) 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 *MsgAppReserveFundsRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgAppReserveFundsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.From) > 0 { - i -= len(m.From) - copy(dAtA[i:], m.From) - i = encodeVarintTx(dAtA, i, uint64(len(m.From))) - i-- - dAtA[i] = 0x22 - } - { - size, err := m.TokenQuantity.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1a - if m.AssetId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.AssetId)) - i-- - dAtA[i] = 0x10 - } - if m.AppId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - -func (m *MsgAppReserveFundsResponse) 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 *MsgAppReserveFundsResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgAppReserveFundsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - return len(dAtA) - i, nil -} - -func (m *MsgLiquidateExternalKeeperRequest) 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 *MsgLiquidateExternalKeeperRequest) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgLiquidateExternalKeeperRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.IsDebtCmst { - i-- - if m.IsDebtCmst { - dAtA[i] = 1 - } else { - dAtA[i] = 0 - } - i-- - dAtA[i] = 0x40 - } - if m.DebtAssetId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.DebtAssetId)) - i-- - dAtA[i] = 0x38 - } - if m.CollateralAssetId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.CollateralAssetId)) - i-- - dAtA[i] = 0x30 - } - { - size, err := m.DebtToken.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a - { - size, err := m.CollateralToken.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTx(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x22 - if len(m.Owner) > 0 { - i -= len(m.Owner) - copy(dAtA[i:], m.Owner) - i = encodeVarintTx(dAtA, i, uint64(len(m.Owner))) - i-- - dAtA[i] = 0x1a - } - if m.AppId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.AppId)) - i-- - dAtA[i] = 0x10 - } - if len(m.From) > 0 { - i -= len(m.From) - copy(dAtA[i:], m.From) - i = encodeVarintTx(dAtA, i, uint64(len(m.From))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *MsgLiquidateExternalKeeperResponse) 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 *MsgLiquidateExternalKeeperResponse) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *MsgLiquidateExternalKeeperResponse) 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 *MsgLiquidateInternalKeeperRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.From) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if m.LiqType != 0 { - n += 1 + sovTx(uint64(m.LiqType)) - } - if m.Id != 0 { - n += 1 + sovTx(uint64(m.Id)) - } - return n -} - -func (m *MsgLiquidateInternalKeeperResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *MsgAppReserveFundsRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.AppId != 0 { - n += 1 + sovTx(uint64(m.AppId)) - } - if m.AssetId != 0 { - n += 1 + sovTx(uint64(m.AssetId)) - } - l = m.TokenQuantity.Size() - n += 1 + l + sovTx(uint64(l)) - l = len(m.From) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n -} - -func (m *MsgAppReserveFundsResponse) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - return n -} - -func (m *MsgLiquidateExternalKeeperRequest) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.From) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - if m.AppId != 0 { - n += 1 + sovTx(uint64(m.AppId)) - } - l = len(m.Owner) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - l = m.CollateralToken.Size() - n += 1 + l + sovTx(uint64(l)) - l = m.DebtToken.Size() - n += 1 + l + sovTx(uint64(l)) - if m.CollateralAssetId != 0 { - n += 1 + sovTx(uint64(m.CollateralAssetId)) - } - if m.DebtAssetId != 0 { - n += 1 + sovTx(uint64(m.DebtAssetId)) - } - if m.IsDebtCmst { - n += 2 - } - return n -} - -func (m *MsgLiquidateExternalKeeperResponse) 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 *MsgLiquidateInternalKeeperRequest) 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: MsgLiquidateInternalKeeperRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgLiquidateInternalKeeperRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LiqType", wireType) - } - m.LiqType = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LiqType |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) - } - m.Id = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Id |= 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 *MsgLiquidateInternalKeeperResponse) 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: MsgLiquidateInternalKeeperResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgLiquidateInternalKeeperResponse: 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 *MsgAppReserveFundsRequest) 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: MsgAppReserveFundsRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgAppReserveFundsRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AssetId", wireType) - } - m.AssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TokenQuantity", 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 err := m.TokenQuantity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = 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 *MsgAppReserveFundsResponse) 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: MsgAppReserveFundsResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgAppReserveFundsResponse: 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 *MsgLiquidateExternalKeeperRequest) 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: MsgLiquidateExternalKeeperRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgLiquidateExternalKeeperRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field From", 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.From = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field AppId", wireType) - } - m.AppId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.AppId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralToken", 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 err := m.CollateralToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtToken", 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 err := m.DebtToken.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CollateralAssetId", wireType) - } - m.CollateralAssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CollateralAssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 7: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DebtAssetId", wireType) - } - m.DebtAssetId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.DebtAssetId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 8: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IsDebtCmst", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IsDebtCmst = bool(v != 0) - 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 *MsgLiquidateExternalKeeperResponse) 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: MsgLiquidateExternalKeeperResponse: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: MsgLiquidateExternalKeeperResponse: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTx - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func skipTx(dAtA []byte) (n int, err error) { - l := len(dAtA) - iNdEx := 0 - depth := 0 - for iNdEx < l { - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTx - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= (uint64(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - wireType := int(wire & 0x7) - switch wireType { - case 0: - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTx - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - iNdEx++ - if dAtA[iNdEx-1] < 0x80 { - break - } - } - case 1: - iNdEx += 8 - case 2: - var length int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return 0, ErrIntOverflowTx - } - if iNdEx >= l { - return 0, io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - length |= (int(b) & 0x7F) << shift - if b < 0x80 { - break - } - } - if length < 0 { - return 0, ErrInvalidLengthTx - } - iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupTx - } - depth-- - case 5: - iNdEx += 4 - default: - return 0, fmt.Errorf("proto: illegal wireType %d", wireType) - } - if iNdEx < 0 { - return 0, ErrInvalidLengthTx - } - if depth == 0 { - return iNdEx, nil - } - } - return 0, io.ErrUnexpectedEOF -} - -var ( - ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") -)