turtlebasket
/
gpu-compute-chain
mirror of https://github.com/colinear-labs/chain
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

scaffold CLR locking types / msg

master
michael 2022-09-07 20:25:57 +00:00
parent 33e576ca46
commit da45a14534
33 changed files with 1859 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
docs/static/openapi.yml vendored
View File

@ -4,6 +4,43 @@ info:
name: ''
description: ''
paths:
/colinear/colinearcore/locked_users:
get:
summary: Queries a LockedUsers by index.
operationId: ColinearColinearcoreLockedUsers
responses:
'200':
description: A successful response.
schema:
type: object
properties:
LockedUsers:
type: object
properties:
users:
type: object
additionalProperties:
type: string
default:
description: An unexpected error response.
schema:
type: object
properties:
code:
type: integer
format: int32
message:
type: string
details:
type: array
items:
type: object
properties:
'@type':
type: string
additionalProperties: {}
tags:
- Query
/colinearcore/colinearcore/auction:
get:
summary: Queries a list of Auction items.
@ -141,16 +178,6 @@ paths:
in: query
required: false
type: boolean
- name: pagination.reverse
description: >-
reverse is set to true if results are to be returned in the
descending order.
Since: cosmos-sdk 0.43
in: query
required: false
type: boolean
tags:
- Query
'/colinearcore/colinearcore/auction/{index}':
@ -30746,6 +30773,15 @@ definitions:
type: string
amount:
type: string
colinear.colinearcore.LockedUsers:
type: object
properties:
users:
type: object
additionalProperties:
type: string
colinear.colinearcore.MsgLockFundsResponse:
type: object
colinear.colinearcore.MsgNewAuctionResponse:
type: object
properties:
@ -30873,6 +30909,16 @@ definitions:
format: uint64
remaining:
type: string
colinear.colinearcore.QueryGetLockedUsersResponse:
type: object
properties:
LockedUsers:
type: object
properties:
users:
type: object
additionalProperties:
type: string
colinear.colinearcore.QueryGetNextAuctionResponse:
type: object
properties:

2
proto/colinearcore/genesis.proto
View File

@ -5,6 +5,7 @@ import "gogoproto/gogo.proto";
import "colinearcore/params.proto";
import "colinearcore/next_auction.proto";
import "colinearcore/auction.proto";
import "colinearcore/locked_users.proto";
// this line is used by starport scaffolding # genesis/proto/import
option go_package = "colinear/x/colinearcore/types";
@ -14,5 +15,6 @@ message GenesisState {
Params params = 1 [(gogoproto.nullable) = false];
NextAuction nextAuction = 2;
repeated Auction auctionList = 3 [(gogoproto.nullable) = false];
LockedUsers lockedUsers = 4;
// this line is used by starport scaffolding # genesis/proto/state
}

8
proto/colinearcore/locked_users.proto Normal file
View File

@ -0,0 +1,8 @@
syntax = "proto3";
package colinear.colinearcore;
option go_package = "colinear/x/colinearcore/types";
message LockedUsers {
map<string,string> users = 1;
}

10
proto/colinearcore/query.proto
View File

@ -8,6 +8,7 @@ import "colinearcore/params.proto";
import "colinearcore/next_auction.proto";
import "colinearcore/auction.proto";
import "colinearcore/bid.proto";
import "colinearcore/locked_users.proto";
// this line is used by starport scaffolding # 1
option go_package = "colinear/x/colinearcore/types";
@ -37,6 +38,10 @@ service Query {
option (google.api.http).get = "/colinearcore/colinearcore/auction_bids/{index}";
}
// Queries a LockedUsers by index.
rpc LockedUsers(QueryGetLockedUsersRequest) returns (QueryGetLockedUsersResponse) {
option (google.api.http).get = "/colinear/colinearcore/locked_users";
}
// this line is used by starport scaffolding # 2
}
@ -80,4 +85,9 @@ message QueryAuctionBidsResponse {
repeated Bid bids = 1;
}
message QueryGetLockedUsersRequest {}
message QueryGetLockedUsersResponse {
LockedUsers LockedUsers = 1 [(gogoproto.nullable) = false];
}
// this line is used by starport scaffolding # 3

8
proto/colinearcore/tx.proto
View File

@ -9,6 +9,7 @@ option go_package = "colinear/x/colinearcore/types";
service Msg {
rpc NewAuction(MsgNewAuction) returns (MsgNewAuctionResponse);
rpc NewBid(MsgNewBid) returns (MsgNewBidResponse);
rpc LockFunds(MsgLockFunds) returns (MsgLockFundsResponse);
// this line is used by starport scaffolding # proto/tx/rpc
}
@ -34,4 +35,11 @@ message MsgNewBid {
message MsgNewBidResponse {
}
message MsgLockFunds {
string creator = 1;
}
message MsgLockFundsResponse {
}
// this line is used by starport scaffolding # proto/tx/message

9
x/colinearcore/auctionconfig/config.go
View File

@ -8,6 +8,15 @@ const (
MinLeasePeriod = 3_600 // 1 hour
MaxLeasePeriod = 8_035_200 // 3 months
// Minimum required staked CLR to be a provider (i.e. to bid)
ProviderMinLockedClr = 500
// Amount slashed when a provider is offline during an audit
ProviderLockedSlash = 100
// Blocks between provider audit pings
// 40 blocks ~40min-2hr
ProviderPingFrequency = 40
// Gas Fees
AuctionGas = 10
)

1
x/colinearcore/client/cli/query.go
View File

@ -30,6 +30,7 @@ func GetQueryCmd(queryRoute string) *cobra.Command {
cmd.AddCommand(CmdShowAuction())
cmd.AddCommand(CmdAuctionBids())
cmd.AddCommand(CmdShowLockedUsers())
// this line is used by starport scaffolding # 1
return cmd

36
x/colinearcore/client/cli/query_locked_users.go Normal file
View File

@ -0,0 +1,36 @@
package cli
import (
"context"
"colinear/x/colinearcore/types"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/spf13/cobra"
)
func CmdShowLockedUsers() *cobra.Command {
cmd := &cobra.Command{
Use: "show-locked-users",
Short: "shows lockedUsers",
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx := client.GetClientContextFromCmd(cmd)
queryClient := types.NewQueryClient(clientCtx)
params := &types.QueryGetLockedUsersRequest{}
res, err := queryClient.LockedUsers(context.Background(), params)
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
return cmd
}

72
x/colinearcore/client/cli/query_locked_users_test.go Normal file
View File

@ -0,0 +1,72 @@
package cli_test
import (
"fmt"
"testing"
clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli"
"github.com/stretchr/testify/require"
tmcli "github.com/tendermint/tendermint/libs/cli"
"google.golang.org/grpc/status"
"colinear/testutil/network"
"colinear/testutil/nullify"
"colinear/x/colinearcore/client/cli"
"colinear/x/colinearcore/types"
)
func networkWithLockedUsersObjects(t *testing.T) (*network.Network, types.LockedUsers) {
t.Helper()
cfg := network.DefaultConfig()
state := types.GenesisState{}
require.NoError(t, cfg.Codec.UnmarshalJSON(cfg.GenesisState[types.ModuleName], &state))
lockedUsers := &types.LockedUsers{}
nullify.Fill(&lockedUsers)
state.LockedUsers = lockedUsers
buf, err := cfg.Codec.MarshalJSON(&state)
require.NoError(t, err)
cfg.GenesisState[types.ModuleName] = buf
return network.New(t, cfg), *state.LockedUsers
}
func TestShowLockedUsers(t *testing.T) {
net, obj := networkWithLockedUsersObjects(t)
ctx := net.Validators[0].ClientCtx
common := []string{
fmt.Sprintf("--%s=json", tmcli.OutputFlag),
}
for _, tc := range []struct {
desc string
args []string
err error
obj types.LockedUsers
}{
{
desc: "get",
args: common,
obj: obj,
},
} {
t.Run(tc.desc, func(t *testing.T) {
var args []string
args = append(args, tc.args...)
out, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdShowLockedUsers(), args)
if tc.err != nil {
stat, ok := status.FromError(tc.err)
require.True(t, ok)
require.ErrorIs(t, stat.Err(), tc.err)
} else {
require.NoError(t, err)
var resp types.QueryGetLockedUsersResponse
require.NoError(t, net.Config.Codec.UnmarshalJSON(out.Bytes(), &resp))
require.NotNil(t, resp.LockedUsers)
require.Equal(t,
nullify.Fill(&tc.obj),
nullify.Fill(&resp.LockedUsers),
)
}
})
}
}

1
x/colinearcore/client/cli/tx.go
View File

@ -32,6 +32,7 @@ func GetTxCmd() *cobra.Command {
cmd.AddCommand(CmdNewAuction())
cmd.AddCommand(CmdNewBid())
cmd.AddCommand(CmdLockFunds())
// this line is used by starport scaffolding # 1
return cmd

40
x/colinearcore/client/cli/tx_lock_funds.go Normal file
View File

@ -0,0 +1,40 @@
package cli
import (
"strconv"
"colinear/x/colinearcore/types"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/client/tx"
"github.com/spf13/cobra"
)
var _ = strconv.Itoa(0)
func CmdLockFunds() *cobra.Command {
cmd := &cobra.Command{
Use: "lock-funds",
Short: "Broadcast message lockFunds",
Args: cobra.ExactArgs(0),
RunE: func(cmd *cobra.Command, args []string) (err error) {
clientCtx, err := client.GetClientTxContext(cmd)
if err != nil {
return err
}
msg := types.NewMsgLockFunds(
clientCtx.GetFromAddress().String(),
)
if err := msg.ValidateBasic(); err != nil {
return err
}
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
},
}
flags.AddTxFlagsToCmd(cmd)
return cmd
}

9
x/colinearcore/genesis.go
View File

@ -18,6 +18,10 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState)
for _, elem := range genState.AuctionList {
k.SetAuction(ctx, elem)
}
// Set if defined
if genState.LockedUsers != nil {
k.SetLockedUsers(ctx, *genState.LockedUsers)
}
// this line is used by starport scaffolding # genesis/module/init
k.SetParams(ctx, genState.Params)
}
@ -33,6 +37,11 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState {
genesis.NextAuction = &nextAuction
}
genesis.AuctionList = k.GetAllAuction(ctx)
// Get all lockedUsers
lockedUsers, found := k.GetLockedUsers(ctx)
if found {
genesis.LockedUsers = &lockedUsers
}
// this line is used by starport scaffolding # genesis/module/export
return genesis

4
x/colinearcore/genesis_test.go
View File

@ -26,6 +26,9 @@ func TestGenesis(t *testing.T) {
Index: "1",
},
},
LockedUsers: &types.LockedUsers{
Users: map[string]string{},
},
// this line is used by starport scaffolding # genesis/test/state
}
@ -39,5 +42,6 @@ func TestGenesis(t *testing.T) {
require.Equal(t, genesisState.NextAuction, got.NextAuction)
require.ElementsMatch(t, genesisState.AuctionList, got.AuctionList)
require.Equal(t, genesisState.LockedUsers, got.LockedUsers)
// this line is used by starport scaffolding # genesis/test/assert
}

3
x/colinearcore/handler.go
View File

@ -24,6 +24,9 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
case *types.MsgNewBid:
res, err := msgServer.NewBid(sdk.WrapSDKContext(ctx), msg)
return sdk.WrapServiceResult(ctx, res, err)
case *types.MsgLockFunds:
res, err := msgServer.LockFunds(sdk.WrapSDKContext(ctx), msg)
return sdk.WrapServiceResult(ctx, res, err)
// this line is used by starport scaffolding # 1
default:
errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg)

24
x/colinearcore/keeper/grpc_query_locked_users.go Normal file
View File

@ -0,0 +1,24 @@
package keeper
import (
"context"
"colinear/x/colinearcore/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (k Keeper) LockedUsers(c context.Context, req *types.QueryGetLockedUsersRequest) (*types.QueryGetLockedUsersResponse, error) {
if req == nil {
return nil, status.Error(codes.InvalidArgument, "invalid request")
}
ctx := sdk.UnwrapSDKContext(c)
val, found := k.GetLockedUsers(ctx)
if !found {
return nil, status.Error(codes.NotFound, "not found")
}
return &types.QueryGetLockedUsersResponse{LockedUsers: val}, nil
}

49
x/colinearcore/keeper/grpc_query_locked_users_test.go Normal file
View File

@ -0,0 +1,49 @@
package keeper_test
import (
"testing"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/require"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
keepertest "colinear/testutil/keeper"
"colinear/testutil/nullify"
"colinear/x/colinearcore/types"
)
func TestLockedUsersQuery(t *testing.T) {
keeper, ctx := keepertest.ColinearcoreKeeper(t)
wctx := sdk.WrapSDKContext(ctx)
item := createTestLockedUsers(keeper, ctx)
for _, tc := range []struct {
desc string
request *types.QueryGetLockedUsersRequest
response *types.QueryGetLockedUsersResponse
err error
}{
{
desc: "First",
request: &types.QueryGetLockedUsersRequest{},
response: &types.QueryGetLockedUsersResponse{LockedUsers: item},
},
{
desc: "InvalidRequest",
err: status.Error(codes.InvalidArgument, "invalid request"),
},
} {
t.Run(tc.desc, func(t *testing.T) {
response, err := keeper.LockedUsers(wctx, tc.request)
if tc.err != nil {
require.ErrorIs(t, err, tc.err)
} else {
require.NoError(t, err)
require.Equal(t,
nullify.Fill(tc.response),
nullify.Fill(response),
)
}
})
}
}

33
x/colinearcore/keeper/locked_users.go Normal file
View File

@ -0,0 +1,33 @@
package keeper
import (
"colinear/x/colinearcore/types"
"github.com/cosmos/cosmos-sdk/store/prefix"
sdk "github.com/cosmos/cosmos-sdk/types"
)
// SetLockedUsers set lockedUsers in the store
func (k Keeper) SetLockedUsers(ctx sdk.Context, lockedUsers types.LockedUsers) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.LockedUsersKey))
b := k.cdc.MustMarshal(&lockedUsers)
store.Set([]byte{0}, b)
}
// GetLockedUsers returns lockedUsers
func (k Keeper) GetLockedUsers(ctx sdk.Context) (val types.LockedUsers, found bool) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.LockedUsersKey))
b := store.Get([]byte{0})
if b == nil {
return val, false
}
k.cdc.MustUnmarshal(b, &val)
return val, true
}
// RemoveLockedUsers removes lockedUsers from the store
func (k Keeper) RemoveLockedUsers(ctx sdk.Context) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.LockedUsersKey))
store.Delete([]byte{0})
}

38
x/colinearcore/keeper/locked_users_test.go Normal file
View File

@ -0,0 +1,38 @@
package keeper_test
import (
"testing"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/require"
keepertest "colinear/testutil/keeper"
"colinear/testutil/nullify"
"colinear/x/colinearcore/keeper"
"colinear/x/colinearcore/types"
)
func createTestLockedUsers(keeper *keeper.Keeper, ctx sdk.Context) types.LockedUsers {
item := types.LockedUsers{}
keeper.SetLockedUsers(ctx, item)
return item
}
func TestLockedUsersGet(t *testing.T) {
keeper, ctx := keepertest.ColinearcoreKeeper(t)
item := createTestLockedUsers(keeper, ctx)
rst, found := keeper.GetLockedUsers(ctx)
require.True(t, found)
require.Equal(t,
nullify.Fill(&item),
nullify.Fill(&rst),
)
}
func TestLockedUsersRemove(t *testing.T) {
keeper, ctx := keepertest.ColinearcoreKeeper(t)
createTestLockedUsers(keeper, ctx)
keeper.RemoveLockedUsers(ctx)
_, found := keeper.GetLockedUsers(ctx)
require.False(t, found)
}

18
x/colinearcore/keeper/msg_server_lock_funds.go Normal file
View File

@ -0,0 +1,18 @@
package keeper
import (
"context"
"colinear/x/colinearcore/types"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func (k msgServer) LockFunds(goCtx context.Context, msg *types.MsgLockFunds) (*types.MsgLockFundsResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
// TODO
_ = ctx
return &types.MsgLockFundsResponse{}, nil
}

5
x/colinearcore/keeper/msg_server_new_bid.go
View File

@ -62,6 +62,8 @@ func (k msgServer) NewBid(goCtx context.Context, msg *types.MsgNewBid) (*types.M
}
}
// check that user has locked minimum required CLR
bid := &types.Bid{
Amount: msg.Amount,
Owner: msg.Creator,
@ -71,8 +73,5 @@ func (k msgServer) NewBid(goCtx context.Context, msg *types.MsgNewBid) (*types.M
return nil, fmt.Errorf("failed to add bid: %s", err)
}
// auction.Bids = append(auction.Bids, bid)
// k.Keeper.SetAuction(ctx, auction)
return &types.MsgNewBidResponse{}, nil
}

23
x/colinearcore/module_simulation.go
View File

@ -4,7 +4,7 @@ import (
"math/rand"
"colinear/testutil/sample"
colinearsimulation "colinear/x/colinearcore/simulation"
colinearcoresimulation "colinear/x/colinearcore/simulation"
"colinear/x/colinearcore/types"
"github.com/cosmos/cosmos-sdk/baseapp"
@ -18,7 +18,7 @@ import (
// avoid unused import issue
var (
_ = sample.AccAddress
_ = colinearsimulation.FindAccount
_ = colinearcoresimulation.FindAccount
_ = simappparams.StakePerAccount
_ = simulation.MsgEntryKind
_ = baseapp.Paramspace
@ -33,6 +33,10 @@ const (
// TODO: Determine the simulation weight value
defaultWeightMsgNewBid int = 100
opWeightMsgLockFunds = "op_weight_msg_lock_funds"
// TODO: Determine the simulation weight value
defaultWeightMsgLockFunds int = 100
// this line is used by starport scaffolding # simapp/module/const
)
@ -75,7 +79,7 @@ func (am AppModule) WeightedOperations(simState module.SimulationState) []simtyp
)
operations = append(operations, simulation.NewWeightedOperation(
weightMsgNewAuction,
colinearsimulation.SimulateMsgNewAuction(am.accountKeeper, am.bankKeeper, am.keeper),
colinearcoresimulation.SimulateMsgNewAuction(am.accountKeeper, am.bankKeeper, am.keeper),
))
var weightMsgNewBid int
@ -86,7 +90,18 @@ func (am AppModule) WeightedOperations(simState module.SimulationState) []simtyp
)
operations = append(operations, simulation.NewWeightedOperation(
weightMsgNewBid,
colinearsimulation.SimulateMsgNewBid(am.accountKeeper, am.bankKeeper, am.keeper),
colinearcoresimulation.SimulateMsgNewBid(am.accountKeeper, am.bankKeeper, am.keeper),
))
var weightMsgLockFunds int
simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgLockFunds, &weightMsgLockFunds, nil,
func(_ *rand.Rand) {
weightMsgLockFunds = defaultWeightMsgLockFunds
},
)
operations = append(operations, simulation.NewWeightedOperation(
weightMsgLockFunds,
colinearcoresimulation.SimulateMsgLockFunds(am.accountKeeper, am.bankKeeper, am.keeper),
))
// this line is used by starport scaffolding # simapp/module/operation

29
x/colinearcore/simulation/lock_funds.go Normal file
View File

@ -0,0 +1,29 @@
package simulation
import (
"math/rand"
"colinear/x/colinearcore/keeper"
"colinear/x/colinearcore/types"
"github.com/cosmos/cosmos-sdk/baseapp"
sdk "github.com/cosmos/cosmos-sdk/types"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
)
func SimulateMsgLockFunds(
ak types.AccountKeeper,
bk types.BankKeeper,
k keeper.Keeper,
) simtypes.Operation {
return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string,
) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
simAccount, _ := simtypes.RandomAcc(r, accs)
msg := &types.MsgLockFunds{
Creator: simAccount.Address.String(),
}
// TODO: Handling the LockFunds simulation
return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "LockFunds simulation not implemented"), nil, nil
}
}

4
x/colinearcore/types/codec.go
View File

@ -10,6 +10,7 @@ import (
func RegisterCodec(cdc *codec.LegacyAmino) {
cdc.RegisterConcrete(&MsgNewAuction{}, "colinear/NewAuction", nil)
cdc.RegisterConcrete(&MsgNewBid{}, "colinear/NewBid", nil)
cdc.RegisterConcrete(&MsgLockFunds{}, "colinearcore/LockFunds", nil)
// this line is used by starport scaffolding # 2
}
@ -20,6 +21,9 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
registry.RegisterImplementations((*sdk.Msg)(nil),
&MsgNewBid{},
)
registry.RegisterImplementations((*sdk.Msg)(nil),
&MsgLockFunds{},
)
// this line is used by starport scaffolding # 3
msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)

1
x/colinearcore/types/genesis.go
View File

@ -12,6 +12,7 @@ func DefaultGenesis() *GenesisState {
return &GenesisState{
NextAuction: &NextAuction{AuctionId: 0},
AuctionList: []Auction{},
LockedUsers: nil,
// this line is used by starport scaffolding # genesis/types/default
Params: DefaultParams(),
}

86
x/colinearcore/types/genesis.pb.go
View File

@ -28,6 +28,7 @@ type GenesisState struct {
Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
NextAuction *NextAuction `protobuf:"bytes,2,opt,name=nextAuction,proto3" json:"nextAuction,omitempty"`
AuctionList []Auction `protobuf:"bytes,3,rep,name=auctionList,proto3" json:"auctionList"`
LockedUsers *LockedUsers `protobuf:"bytes,4,opt,name=lockedUsers,proto3" json:"lockedUsers,omitempty"`
}
func (m *GenesisState) Reset() { *m = GenesisState{} }
@ -84,6 +85,13 @@ func (m *GenesisState) GetAuctionList() []Auction {
return nil
}
func (m *GenesisState) GetLockedUsers() *LockedUsers {
if m != nil {
return m.LockedUsers
}
return nil
}
func init() {
proto.RegisterType((*GenesisState)(nil), "colinear.colinearcore.GenesisState")
}
@ -91,23 +99,25 @@ func init() {
func init() { proto.RegisterFile("colinearcore/genesis.proto", fileDescriptor_bc4df5b37e28503f) }
var fileDescriptor_bc4df5b37e28503f = []byte{
// 247 bytes of a gzipped FileDescriptorProto
// 281 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0xce, 0xcf, 0xc9,
0xcc, 0x4b, 0x4d, 0x2c, 0x4a, 0xce, 0x2f, 0x4a, 0xd5, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c,
0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x85, 0xc9, 0xe9, 0x21, 0x2b, 0x92, 0x12, 0x49,
0xcf, 0x4f, 0xcf, 0x07, 0xab, 0xd0, 0x07, 0xb1, 0x20, 0x8a, 0xa5, 0x24, 0x51, 0x0c, 0x2a, 0x48,
0x2c, 0x4a, 0xcc, 0x85, 0x9a, 0x23, 0x25, 0x8f, 0x22, 0x95, 0x97, 0x5a, 0x51, 0x12, 0x9f, 0x58,
0x9a, 0x5c, 0x92, 0x99, 0x9f, 0x07, 0x55, 0x80, 0xea, 0x08, 0x14, 0x39, 0xa5, 0x9b, 0x8c, 0x5c,
0x3c, 0xee, 0x10, 0x67, 0x05, 0x97, 0x24, 0x96, 0xa4, 0x0a, 0x59, 0x73, 0xb1, 0x41, 0x4c, 0x97,
0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd5, 0xc3, 0xea, 0x4c, 0xbd, 0x00, 0xb0, 0x22, 0x27,
0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xa0, 0x5a, 0x84, 0x5c, 0xb8, 0xb8, 0x41, 0xf6, 0x3b, 0x42,
0xac, 0x90, 0x60, 0x02, 0x9b, 0xa0, 0x84, 0xc3, 0x04, 0x3f, 0x84, 0xca, 0x20, 0x64, 0x6d, 0x42,
0x6e, 0x5c, 0xdc, 0x50, 0x47, 0xfa, 0x64, 0x16, 0x97, 0x48, 0x30, 0x2b, 0x30, 0x6b, 0x70, 0x1b,
0xc9, 0xe1, 0x30, 0x05, 0xaa, 0x09, 0xea, 0x10, 0x64, 0x8d, 0x4e, 0xe6, 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, 0x25, 0x0b, 0x33, 0x42, 0xbf, 0x42, 0x1f, 0x25, 0x70, 0x4a,
0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0x61, 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xff,
0xa0, 0xf4, 0x18, 0xbe, 0x01, 0x00, 0x00,
0x9a, 0x5c, 0x92, 0x99, 0x9f, 0x07, 0x55, 0x80, 0xea, 0x08, 0x54, 0x39, 0x54, 0xcd, 0x39, 0xf9,
0xc9, 0xd9, 0xa9, 0x29, 0xf1, 0xa5, 0xc5, 0xa9, 0x45, 0x50, 0xd3, 0x95, 0xe6, 0x33, 0x71, 0xf1,
0xb8, 0x43, 0xdc, 0x1d, 0x5c, 0x92, 0x58, 0x92, 0x2a, 0x64, 0xcd, 0xc5, 0x06, 0xb1, 0x5e, 0x82,
0x51, 0x81, 0x51, 0x83, 0xdb, 0x48, 0x56, 0x0f, 0xab, 0x3f, 0xf4, 0x02, 0xc0, 0x8a, 0x9c, 0x58,
0x4e, 0xdc, 0x93, 0x67, 0x08, 0x82, 0x6a, 0x11, 0x72, 0xe1, 0xe2, 0x06, 0x39, 0xd0, 0x11, 0xe2,
0x06, 0x09, 0x26, 0xb0, 0x09, 0x4a, 0x38, 0x4c, 0xf0, 0x43, 0xa8, 0x0c, 0x42, 0xd6, 0x26, 0xe4,
0xc6, 0xc5, 0x0d, 0xf5, 0x85, 0x4f, 0x66, 0x71, 0x89, 0x04, 0xb3, 0x02, 0xb3, 0x06, 0xb7, 0x91,
0x1c, 0x0e, 0x53, 0xa0, 0x9a, 0xa0, 0x0e, 0x41, 0xd6, 0x08, 0x72, 0x0d, 0xc4, 0xc7, 0xa1, 0x20,
0x0f, 0x4b, 0xb0, 0xe0, 0x75, 0x8d, 0x0f, 0x42, 0x65, 0x10, 0xb2, 0x36, 0x27, 0xf3, 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, 0x92, 0x85, 0x19, 0xa0, 0x5f, 0xa1, 0x8f, 0x12,
0xce, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0x10, 0x36, 0x06, 0x04, 0x00, 0x00, 0xff,
0xff, 0xad, 0x0f, 0xd8, 0x00, 0x25, 0x02, 0x00, 0x00,
}
func (m *GenesisState) Marshal() (dAtA []byte, err error) {
@ -130,6 +140,18 @@ func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.LockedUsers != nil {
{
size, err := m.LockedUsers.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenesis(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
}
if len(m.AuctionList) > 0 {
for iNdEx := len(m.AuctionList) - 1; iNdEx >= 0; iNdEx-- {
{
@ -198,6 +220,10 @@ func (m *GenesisState) Size() (n int) {
n += 1 + l + sovGenesis(uint64(l))
}
}
if m.LockedUsers != nil {
l = m.LockedUsers.Size()
n += 1 + l + sovGenesis(uint64(l))
}
return n
}
@ -339,6 +365,42 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LockedUsers", 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 m.LockedUsers == nil {
m.LockedUsers = &LockedUsers{}
}
if err := m.LockedUsers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenesis(dAtA[iNdEx:])

3
x/colinearcore/types/genesis_test.go
View File

@ -34,6 +34,9 @@ func TestGenesisState_Validate(t *testing.T) {
Index: "1",
},
},
LockedUsers: &types.LockedUsers{
Users: map[string]string{},
},
// this line is used by starport scaffolding # types/genesis/validField
},
valid: true,

4
x/colinearcore/types/keys.go
View File

@ -24,3 +24,7 @@ func KeyPrefix(p string) []byte {
const (
NextAuctionKey = "NextAuction-value-"
)
const (
LockedUsersKey = "LockedUsers-value-"
)

429
x/colinearcore/types/locked_users.pb.go Normal file
View File

@ -0,0 +1,429 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: colinearcore/locked_users.proto
package types
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 LockedUsers struct {
Users map[string]string `protobuf:"bytes,1,rep,name=users,proto3" json:"users,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (m *LockedUsers) Reset() { *m = LockedUsers{} }
func (m *LockedUsers) String() string { return proto.CompactTextString(m) }
func (*LockedUsers) ProtoMessage() {}
func (*LockedUsers) Descriptor() ([]byte, []int) {
return fileDescriptor_a95f97d52ce10c20, []int{0}
}
func (m *LockedUsers) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *LockedUsers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_LockedUsers.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 *LockedUsers) XXX_Merge(src proto.Message) {
xxx_messageInfo_LockedUsers.Merge(m, src)
}
func (m *LockedUsers) XXX_Size() int {
return m.Size()
}
func (m *LockedUsers) XXX_DiscardUnknown() {
xxx_messageInfo_LockedUsers.DiscardUnknown(m)
}
var xxx_messageInfo_LockedUsers proto.InternalMessageInfo
func (m *LockedUsers) GetUsers() map[string]string {
if m != nil {
return m.Users
}
return nil
}
func init() {
proto.RegisterType((*LockedUsers)(nil), "colinear.colinearcore.LockedUsers")
proto.RegisterMapType((map[string]string)(nil), "colinear.colinearcore.LockedUsers.UsersEntry")
}
func init() { proto.RegisterFile("colinearcore/locked_users.proto", fileDescriptor_a95f97d52ce10c20) }
var fileDescriptor_a95f97d52ce10c20 = []byte{
// 194 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xce, 0xcf, 0xc9,
0xcc, 0x4b, 0x4d, 0x2c, 0x4a, 0xce, 0x2f, 0x4a, 0xd5, 0xcf, 0xc9, 0x4f, 0xce, 0x4e, 0x4d, 0x89,
0x2f, 0x2d, 0x4e, 0x2d, 0x2a, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x85, 0x29, 0xd0,
0x43, 0x56, 0xa9, 0xd4, 0xc3, 0xc8, 0xc5, 0xed, 0x03, 0x56, 0x1d, 0x0a, 0x52, 0x2c, 0xe4, 0xcc,
0xc5, 0x0a, 0xd6, 0x25, 0xc1, 0xa8, 0xc0, 0xac, 0xc1, 0x6d, 0xa4, 0xab, 0x87, 0x55, 0x9b, 0x1e,
0x92, 0x16, 0x3d, 0x30, 0xe9, 0x9a, 0x57, 0x52, 0x54, 0x19, 0x04, 0xd1, 0x2b, 0x65, 0xc1, 0xc5,
0x85, 0x10, 0x14, 0x12, 0xe0, 0x62, 0xce, 0x4e, 0xad, 0x94, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c,
0x02, 0x31, 0x85, 0x44, 0xb8, 0x58, 0xcb, 0x12, 0x73, 0x4a, 0x53, 0x25, 0x98, 0xc0, 0x62, 0x10,
0x8e, 0x15, 0x93, 0x05, 0xa3, 0x93, 0xf9, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e,
0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31,
0x44, 0xc9, 0xc2, 0xec, 0xd7, 0xaf, 0xd0, 0x47, 0xf1, 0x6b, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12,
0x1b, 0xd8, 0x97, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x58, 0x07, 0xd9, 0x09, 0x08, 0x01,
0x00, 0x00,
}
func (m *LockedUsers) 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 *LockedUsers) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *LockedUsers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Users) > 0 {
for k := range m.Users {
v := m.Users[k]
baseI := i
i -= len(v)
copy(dAtA[i:], v)
i = encodeVarintLockedUsers(dAtA, i, uint64(len(v)))
i--
dAtA[i] = 0x12
i -= len(k)
copy(dAtA[i:], k)
i = encodeVarintLockedUsers(dAtA, i, uint64(len(k)))
i--
dAtA[i] = 0xa
i = encodeVarintLockedUsers(dAtA, i, uint64(baseI-i))
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func encodeVarintLockedUsers(dAtA []byte, offset int, v uint64) int {
offset -= sovLockedUsers(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *LockedUsers) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Users) > 0 {
for k, v := range m.Users {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovLockedUsers(uint64(len(k))) + 1 + len(v) + sovLockedUsers(uint64(len(v)))
n += mapEntrySize + 1 + sovLockedUsers(uint64(mapEntrySize))
}
}
return n
}
func sovLockedUsers(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozLockedUsers(x uint64) (n int) {
return sovLockedUsers(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *LockedUsers) 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 ErrIntOverflowLockedUsers
}
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: LockedUsers: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: LockedUsers: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Users", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowLockedUsers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthLockedUsers
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthLockedUsers
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Users == nil {
m.Users = make(map[string]string)
}
var mapkey string
var mapvalue string
for iNdEx < postIndex {
entryPreIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowLockedUsers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
if fieldNum == 1 {
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowLockedUsers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthLockedUsers
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey < 0 {
return ErrInvalidLengthLockedUsers
}
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
} else if fieldNum == 2 {
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowLockedUsers
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthLockedUsers
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue < 0 {
return ErrInvalidLengthLockedUsers
}
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
} else {
iNdEx = entryPreIndex
skippy, err := skipLockedUsers(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLockedUsers
}
if (iNdEx + skippy) > postIndex {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
m.Users[mapkey] = mapvalue
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipLockedUsers(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthLockedUsers
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipLockedUsers(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, ErrIntOverflowLockedUsers
}
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, ErrIntOverflowLockedUsers
}
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, ErrIntOverflowLockedUsers
}
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, ErrInvalidLengthLockedUsers
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupLockedUsers
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthLockedUsers
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthLockedUsers = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowLockedUsers = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupLockedUsers = fmt.Errorf("proto: unexpected end of group")
)

45
x/colinearcore/types/message_lock_funds.go Normal file
View File

@ -0,0 +1,45 @@
package types
import (
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
)
const TypeMsgLockFunds = "lock_funds"
var _ sdk.Msg = &MsgLockFunds{}
func NewMsgLockFunds(creator string) *MsgLockFunds {
return &MsgLockFunds{
Creator: creator,
}
}
func (msg *MsgLockFunds) Route() string {
return RouterKey
}
func (msg *MsgLockFunds) Type() string {
return TypeMsgLockFunds
}
func (msg *MsgLockFunds) GetSigners() []sdk.AccAddress {
creator, err := sdk.AccAddressFromBech32(msg.Creator)
if err != nil {
panic(err)
}
return []sdk.AccAddress{creator}
}
func (msg *MsgLockFunds) GetSignBytes() []byte {
bz := ModuleCdc.MustMarshalJSON(msg)
return sdk.MustSortJSON(bz)
}
func (msg *MsgLockFunds) ValidateBasic() error {
_, err := sdk.AccAddressFromBech32(msg.Creator)
if err != nil {
return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err)
}
return nil
}

40
x/colinearcore/types/message_lock_funds_test.go Normal file
View File

@ -0,0 +1,40 @@
package types
import (
"testing"
"colinear/testutil/sample"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/stretchr/testify/require"
)
func TestMsgLockFunds_ValidateBasic(t *testing.T) {
tests := []struct {
name string
msg MsgLockFunds
err error
}{
{
name: "invalid address",
msg: MsgLockFunds{
Creator: "invalid_address",
},
err: sdkerrors.ErrInvalidAddress,
}, {
name: "valid address",
msg: MsgLockFunds{
Creator: sample.AccAddress(),
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := tt.msg.ValidateBasic()
if tt.err != nil {
require.ErrorIs(t, err, tt.err)
return
}
require.NoError(t, err)
})
}
}

413
x/colinearcore/types/query.pb.go
View File

@ -465,6 +465,86 @@ func (m *QueryAuctionBidsResponse) GetBids() []*Bid {
return nil
}
type QueryGetLockedUsersRequest struct {
}
func (m *QueryGetLockedUsersRequest) Reset() { *m = QueryGetLockedUsersRequest{} }
func (m *QueryGetLockedUsersRequest) String() string { return proto.CompactTextString(m) }
func (*QueryGetLockedUsersRequest) ProtoMessage() {}
func (*QueryGetLockedUsersRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_7b40a5389bf6a896, []int{10}
}
func (m *QueryGetLockedUsersRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryGetLockedUsersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryGetLockedUsersRequest.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 *QueryGetLockedUsersRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryGetLockedUsersRequest.Merge(m, src)
}
func (m *QueryGetLockedUsersRequest) XXX_Size() int {
return m.Size()
}
func (m *QueryGetLockedUsersRequest) XXX_DiscardUnknown() {
xxx_messageInfo_QueryGetLockedUsersRequest.DiscardUnknown(m)
}
var xxx_messageInfo_QueryGetLockedUsersRequest proto.InternalMessageInfo
type QueryGetLockedUsersResponse struct {
LockedUsers LockedUsers `protobuf:"bytes,1,opt,name=LockedUsers,proto3" json:"LockedUsers"`
}
func (m *QueryGetLockedUsersResponse) Reset() { *m = QueryGetLockedUsersResponse{} }
func (m *QueryGetLockedUsersResponse) String() string { return proto.CompactTextString(m) }
func (*QueryGetLockedUsersResponse) ProtoMessage() {}
func (*QueryGetLockedUsersResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_7b40a5389bf6a896, []int{11}
}
func (m *QueryGetLockedUsersResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryGetLockedUsersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryGetLockedUsersResponse.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 *QueryGetLockedUsersResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryGetLockedUsersResponse.Merge(m, src)
}
func (m *QueryGetLockedUsersResponse) XXX_Size() int {
return m.Size()
}
func (m *QueryGetLockedUsersResponse) XXX_DiscardUnknown() {
xxx_messageInfo_QueryGetLockedUsersResponse.DiscardUnknown(m)
}
var xxx_messageInfo_QueryGetLockedUsersResponse proto.InternalMessageInfo
func (m *QueryGetLockedUsersResponse) GetLockedUsers() LockedUsers {
if m != nil {
return m.LockedUsers
}
return LockedUsers{}
}
func init() {
proto.RegisterType((*QueryParamsRequest)(nil), "colinear.colinearcore.QueryParamsRequest")
proto.RegisterType((*QueryParamsResponse)(nil), "colinear.colinearcore.QueryParamsResponse")
@ -476,51 +556,57 @@ func init() {
proto.RegisterType((*QueryAllAuctionResponse)(nil), "colinear.colinearcore.QueryAllAuctionResponse")
proto.RegisterType((*QueryAuctionBidsRequest)(nil), "colinear.colinearcore.QueryAuctionBidsRequest")
proto.RegisterType((*QueryAuctionBidsResponse)(nil), "colinear.colinearcore.QueryAuctionBidsResponse")
proto.RegisterType((*QueryGetLockedUsersRequest)(nil), "colinear.colinearcore.QueryGetLockedUsersRequest")
proto.RegisterType((*QueryGetLockedUsersResponse)(nil), "colinear.colinearcore.QueryGetLockedUsersResponse")
}
func init() { proto.RegisterFile("colinearcore/query.proto", fileDescriptor_7b40a5389bf6a896) }
var fileDescriptor_7b40a5389bf6a896 = []byte{
// 610 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x95, 0xc1, 0x6b, 0x13, 0x41,
0x14, 0xc6, 0x33, 0xb5, 0x4d, 0x71, 0x7a, 0x1b, 0x6b, 0xad, 0x6b, 0xbb, 0xd5, 0x51, 0xac, 0x09,
0x3a, 0x43, 0xe2, 0xa1, 0x07, 0x41, 0x48, 0x0e, 0x16, 0x7a, 0x90, 0xba, 0x37, 0xbd, 0xd4, 0x49,
0x32, 0x2c, 0x0b, 0xdb, 0x9d, 0x6d, 0x76, 0x23, 0x29, 0xe2, 0xc5, 0xa3, 0x27, 0xc1, 0x83, 0x17,
0x41, 0x10, 0xc4, 0x7f, 0xa5, 0xc7, 0x82, 0x17, 0x4f, 0x22, 0x89, 0x7f, 0x88, 0x64, 0xe6, 0x2d,
0xee, 0x74, 0x93, 0x4d, 0x7a, 0x4b, 0xe6, 0x7d, 0xdf, 0xfb, 0x7e, 0xb3, 0x79, 0x2f, 0x8b, 0x37,
0xbb, 0x2a, 0x0c, 0x22, 0x29, 0xfa, 0x5d, 0xd5, 0x97, 0xfc, 0x64, 0x20, 0xfb, 0xa7, 0x2c, 0xee,
0xab, 0x54, 0x91, 0xeb, 0x59, 0x85, 0xe5, 0x25, 0xce, 0xba, 0xaf, 0x7c, 0xa5, 0x15, 0x7c, 0xf2,
0xc9, 0x88, 0x9d, 0x2d, 0x5f, 0x29, 0x3f, 0x94, 0x5c, 0xc4, 0x01, 0x17, 0x51, 0xa4, 0x52, 0x91,
0x06, 0x2a, 0x4a, 0xa0, 0x5a, 0xef, 0xaa, 0xe4, 0x58, 0x25, 0xbc, 0x23, 0x12, 0xc8, 0xe0, 0x6f,
0x1a, 0x1d, 0x99, 0x8a, 0x06, 0x8f, 0x85, 0x1f, 0x44, 0x5a, 0x0c, 0xda, 0x9b, 0x16, 0x50, 0x2c,
0xfa, 0xe2, 0x38, 0x6b, 0xb3, 0x63, 0x95, 0x22, 0x39, 0x4c, 0x8f, 0xc4, 0xa0, 0x9b, 0xf3, 0x3a,
0x96, 0xc0, 0xae, 0x6d, 0x58, 0xb5, 0x4e, 0xd0, 0x33, 0xe7, 0x74, 0x1d, 0x93, 0x17, 0x13, 0xa2,
0x43, 0x9d, 0xe4, 0xc9, 0x93, 0x81, 0x4c, 0x52, 0xea, 0xe1, 0x6b, 0xd6, 0x69, 0x12, 0xab, 0x28,
0x91, 0xe4, 0x09, 0xae, 0x1a, 0xa2, 0x4d, 0x74, 0x1b, 0x3d, 0x58, 0x6b, 0x6e, 0xb3, 0xa9, 0x0f,
0x89, 0x19, 0x5b, 0x7b, 0xf9, 0xec, 0xf7, 0x4e, 0xc5, 0x03, 0x0b, 0xdd, 0xc2, 0x8e, 0xee, 0xb9,
0x2f, 0xd3, 0xe7, 0x72, 0x98, 0xb6, 0x0c, 0x5e, 0x96, 0x18, 0xe0, 0x5b, 0x53, 0xab, 0x90, 0x7c,
0x80, 0xd7, 0x72, 0xc7, 0x10, 0x4f, 0x67, 0xc4, 0xe7, 0x94, 0xc0, 0x90, 0x37, 0x53, 0x86, 0x37,
0xb2, 0x28, 0x1b, 0x82, 0xac, 0xe3, 0x95, 0x20, 0xea, 0xc9, 0xa1, 0xee, 0x7f, 0xd5, 0x33, 0x5f,
0xe8, 0x4b, 0x7c, 0xa3, 0xa0, 0x07, 0xac, 0xa7, 0x78, 0x55, 0x58, 0x48, 0xee, 0x0c, 0x24, 0x1b,
0x27, 0x33, 0xd1, 0xd7, 0x80, 0xd2, 0x0a, 0xc3, 0x0b, 0x28, 0xcf, 0x30, 0xfe, 0x3f, 0x1b, 0xd0,
0xfc, 0x3e, 0x33, 0x83, 0xc4, 0x26, 0x83, 0xc4, 0xcc, 0xb0, 0xc2, 0x20, 0xb1, 0x43, 0xe1, 0x4b,
0xf0, 0x7a, 0x39, 0x27, 0xfd, 0x86, 0x80, 0x3e, 0x1f, 0x31, 0x8d, 0xfe, 0xca, 0xa5, 0xe9, 0xc9,
0xbe, 0xc5, 0xb8, 0xa4, 0x19, 0x77, 0xe7, 0x32, 0x9a, 0x70, 0x0b, 0x92, 0x67, 0x8c, 0x90, 0x13,
0xf4, 0x92, 0xf2, 0x9f, 0xe4, 0x00, 0x6f, 0x16, 0x0d, 0x70, 0x2b, 0x86, 0x97, 0x3b, 0x41, 0x2f,
0x81, 0x2b, 0x39, 0x33, 0xae, 0xd4, 0x0e, 0x7a, 0x9e, 0xd6, 0x35, 0xbf, 0x56, 0xf1, 0x8a, 0x6e,
0x46, 0x3e, 0x20, 0x5c, 0x35, 0xa3, 0x4b, 0x6a, 0x33, 0x6c, 0xc5, 0x5d, 0x71, 0xea, 0x8b, 0x48,
0x0d, 0x1b, 0xad, 0xbd, 0xff, 0xf9, 0xf7, 0xd3, 0xd2, 0x5d, 0x72, 0x87, 0x5b, 0xeb, 0x38, 0x65,
0xe7, 0xc9, 0x77, 0x64, 0x8d, 0x3c, 0x69, 0x94, 0xc5, 0x4c, 0xdd, 0x29, 0xa7, 0x79, 0x19, 0x0b,
0x10, 0x72, 0x4d, 0x58, 0x23, 0xbb, 0x25, 0x84, 0xf9, 0xbf, 0x1e, 0xf2, 0x05, 0xe1, 0xd5, 0x8c,
0xf1, 0xd1, 0x9c, 0xc0, 0x0b, 0x7c, 0x6c, 0x51, 0x39, 0xb0, 0x35, 0x35, 0xdb, 0x43, 0x52, 0x2f,
0x61, 0x03, 0x2c, 0xfe, 0x56, 0x0f, 0xca, 0x3b, 0xf2, 0x19, 0x61, 0x0c, 0x7d, 0x5a, 0x61, 0x58,
0x4e, 0x58, 0xd8, 0xc2, 0x72, 0xc2, 0xe2, 0x46, 0xd1, 0xba, 0x26, 0xbc, 0x47, 0xe8, 0x7c, 0x42,
0xf2, 0x03, 0xe1, 0xb5, 0xdc, 0xfc, 0x92, 0xf2, 0xac, 0xc2, 0x66, 0x38, 0x7c, 0x61, 0x3d, 0xc0,
0xed, 0x69, 0xb8, 0x06, 0xe1, 0xf3, 0xe1, 0x8e, 0x26, 0x9b, 0x91, 0x3d, 0xc3, 0xf6, 0xde, 0xd9,
0xc8, 0x45, 0xe7, 0x23, 0x17, 0xfd, 0x19, 0xb9, 0xe8, 0xe3, 0xd8, 0xad, 0x9c, 0x8f, 0xdd, 0xca,
0xaf, 0xb1, 0x5b, 0x79, 0xb5, 0x9d, 0x99, 0xf9, 0xd0, 0xee, 0x93, 0x9e, 0xc6, 0x32, 0xe9, 0x54,
0xf5, 0x3b, 0xe6, 0xf1, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x03, 0x0b, 0x40, 0x22, 0x66, 0x07,
0x00, 0x00,
// 675 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x95, 0x3d, 0x6f, 0xd3, 0x40,
0x1c, 0xc6, 0x73, 0xa5, 0x2f, 0xe2, 0xba, 0x1d, 0xa5, 0x14, 0xd3, 0xba, 0x70, 0x05, 0x4a, 0x03,
0xf8, 0x94, 0x30, 0x74, 0x40, 0x42, 0x6a, 0x06, 0x2a, 0x55, 0x08, 0x15, 0x4b, 0x0c, 0xb0, 0x84,
0x4b, 0x7c, 0xb2, 0x2c, 0x5c, 0x9f, 0x6b, 0x3b, 0x28, 0x15, 0x62, 0x61, 0x64, 0x42, 0x62, 0x60,
0x61, 0x01, 0x09, 0xf1, 0x41, 0x58, 0x3a, 0x56, 0x62, 0x61, 0x42, 0x28, 0xe1, 0x83, 0xa0, 0x9c,
0xcf, 0xe9, 0x5d, 0xed, 0xd8, 0xe9, 0xd6, 0xde, 0xff, 0xe5, 0xf9, 0xd9, 0x79, 0x9e, 0x33, 0x5c,
0xe9, 0x72, 0xdf, 0x0b, 0x18, 0x8d, 0xba, 0x3c, 0x62, 0xe4, 0xb0, 0xc7, 0xa2, 0x23, 0x2b, 0x8c,
0x78, 0xc2, 0xd1, 0xe5, 0xac, 0x62, 0xa9, 0x2d, 0xc6, 0x92, 0xcb, 0x5d, 0x2e, 0x3a, 0xc8, 0xe8,
0xaf, 0xb4, 0xd9, 0x58, 0x75, 0x39, 0x77, 0x7d, 0x46, 0x68, 0xe8, 0x11, 0x1a, 0x04, 0x3c, 0xa1,
0x89, 0xc7, 0x83, 0x58, 0x56, 0xeb, 0x5d, 0x1e, 0x1f, 0xf0, 0x98, 0x74, 0x68, 0x2c, 0x35, 0xc8,
0x9b, 0x46, 0x87, 0x25, 0xb4, 0x41, 0x42, 0xea, 0x7a, 0x81, 0x68, 0x96, 0xbd, 0x57, 0x35, 0xa0,
0x90, 0x46, 0xf4, 0x20, 0x5b, 0xb3, 0xae, 0x95, 0x02, 0xd6, 0x4f, 0xda, 0xb4, 0xd7, 0x55, 0x66,
0x0d, 0xad, 0x41, 0xaf, 0x2d, 0x6b, 0xb5, 0x8e, 0xe7, 0x14, 0x2e, 0xf5, 0x79, 0xf7, 0x35, 0x73,
0xda, 0xbd, 0x98, 0x45, 0x52, 0x15, 0x2f, 0x41, 0xf4, 0x6c, 0x84, 0xbc, 0x2f, 0x50, 0x6c, 0x76,
0xd8, 0x63, 0x71, 0x82, 0x6d, 0x78, 0x49, 0x3b, 0x8d, 0x43, 0x1e, 0xc4, 0x0c, 0x3d, 0x84, 0xf3,
0x29, 0xf2, 0x0a, 0xb8, 0x0e, 0xee, 0x2c, 0x36, 0xd7, 0xac, 0xc2, 0xb7, 0x68, 0xa5, 0x63, 0xad,
0xd9, 0xe3, 0x3f, 0xeb, 0x35, 0x5b, 0x8e, 0xe0, 0x55, 0x68, 0x88, 0x9d, 0xbb, 0x2c, 0x79, 0xca,
0xfa, 0xc9, 0x4e, 0xca, 0x9f, 0x29, 0x7a, 0xf0, 0x5a, 0x61, 0x55, 0x2a, 0xef, 0xc1, 0x45, 0xe5,
0x58, 0xca, 0xe3, 0x09, 0xf2, 0x4a, 0xa7, 0x64, 0x50, 0x87, 0xb1, 0x05, 0x97, 0x33, 0x29, 0x1d,
0x02, 0x2d, 0xc1, 0x39, 0x2f, 0x70, 0x58, 0x5f, 0xec, 0xbf, 0x68, 0xa7, 0xff, 0xe0, 0x17, 0xf0,
0x4a, 0xae, 0x5f, 0x62, 0x3d, 0x82, 0x0b, 0x54, 0x43, 0x32, 0x27, 0x20, 0xe9, 0x38, 0xd9, 0x10,
0x7e, 0x25, 0x51, 0x76, 0x7c, 0xff, 0x0c, 0xca, 0x63, 0x08, 0x4f, 0xcd, 0x23, 0x97, 0xdf, 0xb6,
0x52, 0xa7, 0x59, 0x23, 0xa7, 0x59, 0xa9, 0x9b, 0xa5, 0xd3, 0xac, 0x7d, 0xea, 0x32, 0x39, 0x6b,
0x2b, 0x93, 0xf8, 0x1b, 0x90, 0xf4, 0xaa, 0x44, 0x11, 0xfd, 0x85, 0x73, 0xd3, 0xa3, 0x5d, 0x8d,
0x71, 0x46, 0x30, 0x6e, 0x56, 0x32, 0xa6, 0xe2, 0x1a, 0x24, 0xc9, 0x18, 0xa5, 0x8e, 0xe7, 0xc4,
0xe5, 0x3f, 0xc9, 0x1e, 0x5c, 0xc9, 0x0f, 0xc8, 0xa7, 0xb2, 0xe0, 0x6c, 0xc7, 0x73, 0x62, 0xf9,
0x48, 0xc6, 0x84, 0x47, 0x6a, 0x79, 0x8e, 0x2d, 0xfa, 0x54, 0x5f, 0x3e, 0x11, 0xf9, 0x78, 0x3e,
0x8a, 0x47, 0x81, 0x2f, 0xb5, 0xea, 0xa9, 0x2f, 0x95, 0xe3, 0x0a, 0x5f, 0x2a, 0x9d, 0x99, 0x2f,
0x95, 0xa3, 0xe6, 0xcf, 0x05, 0x38, 0x27, 0xb4, 0xd0, 0x07, 0x00, 0xe7, 0xd3, 0x0c, 0xa1, 0xad,
0x09, 0xbb, 0xf2, 0xa1, 0x35, 0xea, 0xd3, 0xb4, 0xa6, 0xdc, 0x78, 0xeb, 0xfd, 0xaf, 0x7f, 0x9f,
0x66, 0x36, 0xd0, 0x0d, 0xa2, 0x5d, 0x10, 0x05, 0xb7, 0x13, 0xfa, 0x0e, 0xb4, 0xec, 0xa1, 0x46,
0x99, 0x4c, 0x61, 0xb8, 0x8d, 0xe6, 0x79, 0x46, 0x24, 0x21, 0x11, 0x84, 0x5b, 0x68, 0xb3, 0x84,
0x50, 0xbd, 0x24, 0xd1, 0x17, 0x00, 0x17, 0x32, 0xc6, 0xfb, 0x15, 0x82, 0x67, 0xf8, 0xac, 0x69,
0xdb, 0x25, 0x5b, 0x53, 0xb0, 0xdd, 0x43, 0xf5, 0x12, 0x36, 0x89, 0x45, 0xde, 0x0a, 0xc7, 0xbe,
0x43, 0x9f, 0x01, 0x84, 0x72, 0xcf, 0x8e, 0xef, 0x97, 0x13, 0xe6, 0xae, 0x83, 0x72, 0xc2, 0x7c,
0xb4, 0x71, 0x5d, 0x10, 0xde, 0x44, 0xb8, 0x9a, 0x10, 0xfd, 0x00, 0x70, 0x51, 0x09, 0x12, 0x2a,
0xd7, 0xca, 0x45, 0xd4, 0x20, 0x53, 0xf7, 0x4b, 0xb8, 0x6d, 0x01, 0xd7, 0x40, 0xa4, 0x1a, 0xae,
0x3d, 0x8a, 0xe8, 0xf8, 0x1d, 0x7e, 0x05, 0x5a, 0xdc, 0x2a, 0xad, 0x98, 0xcf, 0x73, 0xa5, 0x15,
0x0b, 0x42, 0x8e, 0xef, 0x0a, 0xde, 0x5b, 0x68, 0x63, 0x8c, 0x48, 0x26, 0x7e, 0x56, 0x5b, 0xdb,
0xc7, 0x03, 0x13, 0x9c, 0x0c, 0x4c, 0xf0, 0x77, 0x60, 0x82, 0x8f, 0x43, 0xb3, 0x76, 0x32, 0x34,
0x6b, 0xbf, 0x87, 0x66, 0xed, 0xe5, 0xda, 0x78, 0xba, 0xaf, 0xcf, 0x27, 0x47, 0x21, 0x8b, 0x3b,
0xf3, 0xe2, 0x83, 0xfc, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd1, 0xf1, 0xb6, 0x7a, 0xb4,
0x08, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -545,6 +631,8 @@ type QueryClient interface {
AuctionAll(ctx context.Context, in *QueryAllAuctionRequest, opts ...grpc.CallOption) (*QueryAllAuctionResponse, error)
// Queries a list of AuctionBids items.
AuctionBids(ctx context.Context, in *QueryAuctionBidsRequest, opts ...grpc.CallOption) (*QueryAuctionBidsResponse, error)
// Queries a LockedUsers by index.
LockedUsers(ctx context.Context, in *QueryGetLockedUsersRequest, opts ...grpc.CallOption) (*QueryGetLockedUsersResponse, error)
}
type queryClient struct {
@ -600,6 +688,15 @@ func (c *queryClient) AuctionBids(ctx context.Context, in *QueryAuctionBidsReque
return out, nil
}
func (c *queryClient) LockedUsers(ctx context.Context, in *QueryGetLockedUsersRequest, opts ...grpc.CallOption) (*QueryGetLockedUsersResponse, error) {
out := new(QueryGetLockedUsersResponse)
err := c.cc.Invoke(ctx, "/colinear.colinearcore.Query/LockedUsers", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// QueryServer is the server API for Query service.
type QueryServer interface {
// Parameters queries the parameters of the module.
@ -612,6 +709,8 @@ type QueryServer interface {
AuctionAll(context.Context, *QueryAllAuctionRequest) (*QueryAllAuctionResponse, error)
// Queries a list of AuctionBids items.
AuctionBids(context.Context, *QueryAuctionBidsRequest) (*QueryAuctionBidsResponse, error)
// Queries a LockedUsers by index.
LockedUsers(context.Context, *QueryGetLockedUsersRequest) (*QueryGetLockedUsersResponse, error)
}
// UnimplementedQueryServer can be embedded to have forward compatible implementations.
@ -633,6 +732,9 @@ func (*UnimplementedQueryServer) AuctionAll(ctx context.Context, req *QueryAllAu
func (*UnimplementedQueryServer) AuctionBids(ctx context.Context, req *QueryAuctionBidsRequest) (*QueryAuctionBidsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method AuctionBids not implemented")
}
func (*UnimplementedQueryServer) LockedUsers(ctx context.Context, req *QueryGetLockedUsersRequest) (*QueryGetLockedUsersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method LockedUsers not implemented")
}
func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
s.RegisterService(&_Query_serviceDesc, srv)
@ -728,6 +830,24 @@ func _Query_AuctionBids_Handler(srv interface{}, ctx context.Context, dec func(i
return interceptor(ctx, in, info, handler)
}
func _Query_LockedUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryGetLockedUsersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryServer).LockedUsers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/colinear.colinearcore.Query/LockedUsers",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryServer).LockedUsers(ctx, req.(*QueryGetLockedUsersRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Query_serviceDesc = grpc.ServiceDesc{
ServiceName: "colinear.colinearcore.Query",
HandlerType: (*QueryServer)(nil),
@ -752,6 +872,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
MethodName: "AuctionBids",
Handler: _Query_AuctionBids_Handler,
},
{
MethodName: "LockedUsers",
Handler: _Query_LockedUsers_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "colinearcore/query.proto",
@ -1083,6 +1207,62 @@ func (m *QueryAuctionBidsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
return len(dAtA) - i, nil
}
func (m *QueryGetLockedUsersRequest) 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 *QueryGetLockedUsersRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryGetLockedUsersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
return len(dAtA) - i, nil
}
func (m *QueryGetLockedUsersResponse) 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 *QueryGetLockedUsersResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryGetLockedUsersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
{
size, err := m.LockedUsers.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
@ -1218,6 +1398,26 @@ func (m *QueryAuctionBidsResponse) Size() (n int) {
return n
}
func (m *QueryGetLockedUsersRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
return n
}
func (m *QueryGetLockedUsersResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = m.LockedUsers.Size()
n += 1 + l + sovQuery(uint64(l))
return n
}
func sovQuery(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@ -2027,6 +2227,139 @@ func (m *QueryAuctionBidsResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *QueryGetLockedUsersRequest) 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: QueryGetLockedUsersRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryGetLockedUsersRequest: 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 *QueryGetLockedUsersResponse) 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: QueryGetLockedUsersResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryGetLockedUsersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LockedUsers", 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.LockedUsers.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

65
x/colinearcore/types/query.pb.gw.go
View File

@ -213,6 +213,24 @@ func local_request_Query_AuctionBids_0(ctx context.Context, marshaler runtime.Ma
}
func request_Query_LockedUsers_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryGetLockedUsersRequest
var metadata runtime.ServerMetadata
msg, err := client.LockedUsers(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_LockedUsers_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq QueryGetLockedUsersRequest
var metadata runtime.ServerMetadata
msg, err := server.LockedUsers(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.
@ -334,6 +352,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
})
mux.Handle("GET", pattern_Query_LockedUsers_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_LockedUsers_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_LockedUsers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@ -475,6 +516,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
})
mux.Handle("GET", pattern_Query_LockedUsers_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_LockedUsers_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_LockedUsers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@ -488,6 +549,8 @@ var (
pattern_Query_AuctionAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 0, 2, 1}, []string{"colinearcore", "auction"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_AuctionBids_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"colinearcore", "auction_bids", "index"}, "", runtime.AssumeColonVerbOpt(true)))
pattern_Query_LockedUsers_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"colinear", "colinearcore", "locked_users"}, "", runtime.AssumeColonVerbOpt(true)))
)
var (
@ -500,4 +563,6 @@ var (
forward_Query_AuctionAll_0 = runtime.ForwardResponseMessage
forward_Query_AuctionBids_0 = runtime.ForwardResponseMessage
forward_Query_LockedUsers_0 = runtime.ForwardResponseMessage
)

372
x/colinearcore/types/tx.pb.go
View File

@ -251,38 +251,123 @@ func (m *MsgNewBidResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_MsgNewBidResponse proto.InternalMessageInfo
type MsgLockFunds struct {
Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
}
func (m *MsgLockFunds) Reset() { *m = MsgLockFunds{} }
func (m *MsgLockFunds) String() string { return proto.CompactTextString(m) }
func (*MsgLockFunds) ProtoMessage() {}
func (*MsgLockFunds) Descriptor() ([]byte, []int) {
return fileDescriptor_0c3854a2a9bba3b4, []int{4}
}
func (m *MsgLockFunds) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgLockFunds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgLockFunds.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 *MsgLockFunds) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgLockFunds.Merge(m, src)
}
func (m *MsgLockFunds) XXX_Size() int {
return m.Size()
}
func (m *MsgLockFunds) XXX_DiscardUnknown() {
xxx_messageInfo_MsgLockFunds.DiscardUnknown(m)
}
var xxx_messageInfo_MsgLockFunds proto.InternalMessageInfo
func (m *MsgLockFunds) GetCreator() string {
if m != nil {
return m.Creator
}
return ""
}
type MsgLockFundsResponse struct {
}
func (m *MsgLockFundsResponse) Reset() { *m = MsgLockFundsResponse{} }
func (m *MsgLockFundsResponse) String() string { return proto.CompactTextString(m) }
func (*MsgLockFundsResponse) ProtoMessage() {}
func (*MsgLockFundsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_0c3854a2a9bba3b4, []int{5}
}
func (m *MsgLockFundsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *MsgLockFundsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_MsgLockFundsResponse.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 *MsgLockFundsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_MsgLockFundsResponse.Merge(m, src)
}
func (m *MsgLockFundsResponse) XXX_Size() int {
return m.Size()
}
func (m *MsgLockFundsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_MsgLockFundsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_MsgLockFundsResponse proto.InternalMessageInfo
func init() {
proto.RegisterType((*MsgNewAuction)(nil), "colinear.colinearcore.MsgNewAuction")
proto.RegisterType((*MsgNewAuctionResponse)(nil), "colinear.colinearcore.MsgNewAuctionResponse")
proto.RegisterType((*MsgNewBid)(nil), "colinear.colinearcore.MsgNewBid")
proto.RegisterType((*MsgNewBidResponse)(nil), "colinear.colinearcore.MsgNewBidResponse")
proto.RegisterType((*MsgLockFunds)(nil), "colinear.colinearcore.MsgLockFunds")
proto.RegisterType((*MsgLockFundsResponse)(nil), "colinear.colinearcore.MsgLockFundsResponse")
}
func init() { proto.RegisterFile("colinearcore/tx.proto", fileDescriptor_0c3854a2a9bba3b4) }
var fileDescriptor_0c3854a2a9bba3b4 = []byte{
// 336 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xc1, 0x4a, 0xc3, 0x40,
0x10, 0x86, 0xbb, 0xb6, 0x8d, 0x76, 0xd4, 0x83, 0xab, 0x95, 0xa5, 0x68, 0x08, 0xc1, 0x43, 0x0f,
0x92, 0x82, 0x22, 0x9e, 0x2d, 0x78, 0xf0, 0x50, 0x0f, 0xc5, 0x93, 0x27, 0xd7, 0xec, 0x50, 0x16,
0xda, 0xdd, 0x90, 0x4d, 0xb1, 0xbe, 0x85, 0xef, 0xe1, 0x33, 0x78, 0xf7, 0xd8, 0xa3, 0x47, 0x69,
0x5f, 0x44, 0xdc, 0x6c, 0x62, 0x03, 0x52, 0xbd, 0xe5, 0xff, 0x66, 0xfe, 0xc9, 0xfc, 0xc9, 0x40,
0x3b, 0xd6, 0x63, 0xa9, 0x90, 0xa7, 0xb1, 0x4e, 0xb1, 0x97, 0xcd, 0xa2, 0x24, 0xd5, 0x99, 0xa6,
0x25, 0x8e, 0x56, 0xeb, 0xe1, 0x2b, 0x81, 0xdd, 0x81, 0x19, 0xdd, 0xe2, 0xd3, 0xd5, 0x34, 0xce,
0xa4, 0x56, 0x94, 0xc1, 0x66, 0x9c, 0x22, 0xcf, 0x74, 0xca, 0x48, 0x40, 0xba, 0xad, 0x61, 0x21,
0x29, 0x85, 0x86, 0xe2, 0x13, 0x64, 0x1b, 0x16, 0xdb, 0x67, 0x1a, 0xc0, 0xb6, 0x40, 0x13, 0xa7,
0x32, 0xf9, 0x36, 0xb3, 0xba, 0x2d, 0xad, 0x22, 0x3b, 0x0f, 0xe5, 0x58, 0xaa, 0x11, 0x6b, 0xb8,
0x79, 0xb9, 0xa4, 0x07, 0xd0, 0x14, 0xa8, 0xf4, 0x84, 0x35, 0x2d, 0xcf, 0x05, 0xed, 0xc0, 0xd6,
0x18, 0xb9, 0xc1, 0x6b, 0x25, 0x98, 0x17, 0x90, 0x6e, 0x63, 0x58, 0xea, 0xf0, 0x02, 0xda, 0x95,
0x65, 0x87, 0x68, 0x12, 0xad, 0x0c, 0xd2, 0x23, 0x68, 0xf1, 0x1c, 0xdd, 0x08, 0xb7, 0xf6, 0x0f,
0x08, 0x39, 0xb4, 0x72, 0x5b, 0x5f, 0x8a, 0x35, 0xf9, 0x42, 0xd8, 0x29, 0x3c, 0x4a, 0xe0, 0xcc,
0xe5, 0xac, 0x30, 0x7a, 0x08, 0x1e, 0x9f, 0xe8, 0xa9, 0xca, 0x5c, 0x54, 0xa7, 0xc2, 0x7d, 0xd8,
0x2b, 0x5f, 0x51, 0x6c, 0x75, 0xf6, 0x46, 0xa0, 0x3e, 0x30, 0x23, 0xfa, 0x00, 0xb0, 0xf2, 0x81,
0x4f, 0xa2, 0x5f, 0x7f, 0x45, 0x54, 0x49, 0xd6, 0x39, 0xfd, 0x4f, 0x57, 0x99, 0xff, 0x0e, 0x3c,
0x17, 0x2f, 0x58, 0xeb, 0xeb, 0x4b, 0xd1, 0xe9, 0xfe, 0xd5, 0x51, 0x4c, 0xed, 0x5f, 0xbe, 0x2f,
0x7c, 0x32, 0x5f, 0xf8, 0xe4, 0x73, 0xe1, 0x93, 0x97, 0xa5, 0x5f, 0x9b, 0x2f, 0xfd, 0xda, 0xc7,
0xd2, 0xaf, 0xdd, 0x1f, 0x17, 0xce, 0xde, 0xac, 0x57, 0xbd, 0xb7, 0xe7, 0x04, 0xcd, 0xa3, 0x67,
0x6f, 0xee, 0xfc, 0x2b, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x6a, 0x01, 0x5c, 0x8c, 0x02, 0x00, 0x00,
// 376 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xcb, 0x4a, 0xc3, 0x40,
0x14, 0x6d, 0xfa, 0x88, 0xe6, 0x5a, 0x17, 0x8e, 0x6d, 0x09, 0x41, 0x43, 0x88, 0x2e, 0x02, 0x4a,
0x0a, 0x8a, 0xb8, 0xb6, 0xa0, 0x20, 0x58, 0x17, 0xc5, 0x95, 0x20, 0x18, 0x33, 0x97, 0x10, 0x6c,
0x67, 0x42, 0x26, 0xc5, 0xfa, 0x17, 0x7e, 0x80, 0x7f, 0xe0, 0x8f, 0xb8, 0xec, 0xd2, 0xa5, 0xb4,
0x3f, 0x22, 0xe6, 0xd5, 0x04, 0x6c, 0xed, 0x6e, 0xce, 0x99, 0x73, 0xce, 0xdc, 0x7b, 0x87, 0x0b,
0x6d, 0x97, 0x0f, 0x7d, 0x86, 0x4e, 0xe8, 0xf2, 0x10, 0xbb, 0xd1, 0xc4, 0x0e, 0x42, 0x1e, 0x71,
0x92, 0xd3, 0x76, 0xf1, 0xde, 0xfc, 0x90, 0x60, 0xbb, 0x2f, 0xbc, 0x5b, 0x7c, 0xb9, 0x18, 0xbb,
0x91, 0xcf, 0x19, 0x51, 0x61, 0xc3, 0x0d, 0xd1, 0x89, 0x78, 0xa8, 0x4a, 0x86, 0x64, 0x29, 0x83,
0x0c, 0x12, 0x02, 0x75, 0xe6, 0x8c, 0x50, 0xad, 0xc6, 0x74, 0x7c, 0x26, 0x06, 0x6c, 0x51, 0x14,
0x6e, 0xe8, 0x07, 0xbf, 0x66, 0xb5, 0x16, 0x5f, 0x15, 0xa9, 0x38, 0x0f, 0xfd, 0xa1, 0xcf, 0x3c,
0xb5, 0x9e, 0xe6, 0x25, 0x90, 0xb4, 0xa0, 0x41, 0x91, 0xf1, 0x91, 0xda, 0x88, 0xf9, 0x04, 0x10,
0x0d, 0x36, 0x87, 0xe8, 0x08, 0xbc, 0x64, 0x54, 0x95, 0x0d, 0xc9, 0xaa, 0x0f, 0x72, 0x6c, 0x9e,
0x41, 0xbb, 0x54, 0xec, 0x00, 0x45, 0xc0, 0x99, 0x40, 0xb2, 0x07, 0x8a, 0x93, 0x50, 0xd7, 0x34,
0x2d, 0x7b, 0x41, 0x98, 0x0e, 0x28, 0x89, 0xad, 0xe7, 0xd3, 0x15, 0xfd, 0x99, 0xd0, 0xcc, 0x3c,
0x8c, 0xe2, 0x24, 0xed, 0xb3, 0xc4, 0x91, 0x0e, 0xc8, 0xce, 0x88, 0x8f, 0x59, 0x94, 0xb6, 0x9a,
0x22, 0x73, 0x17, 0x76, 0xf2, 0x27, 0xb2, 0xaa, 0x4c, 0x0b, 0x9a, 0x7d, 0xe1, 0xdd, 0x70, 0xf7,
0xf9, 0x6a, 0xcc, 0xa8, 0x58, 0xfe, 0xb4, 0xd9, 0x81, 0x56, 0x51, 0x99, 0x25, 0x9c, 0xbc, 0x57,
0xa1, 0xd6, 0x17, 0x1e, 0x79, 0x04, 0x28, 0x7c, 0xd1, 0xa1, 0xfd, 0xe7, 0x67, 0xda, 0xa5, 0xd9,
0x68, 0xc7, 0xeb, 0xa8, 0xf2, 0x09, 0xde, 0x81, 0x9c, 0x0e, 0xc8, 0x58, 0xe9, 0xeb, 0xf9, 0x54,
0xb3, 0xfe, 0x53, 0xe4, 0xa9, 0x0f, 0xa0, 0x2c, 0xda, 0x3f, 0x58, 0x6e, 0xcb, 0x45, 0xda, 0xd1,
0x1a, 0xa2, 0x2c, 0xbe, 0x77, 0xfe, 0x39, 0xd3, 0xa5, 0xe9, 0x4c, 0x97, 0xbe, 0x67, 0xba, 0xf4,
0x36, 0xd7, 0x2b, 0xd3, 0xb9, 0x5e, 0xf9, 0x9a, 0xeb, 0x95, 0xfb, 0xfd, 0xcc, 0xdc, 0x9d, 0x74,
0xcb, 0x0b, 0xf1, 0x1a, 0xa0, 0x78, 0x92, 0xe3, 0xa5, 0x38, 0xfd, 0x09, 0x00, 0x00, 0xff, 0xff,
0x3b, 0x99, 0x2d, 0x8c, 0x2d, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -299,6 +384,7 @@ const _ = grpc.SupportPackageIsVersion4
type MsgClient interface {
NewAuction(ctx context.Context, in *MsgNewAuction, opts ...grpc.CallOption) (*MsgNewAuctionResponse, error)
NewBid(ctx context.Context, in *MsgNewBid, opts ...grpc.CallOption) (*MsgNewBidResponse, error)
LockFunds(ctx context.Context, in *MsgLockFunds, opts ...grpc.CallOption) (*MsgLockFundsResponse, error)
}
type msgClient struct {
@ -327,10 +413,20 @@ func (c *msgClient) NewBid(ctx context.Context, in *MsgNewBid, opts ...grpc.Call
return out, nil
}
func (c *msgClient) LockFunds(ctx context.Context, in *MsgLockFunds, opts ...grpc.CallOption) (*MsgLockFundsResponse, error) {
out := new(MsgLockFundsResponse)
err := c.cc.Invoke(ctx, "/colinear.colinearcore.Msg/LockFunds", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// MsgServer is the server API for Msg service.
type MsgServer interface {
NewAuction(context.Context, *MsgNewAuction) (*MsgNewAuctionResponse, error)
NewBid(context.Context, *MsgNewBid) (*MsgNewBidResponse, error)
LockFunds(context.Context, *MsgLockFunds) (*MsgLockFundsResponse, error)
}
// UnimplementedMsgServer can be embedded to have forward compatible implementations.
@ -343,6 +439,9 @@ func (*UnimplementedMsgServer) NewAuction(ctx context.Context, req *MsgNewAuctio
func (*UnimplementedMsgServer) NewBid(ctx context.Context, req *MsgNewBid) (*MsgNewBidResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method NewBid not implemented")
}
func (*UnimplementedMsgServer) LockFunds(ctx context.Context, req *MsgLockFunds) (*MsgLockFundsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method LockFunds not implemented")
}
func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
s.RegisterService(&_Msg_serviceDesc, srv)
@ -384,6 +483,24 @@ func _Msg_NewBid_Handler(srv interface{}, ctx context.Context, dec func(interfac
return interceptor(ctx, in, info, handler)
}
func _Msg_LockFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(MsgLockFunds)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(MsgServer).LockFunds(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/colinear.colinearcore.Msg/LockFunds",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(MsgServer).LockFunds(ctx, req.(*MsgLockFunds))
}
return interceptor(ctx, in, info, handler)
}
var _Msg_serviceDesc = grpc.ServiceDesc{
ServiceName: "colinear.colinearcore.Msg",
HandlerType: (*MsgServer)(nil),
@ -396,6 +513,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
MethodName: "NewBid",
Handler: _Msg_NewBid_Handler,
},
{
MethodName: "LockFunds",
Handler: _Msg_LockFunds_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "colinearcore/tx.proto",
@ -561,6 +682,59 @@ func (m *MsgNewBidResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *MsgLockFunds) 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 *MsgLockFunds) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgLockFunds) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Creator) > 0 {
i -= len(m.Creator)
copy(dAtA[i:], m.Creator)
i = encodeVarintTx(dAtA, i, uint64(len(m.Creator)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *MsgLockFundsResponse) 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 *MsgLockFundsResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *MsgLockFundsResponse) 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
@ -647,6 +821,28 @@ func (m *MsgNewBidResponse) Size() (n int) {
return n
}
func (m *MsgLockFunds) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Creator)
if l > 0 {
n += 1 + l + sovTx(uint64(l))
}
return n
}
func (m *MsgLockFundsResponse) 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
}
@ -1160,6 +1356,138 @@ func (m *MsgNewBidResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *MsgLockFunds) 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: MsgLockFunds: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgLockFunds: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthTx
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthTx
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Creator = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
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 *MsgLockFundsResponse) 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: MsgLockFundsResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: MsgLockFundsResponse: 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