Mirroristas/planetmint-go
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint-go.git synced 2025-03-30 15:08:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Switch BlockHeight to int64 (#158)

Browse Source 
To align with cosmos-sdk and make interoperability easier.

* Fix typo: blockheight -> blockHeight

* Generate protobuf and openapi

Signed-off-by: Julian Strobl <jmastr@mailbox.org>
This commit is contained in:
Julian Strobl 2023-10-20 13:43:44 +02:00 committed by GitHub
parent bed03197b5
commit 7d65bff35f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 124 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/ante/check_reissuance_decorator.go
View File

@ -22,7 +22,7 @@ func (cmad CheckReissuanceDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simu
if ok {
logger.Debug("REISSUE: receive Proposal")
conf := config.GetConfig()
isValid := dao.IsValidReissuanceCommand(MsgProposal.GetTx(), conf.ReissuanceAsset, MsgProposal.GetBlockheight())
isValid := dao.IsValidReissuanceCommand(MsgProposal.GetTx(), conf.ReissuanceAsset, MsgProposal.GetBlockHeight())
if !isValid {
logger.Debug("REISSUE: Invalid Proposal")
return ctx, errorsmod.Wrapf(daotypes.ErrReissuanceProposal, "error during CheckTx or ReCheckTx")

12
docs/static/openapi.yml vendored
View File

@ -46706,7 +46706,7 @@ paths:
type: string
blockHeight:
type: string
format: uint64
format: int64
default:
description: An unexpected error response.
schema:
@ -46730,7 +46730,7 @@ paths:
in: path
required: true
type: string
format: uint64
format: int64
tags:
- Query
/planetmint/dao/get_reissuances:
@ -46754,7 +46754,7 @@ paths:
type: string
blockHeight:
type: string
format: uint64
format: int64
pagination:
type: object
properties:
@ -76025,7 +76025,7 @@ definitions:
type: string
blockHeight:
type: string
format: uint64
format: int64
planetmintgo.dao.QueryGetReissuancesResponse:
type: object
properties:
@ -76040,7 +76040,7 @@ definitions:
type: string
blockHeight:
type: string
format: uint64
format: int64
pagination:
type: object
properties:
@ -76103,7 +76103,7 @@ definitions:
type: string
blockHeight:
type: string
format: uint64
format: int64
planetmintgo.machine.Machine:
type: object
properties:

2
proto/planetmintgo/dao/query.proto
View File

@ -72,7 +72,7 @@ message QueryMintRequestsByAddressResponse {
}
message QueryGetReissuanceRequest {
uint64 blockHeight = 1;
int64 blockHeight = 1;
}
message QueryGetReissuanceResponse {

2
proto/planetmintgo/dao/reissuance.proto
View File

@ -8,5 +8,5 @@ message Reissuance {
string proposer = 1;
string rawtx = 2;
string txId = 3;
uint64 blockHeight = 4;
int64 blockHeight = 4;
}

4
proto/planetmintgo/dao/tx.proto
View File

@ -16,7 +16,7 @@ message MsgReissueRDDLProposal {
string creator = 1;
string proposer = 2;
string tx = 3;
uint64 blockheight = 4;
int64 blockHeight = 4;
}
message MsgReissueRDDLProposalResponse {}
@ -32,7 +32,7 @@ message MsgReissueRDDLResult {
string creator = 1;
string proposer = 2;
string txId = 3;
uint64 blockHeight = 4;
int64 blockHeight = 4;
}
message MsgReissueRDDLResultResponse {}

4
util/issue_commands.go
View File

@ -35,14 +35,14 @@ func InitRDDLReissuanceProcess(ctx sdk.Context, proposerAddress string, tx_unsig
return err
}
func SendRDDLReissuanceResult(ctx sdk.Context, proposerAddress string, txID string, blk_height uint64) error {
func SendRDDLReissuanceResult(ctx sdk.Context, proposerAddress string, txID string, blk_height int64) error {
logger := ctx.Logger()
// Construct the command
sending_validator_address := config.GetConfig().ValidatorAddress
logger.Debug("REISSUE: create Result")
cmd := exec.Command("planetmint-god", "tx", "dao", "reissue-rddl-result",
"--from", sending_validator_address, "-y",
proposerAddress, txID, strconv.FormatUint(blk_height, 10))
proposerAddress, txID, strconv.FormatInt(blk_height, 10))
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout

2
x/dao/client/cli/query_get_reissuance.go
View File

@ -18,7 +18,7 @@ func CmdGetReissuance() *cobra.Command {
Short: "Query get_reissuance",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) (err error) {
reqBlockHeight, err := cast.ToUint64E(args[0])
reqBlockHeight, err := cast.ToInt64E(args[0])
if err != nil {
return err
}

4
x/dao/client/cli/tx_reissue_rddl_proposal.go
View File

@ -21,7 +21,7 @@ func CmdReissueRDDLProposal() *cobra.Command {
RunE: func(cmd *cobra.Command, args []string) (err error) {
argProposer := args[0]
argTx := args[1]
argBlockheight, err := cast.ToUint64E(args[2])
argBlockHeight, err := cast.ToInt64E(args[2])
if err != nil {
return err
}
@ -35,7 +35,7 @@ func CmdReissueRDDLProposal() *cobra.Command {
clientCtx.GetFromAddress().String(),
argProposer,
argTx,
argBlockheight,
argBlockHeight,
)
if err := msg.ValidateBasic(); err != nil {
return err

2
x/dao/client/cli/tx_reissue_rddl_result.go
View File

@ -21,7 +21,7 @@ func CmdReissueRDDLResult() *cobra.Command {
RunE: func(cmd *cobra.Command, args []string) (err error) {
argProposer := args[0]
argTxId := args[1]
argBlockHeight, err := cast.ToUint64E(args[2])
argBlockHeight, err := cast.ToInt64E(args[2])
if err != nil {
return err
}

4
x/dao/keeper/msg_server_reissue_rddl_proposal.go
View File

@ -20,7 +20,7 @@ func (k msgServer) ReissueRDDLProposal(goCtx context.Context, msg *types.MsgReis
txID, err := util.ReissueAsset(msg.Tx)
if err == nil {
// 3. notarize result by notarizing the liquid tx-id
_ = util.SendRDDLReissuanceResult(ctx, msg.GetProposer(), txID, msg.GetBlockheight())
_ = util.SendRDDLReissuanceResult(ctx, msg.GetProposer(), txID, msg.GetBlockHeight())
//TODO verify and resolve error
} else {
logger.Debug("REISSUE: Asset reissuance failure")
@ -29,7 +29,7 @@ func (k msgServer) ReissueRDDLProposal(goCtx context.Context, msg *types.MsgReis
}
var reissuance types.Reissuance
reissuance.BlockHeight = msg.GetBlockheight()
reissuance.BlockHeight = msg.GetBlockHeight()
reissuance.Proposer = msg.GetProposer()
reissuance.Rawtx = msg.GetTx()
k.StoreReissuance(ctx, reissuance)

8
x/dao/keeper/msg_server_reissue_rddl_result.go
View File

@ -14,16 +14,16 @@ func (k msgServer) ReissueRDDLResult(goCtx context.Context, msg *types.MsgReissu
reissuance, found := k.LookupReissuance(ctx, msg.GetBlockHeight())
if !found {
return nil, errorsmod.Wrapf(types.ErrReissuanceNotFound, " for provided block height %s", strconv.FormatUint(msg.GetBlockHeight(), 10))
return nil, errorsmod.Wrapf(types.ErrReissuanceNotFound, " for provided block height %s", strconv.FormatInt(msg.GetBlockHeight(), 10))
}
if reissuance.GetBlockHeight() != msg.GetBlockHeight() {
return nil, errorsmod.Wrapf(types.ErrWrongBlockHeight, " for provided block height %s", strconv.FormatUint(msg.GetBlockHeight(), 10))
return nil, errorsmod.Wrapf(types.ErrWrongBlockHeight, " for provided block height %s", strconv.FormatInt(msg.GetBlockHeight(), 10))
}
if reissuance.GetProposer() != msg.GetProposer() {
return nil, errorsmod.Wrapf(types.ErrInvalidProposer, " for provided block height %s", strconv.FormatUint(msg.GetBlockHeight(), 10))
return nil, errorsmod.Wrapf(types.ErrInvalidProposer, " for provided block height %s", strconv.FormatInt(msg.GetBlockHeight(), 10))
}
if reissuance.GetTxId() != "" {
return nil, errorsmod.Wrapf(types.ErrTXAlreadySet, " for provided block height %s", strconv.FormatUint(msg.GetBlockHeight(), 10))
return nil, errorsmod.Wrapf(types.ErrTXAlreadySet, " for provided block height %s", strconv.FormatInt(msg.GetBlockHeight(), 10))
}
reissuance.TxId = msg.GetTxId()
k.StoreReissuance(ctx, reissuance)

6
x/dao/keeper/reissuance.go
View File

@ -14,7 +14,7 @@ func (k Keeper) StoreReissuance(ctx sdk.Context, reissuance types.Reissuance) {
store.Set(getReissuanceBytes(reissuance.BlockHeight), appendValue)
}
func (k Keeper) LookupReissuance(ctx sdk.Context, height uint64) (val types.Reissuance, found bool) {
func (k Keeper) LookupReissuance(ctx sdk.Context, height int64) (val types.Reissuance, found bool) {
store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.ReissuanceBlockHeightKey))
reissuance := store.Get(getReissuanceBytes(height))
if reissuance == nil {
@ -43,7 +43,7 @@ func (k Keeper) getReissuancesPage(ctx sdk.Context, key []byte, offset uint64, p
return reissuances
}
func getReissuanceBytes(height uint64) []byte {
func getReissuanceBytes(height int64) []byte {
// Adding 1 because 0 will be interpreted as nil, which is an invalid key
return big.NewInt(int64(height + 1)).Bytes()
return big.NewInt(height + 1).Bytes()
}

2
x/dao/keeper/reissuance_test.go
View File

@ -15,7 +15,7 @@ import (
func createNReissuances(keeper *keeper.Keeper, ctx sdk.Context, n int) []types.Reissuance {
items := make([]types.Reissuance, n)
for i := range items {
items[i].BlockHeight = uint64(i)
items[i].BlockHeight = int64(i)
items[i].Proposer = fmt.Sprintf("proposer_%v", i)
items[i].Rawtx = fmt.Sprintf("rawtransaction_%v", i)
items[i].TxId = ""

4
x/dao/types/message_reissue_rddl_proposal.go
View File

@ -10,12 +10,12 @@ const TypeMsgReissueRDDLProposal = "reissue_rddl_proposal"
var _ sdk.Msg = &MsgReissueRDDLProposal{}
func NewMsgReissueRDDLProposal(creator string, proposer string, tx string, blockheight uint64) *MsgReissueRDDLProposal {
func NewMsgReissueRDDLProposal(creator string, proposer string, tx string, blockHeight int64) *MsgReissueRDDLProposal {
return &MsgReissueRDDLProposal{
Creator: creator,
Proposer: proposer,
Tx: tx,
Blockheight: blockheight,
BlockHeight: blockHeight,
}
}

2
x/dao/types/message_reissue_rddl_result.go
View File

@ -10,7 +10,7 @@ const TypeMsgReissueRDDLResult = "reissue_rddl_result"
var _ sdk.Msg = &MsgReissueRDDLResult{}
func NewMsgReissueRDDLResult(creator string, proposer string, txId string, blockHeight uint64) *MsgReissueRDDLResult {
func NewMsgReissueRDDLResult(creator string, proposer string, txId string, blockHeight int64) *MsgReissueRDDLResult {
return &MsgReissueRDDLResult{
Creator: creator,
Proposer: proposer,

94
x/dao/types/query.pb.go
View File

@ -290,7 +290,7 @@ func (m *QueryMintRequestsByAddressResponse) GetMintRequests() *MintRequests {
}
type QueryGetReissuanceRequest struct {
BlockHeight uint64 `protobuf:"varint,1,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
BlockHeight int64 `protobuf:"varint,1,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
}
func (m *QueryGetReissuanceRequest) Reset() { *m = QueryGetReissuanceRequest{} }
@ -326,7 +326,7 @@ func (m *QueryGetReissuanceRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_QueryGetReissuanceRequest proto.InternalMessageInfo
func (m *QueryGetReissuanceRequest) GetBlockHeight() uint64 {
func (m *QueryGetReissuanceRequest) GetBlockHeight() int64 {
if m != nil {
return m.BlockHeight
}
@ -489,50 +489,50 @@ func init() {
func init() { proto.RegisterFile("planetmintgo/dao/query.proto", fileDescriptor_07bad0eeb5b27724) }
var fileDescriptor_07bad0eeb5b27724 = []byte{
// 687 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0x41, 0x4f, 0x13, 0x41,
0x14, 0xc7, 0xbb, 0x04, 0x6b, 0x7c, 0xa8, 0x31, 0x23, 0x98, 0x5a, 0x61, 0x81, 0x11, 0xc5, 0x28,
0xec, 0x48, 0x21, 0x6a, 0x8c, 0xc4, 0xd8, 0x83, 0xe0, 0x81, 0x04, 0xf7, 0xc8, 0xa5, 0x99, 0xb6,
0x93, 0xed, 0x46, 0xba, 0xb3, 0x74, 0xb6, 0xc6, 0x86, 0x70, 0xf1, 0x13, 0x98, 0x98, 0x78, 0xf6,
0xe0, 0xa7, 0x30, 0xc6, 0x33, 0x47, 0x12, 0x2f, 0x9e, 0x8c, 0x01, 0x3f, 0x88, 0xe9, 0xcc, 0x2c,
0x9d, 0x65, 0xb7, 0x4b, 0x4d, 0xbc, 0x90, 0xd9, 0x9d, 0xff, 0xff, 0xbd, 0xdf, 0x3e, 0xe6, 0x3f,
0x85, 0xe9, 0x70, 0x97, 0x06, 0x2c, 0x6a, 0xfb, 0x41, 0xe4, 0x71, 0xd2, 0xa4, 0x9c, 0xec, 0x75,
0x59, 0xa7, 0xe7, 0x84, 0x1d, 0x1e, 0x71, 0x74, 0xcd, 0xdc, 0x75, 0x9a, 0x94, 0x97, 0x27, 0x3d,
0xee, 0x71, 0xb9, 0x49, 0xfa, 0x2b, 0xa5, 0x2b, 0x4f, 0x7b, 0x9c, 0x7b, 0xbb, 0x8c, 0xd0, 0xd0,
0x27, 0x34, 0x08, 0x78, 0x44, 0x23, 0x9f, 0x07, 0x42, 0xef, 0xde, 0x6f, 0x70, 0xd1, 0xe6, 0x82,
0xd4, 0xa9, 0x60, 0xaa, 0x3c, 0x79, 0xbb, 0x52, 0x67, 0x11, 0x5d, 0x21, 0x21, 0xf5, 0xfc, 0x40,
0x8a, 0xb5, 0x76, 0x26, 0xc5, 0x13, 0xd2, 0x0e, 0x6d, 0xc7, 0xa5, 0x6e, 0xa7, 0xb6, 0xfb, 0xcb,
0x5a, 0x87, 0xed, 0x75, 0x99, 0x88, 0xb4, 0x68, 0x21, 0x57, 0x14, 0x97, 0x9a, 0x4f, 0xa9, 0x3a,
0xcc, 0x17, 0xa2, 0x4b, 0x83, 0x06, 0x53, 0x12, 0x3c, 0x09, 0xe8, 0x75, 0x1f, 0x77, 0x5b, 0x22,
0xb8, 0xca, 0x8f, 0xb7, 0xe0, 0x7a, 0xe2, 0xad, 0x08, 0x79, 0x20, 0x18, 0x7a, 0x04, 0x45, 0x85,
0x5a, 0xb2, 0xe6, 0xac, 0x7b, 0x13, 0x95, 0x92, 0x73, 0x76, 0x78, 0x8e, 0x72, 0x54, 0xc7, 0x0f,
0x7f, 0xcd, 0x16, 0x5c, 0xad, 0xc6, 0x8f, 0x61, 0x5e, 0x96, 0xdb, 0x60, 0xd1, 0x96, 0x1f, 0x44,
0xba, 0x8b, 0xa8, 0xf6, 0x36, 0xa9, 0x68, 0xe9, 0x27, 0x84, 0x60, 0xbc, 0x45, 0x45, 0x4b, 0x96,
0xbe, 0xe4, 0xca, 0x35, 0x66, 0x80, 0xf3, 0x8c, 0x1a, 0xeb, 0x39, 0x4c, 0xb4, 0x07, 0xbb, 0x9a,
0x6d, 0x26, 0xcd, 0x66, 0x94, 0x70, 0x4d, 0x07, 0x5e, 0xd7, 0x7c, 0xc9, 0x1e, 0x2f, 0x9a, 0xcd,
0x0e, 0x13, 0xf1, 0x4c, 0x50, 0x09, 0x2e, 0x52, 0xf5, 0x46, 0x23, 0xc6, 0x8f, 0xb8, 0xa5, 0x29,
0x87, 0xd8, 0x35, 0x65, 0x15, 0x2e, 0x1b, 0x3d, 0xe3, 0x11, 0xda, 0xb9, 0x98, 0xc2, 0x4d, 0x78,
0xf0, 0x3a, 0xdc, 0x8c, 0xe7, 0xe1, 0x9e, 0xfe, 0x27, 0x63, 0xc0, 0x39, 0x98, 0xa8, 0xef, 0xf2,
0xc6, 0x9b, 0x4d, 0xe6, 0x7b, 0x2d, 0x35, 0x86, 0x71, 0xd7, 0x7c, 0x85, 0x77, 0xa0, 0x9c, 0x65,
0xd7, 0x80, 0xcf, 0x00, 0x06, 0xc7, 0x43, 0xe3, 0x4d, 0xa7, 0xf1, 0x0c, 0xa7, 0xa1, 0xc7, 0xcd,
0xac, 0xda, 0xa7, 0xc3, 0x7b, 0x09, 0x30, 0xc8, 0x81, 0xae, 0x7d, 0xd7, 0x51, 0xa1, 0x71, 0xfa,
0xa1, 0x71, 0x54, 0x26, 0x75, 0x68, 0x9c, 0x6d, 0xea, 0xc5, 0xdf, 0xe5, 0x1a, 0x4e, 0xfc, 0xc5,
0x82, 0x5b, 0x99, 0x6d, 0xfe, 0xc7, 0x37, 0xa0, 0x8d, 0x04, 0xe5, 0x98, 0x74, 0x2f, 0x9e, 0x4b,
0xa9, 0x5a, 0x9b, 0x98, 0x95, 0xaf, 0x45, 0xb8, 0x20, 0x31, 0x51, 0x17, 0x8a, 0x2a, 0x12, 0x68,
0x21, 0x8d, 0x91, 0x4e, 0x5e, 0xf9, 0xce, 0x39, 0x2a, 0xd5, 0x0c, 0xdb, 0xef, 0x7f, 0xfc, 0xf9,
0x38, 0x56, 0x42, 0x37, 0xc8, 0x40, 0x6e, 0x5c, 0x25, 0xe8, 0x9b, 0x05, 0x53, 0x99, 0xa1, 0x41,
0xab, 0x43, 0x1a, 0xe4, 0x65, 0xb3, 0xbc, 0xf6, 0x6f, 0x26, 0x0d, 0xf9, 0x44, 0x42, 0x56, 0xd0,
0xc3, 0xb3, 0x90, 0x1e, 0x8b, 0x6a, 0x89, 0xfb, 0xaa, 0x56, 0xef, 0xd5, 0xfa, 0x81, 0x27, 0xfb,
0xfd, 0xbf, 0x07, 0xe8, 0xbb, 0x05, 0x53, 0x99, 0x69, 0x1a, 0x8a, 0x9f, 0x17, 0xdd, 0xa1, 0xf8,
0xb9, 0x81, 0xc5, 0x4f, 0x25, 0xfe, 0x1a, 0xaa, 0x9c, 0xc5, 0x4f, 0xa1, 0xeb, 0x8b, 0x80, 0xec,
0xeb, 0xc5, 0x01, 0xfa, 0x6c, 0xc1, 0x95, 0xc4, 0x11, 0x45, 0x0f, 0x86, 0x8f, 0x30, 0x15, 0xe5,
0xf2, 0xd2, 0x68, 0x62, 0x0d, 0xba, 0x26, 0x41, 0x1d, 0xb4, 0x94, 0x35, 0xe7, 0xc1, 0xf1, 0x26,
0xfb, 0xc6, 0x5d, 0x70, 0x80, 0x3e, 0x59, 0x70, 0x35, 0x99, 0x22, 0x34, 0x52, 0xdb, 0xd3, 0xa9,
0x2e, 0x8f, 0xa8, 0xd6, 0x94, 0x8b, 0x92, 0x72, 0x1e, 0xcd, 0xe6, 0x53, 0x8a, 0xea, 0xab, 0xc3,
0x63, 0xdb, 0x3a, 0x3a, 0xb6, 0xad, 0xdf, 0xc7, 0xb6, 0xf5, 0xe1, 0xc4, 0x2e, 0x1c, 0x9d, 0xd8,
0x85, 0x9f, 0x27, 0x76, 0x61, 0x87, 0x78, 0x7e, 0xd4, 0xea, 0xd6, 0x9d, 0x06, 0x6f, 0x9b, 0x45,
0x06, 0xcb, 0x65, 0x8f, 0x93, 0x77, 0xb2, 0x68, 0xd4, 0x0b, 0x99, 0xa8, 0x17, 0xe5, 0x8f, 0xdc,
0xea, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8c, 0xde, 0x16, 0xfc, 0x03, 0x08, 0x00, 0x00,
// 688 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0x41, 0x4f, 0x13, 0x4f,
0x18, 0xc6, 0xbb, 0xfc, 0xf9, 0xd7, 0xf8, 0xa2, 0xc6, 0x8c, 0x60, 0x6a, 0x85, 0x05, 0x46, 0x14,
0xa3, 0xb0, 0x23, 0x85, 0xa8, 0x31, 0x12, 0x63, 0x0f, 0x82, 0x07, 0x12, 0xdc, 0x23, 0x97, 0x66,
0xda, 0x4e, 0xb6, 0x1b, 0xe9, 0xce, 0xd2, 0xd9, 0x1a, 0x1b, 0xc2, 0xc5, 0x4f, 0x60, 0x62, 0xe2,
0xd9, 0x83, 0x9f, 0xc2, 0x18, 0xcf, 0x1c, 0x49, 0xbc, 0x78, 0x32, 0x06, 0xfc, 0x20, 0xa6, 0x33,
0xb3, 0x74, 0x96, 0xdd, 0x2e, 0x35, 0xf1, 0x42, 0x66, 0x77, 0x9e, 0xe7, 0x7d, 0x7f, 0xfb, 0x32,
0xcf, 0x14, 0xa6, 0xc3, 0x5d, 0x1a, 0xb0, 0xa8, 0xed, 0x07, 0x91, 0xc7, 0x49, 0x93, 0x72, 0xb2,
0xd7, 0x65, 0x9d, 0x9e, 0x13, 0x76, 0x78, 0xc4, 0xd1, 0x55, 0x73, 0xd7, 0x69, 0x52, 0x5e, 0x9e,
0xf4, 0xb8, 0xc7, 0xe5, 0x26, 0xe9, 0xaf, 0x94, 0xae, 0x3c, 0xed, 0x71, 0xee, 0xed, 0x32, 0x42,
0x43, 0x9f, 0xd0, 0x20, 0xe0, 0x11, 0x8d, 0x7c, 0x1e, 0x08, 0xbd, 0x7b, 0xaf, 0xc1, 0x45, 0x9b,
0x0b, 0x52, 0xa7, 0x82, 0xa9, 0xf2, 0xe4, 0xcd, 0x4a, 0x9d, 0x45, 0x74, 0x85, 0x84, 0xd4, 0xf3,
0x03, 0x29, 0xd6, 0xda, 0x99, 0x14, 0x4f, 0x48, 0x3b, 0xb4, 0x1d, 0x97, 0xba, 0x95, 0xda, 0xee,
0x2f, 0x6b, 0x1d, 0xb6, 0xd7, 0x65, 0x22, 0xd2, 0xa2, 0x85, 0x5c, 0x51, 0x5c, 0x6a, 0x3e, 0xa5,
0xea, 0x30, 0x5f, 0x88, 0x2e, 0x0d, 0x1a, 0x4c, 0x49, 0xf0, 0x24, 0xa0, 0x57, 0x7d, 0xdc, 0x6d,
0x89, 0xe0, 0x2a, 0x3f, 0xde, 0x82, 0x6b, 0x89, 0xb7, 0x22, 0xe4, 0x81, 0x60, 0xe8, 0x21, 0x14,
0x15, 0x6a, 0xc9, 0x9a, 0xb3, 0xee, 0x4e, 0x54, 0x4a, 0xce, 0xd9, 0xe1, 0x39, 0xca, 0x51, 0x1d,
0x3f, 0xfc, 0x39, 0x5b, 0x70, 0xb5, 0x1a, 0x3f, 0x82, 0x79, 0x59, 0x6e, 0x83, 0x45, 0x5b, 0x7e,
0x10, 0xe9, 0x2e, 0xa2, 0xda, 0xdb, 0xa4, 0xa2, 0xa5, 0x9f, 0x10, 0x82, 0xf1, 0x16, 0x15, 0x2d,
0x59, 0xfa, 0xa2, 0x2b, 0xd7, 0x98, 0x01, 0xce, 0x33, 0x6a, 0xac, 0x67, 0x30, 0xd1, 0x1e, 0xec,
0x6a, 0xb6, 0x99, 0x34, 0x9b, 0x51, 0xc2, 0x35, 0x1d, 0x78, 0x5d, 0xf3, 0x25, 0x7b, 0x3c, 0x6f,
0x36, 0x3b, 0x4c, 0xc4, 0x33, 0x41, 0x25, 0xb8, 0x40, 0xd5, 0x1b, 0x8d, 0x18, 0x3f, 0xe2, 0x96,
0xa6, 0x1c, 0x62, 0xd7, 0x94, 0x55, 0xb8, 0x64, 0xf4, 0x8c, 0x47, 0x68, 0xe7, 0x62, 0x0a, 0x37,
0xe1, 0xc1, 0xeb, 0x70, 0x23, 0x9e, 0x87, 0x7b, 0xfa, 0x9f, 0x8c, 0x01, 0xe7, 0x60, 0xa2, 0xbe,
0xcb, 0x1b, 0xaf, 0x37, 0x99, 0xef, 0xb5, 0xd4, 0x18, 0xfe, 0x73, 0xcd, 0x57, 0x78, 0x07, 0xca,
0x59, 0x76, 0x0d, 0xf8, 0x14, 0x60, 0x70, 0x3c, 0x34, 0xde, 0x74, 0x1a, 0xcf, 0x70, 0x1a, 0x7a,
0xdc, 0xcc, 0xaa, 0x7d, 0x3a, 0xbc, 0x17, 0x00, 0x83, 0x1c, 0xe8, 0xda, 0x77, 0x1c, 0x15, 0x1a,
0xa7, 0x1f, 0x1a, 0x47, 0x65, 0x52, 0x87, 0xc6, 0xd9, 0xa6, 0x5e, 0xfc, 0x5d, 0xae, 0xe1, 0xc4,
0x9f, 0x2d, 0xb8, 0x99, 0xd9, 0xe6, 0x5f, 0x7c, 0x03, 0xda, 0x48, 0x50, 0x8e, 0x49, 0xf7, 0xe2,
0xb9, 0x94, 0xaa, 0xb5, 0x89, 0x59, 0xf9, 0x52, 0x84, 0xff, 0x25, 0x26, 0xea, 0x42, 0x51, 0x45,
0x02, 0x2d, 0xa4, 0x31, 0xd2, 0xc9, 0x2b, 0xdf, 0x3e, 0x47, 0xa5, 0x9a, 0x61, 0xfb, 0xdd, 0xf7,
0xdf, 0x1f, 0xc6, 0x4a, 0xe8, 0x3a, 0x19, 0xc8, 0x8d, 0xab, 0x04, 0x7d, 0xb5, 0x60, 0x2a, 0x33,
0x34, 0x68, 0x75, 0x48, 0x83, 0xbc, 0x6c, 0x96, 0xd7, 0xfe, 0xce, 0xa4, 0x21, 0x1f, 0x4b, 0xc8,
0x0a, 0x7a, 0x70, 0x16, 0xd2, 0x63, 0x51, 0x2d, 0x71, 0x5f, 0xd5, 0xea, 0xbd, 0x5a, 0x3f, 0xf0,
0x64, 0xbf, 0xff, 0xf7, 0x00, 0x7d, 0xb3, 0x60, 0x2a, 0x33, 0x4d, 0x43, 0xf1, 0xf3, 0xa2, 0x3b,
0x14, 0x3f, 0x37, 0xb0, 0xf8, 0x89, 0xc4, 0x5f, 0x43, 0x95, 0xb3, 0xf8, 0x29, 0x74, 0x7d, 0x11,
0x90, 0x7d, 0xbd, 0x38, 0x40, 0x9f, 0x2c, 0xb8, 0x9c, 0x38, 0xa2, 0xe8, 0xfe, 0xf0, 0x11, 0xa6,
0xa2, 0x5c, 0x5e, 0x1a, 0x4d, 0xac, 0x41, 0xd7, 0x24, 0xa8, 0x83, 0x96, 0xb2, 0xe6, 0x3c, 0x38,
0xde, 0x64, 0xdf, 0xb8, 0x0b, 0x0e, 0xd0, 0x47, 0x0b, 0xae, 0x24, 0x53, 0x84, 0x46, 0x6a, 0x7b,
0x3a, 0xd5, 0xe5, 0x11, 0xd5, 0x9a, 0x72, 0x51, 0x52, 0xce, 0xa3, 0xd9, 0x7c, 0x4a, 0x51, 0x7d,
0x79, 0x78, 0x6c, 0x5b, 0x47, 0xc7, 0xb6, 0xf5, 0xeb, 0xd8, 0xb6, 0xde, 0x9f, 0xd8, 0x85, 0xa3,
0x13, 0xbb, 0xf0, 0xe3, 0xc4, 0x2e, 0xec, 0x10, 0xcf, 0x8f, 0x5a, 0xdd, 0xba, 0xd3, 0xe0, 0x6d,
0xb3, 0xc8, 0x60, 0xb9, 0xec, 0x71, 0xf2, 0x56, 0x16, 0x8d, 0x7a, 0x21, 0x13, 0xf5, 0xa2, 0xfc,
0x91, 0x5b, 0xfd, 0x13, 0x00, 0x00, 0xff, 0xff, 0xa8, 0x67, 0x9b, 0xdb, 0x03, 0x08, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -1756,7 +1756,7 @@ func (m *QueryGetReissuanceRequest) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.BlockHeight |= uint64(b&0x7F) << shift
m.BlockHeight |= int64(b&0x7F) << shift
if b < 0x80 {
break
}

4
x/dao/types/query.pb.gw.go
View File

@ -175,7 +175,7 @@ func request_Query_GetReissuance_0(ctx context.Context, marshaler runtime.Marsha
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "blockHeight")
}
protoReq.BlockHeight, err = runtime.Uint64(val)
protoReq.BlockHeight, err = runtime.Int64(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "blockHeight", err)
@ -202,7 +202,7 @@ func local_request_Query_GetReissuance_0(ctx context.Context, marshaler runtime.
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "blockHeight")
}
protoReq.BlockHeight, err = runtime.Uint64(val)
protoReq.BlockHeight, err = runtime.Int64(val)
if err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "blockHeight", err)

10
x/dao/types/reissuance.pb.go
View File

@ -26,7 +26,7 @@ type Reissuance struct {
Proposer string `protobuf:"bytes,1,opt,name=proposer,proto3" json:"proposer,omitempty"`
Rawtx string `protobuf:"bytes,2,opt,name=rawtx,proto3" json:"rawtx,omitempty"`
TxId string `protobuf:"bytes,3,opt,name=txId,proto3" json:"txId,omitempty"`
BlockHeight uint64 `protobuf:"varint,4,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
BlockHeight int64 `protobuf:"varint,4,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
}
func (m *Reissuance) Reset() { *m = Reissuance{} }
@ -83,7 +83,7 @@ func (m *Reissuance) GetTxId() string {
return ""
}
func (m *Reissuance) GetBlockHeight() uint64 {
func (m *Reissuance) GetBlockHeight() int64 {
if m != nil {
return m.BlockHeight
}
@ -106,11 +106,11 @@ var fileDescriptor_35cf062bd4436e27 = []byte{
0xe7, 0x0b, 0x89, 0x70, 0xb1, 0x16, 0x25, 0x96, 0x97, 0x54, 0x48, 0x30, 0x81, 0x25, 0x20, 0x1c,
0x21, 0x21, 0x2e, 0x96, 0x92, 0x0a, 0xcf, 0x14, 0x09, 0x66, 0xb0, 0x20, 0x98, 0x2d, 0xa4, 0xc0,
0xc5, 0x9d, 0x94, 0x93, 0x9f, 0x9c, 0xed, 0x91, 0x9a, 0x99, 0x9e, 0x51, 0x22, 0xc1, 0xa2, 0xc0,
0xa8, 0xc1, 0x12, 0x84, 0x2c, 0xe4, 0xe4, 0x79, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c,
0xa8, 0xc1, 0x1c, 0x84, 0x2c, 0xe4, 0xe4, 0x79, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c,
0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72,
0x0c, 0x51, 0xfa, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x08, 0xc7,
0x22, 0x31, 0x75, 0xd3, 0xf3, 0xf5, 0x2b, 0xc0, 0xbe, 0x2b, 0xa9, 0x2c, 0x48, 0x2d, 0x4e, 0x62,
0x03, 0xfb, 0xcc, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x81, 0xd2, 0xf6, 0x5d, 0xfe, 0x00, 0x00,
0x03, 0xfb, 0xcc, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0xb7, 0xaf, 0x8f, 0xce, 0xfe, 0x00, 0x00,
0x00,
}
@ -343,7 +343,7 @@ func (m *Reissuance) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.BlockHeight |= uint64(b&0x7F) << shift
m.BlockHeight |= int64(b&0x7F) << shift
if b < 0x80 {
break
}

78
x/dao/types/tx.pb.go
View File

@ -31,7 +31,7 @@ type MsgReissueRDDLProposal struct {
Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
Proposer string `protobuf:"bytes,2,opt,name=proposer,proto3" json:"proposer,omitempty"`
Tx string `protobuf:"bytes,3,opt,name=tx,proto3" json:"tx,omitempty"`
Blockheight uint64 `protobuf:"varint,4,opt,name=blockheight,proto3" json:"blockheight,omitempty"`
BlockHeight int64 `protobuf:"varint,4,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
}
func (m *MsgReissueRDDLProposal) Reset() { *m = MsgReissueRDDLProposal{} }
@ -88,9 +88,9 @@ func (m *MsgReissueRDDLProposal) GetTx() string {
return ""
}
func (m *MsgReissueRDDLProposal) GetBlockheight() uint64 {
func (m *MsgReissueRDDLProposal) GetBlockHeight() int64 {
if m != nil {
return m.Blockheight
return m.BlockHeight
}
return 0
}
@ -223,7 +223,7 @@ type MsgReissueRDDLResult struct {
Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"`
Proposer string `protobuf:"bytes,2,opt,name=proposer,proto3" json:"proposer,omitempty"`
TxId string `protobuf:"bytes,3,opt,name=txId,proto3" json:"txId,omitempty"`
BlockHeight uint64 `protobuf:"varint,4,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
BlockHeight int64 `protobuf:"varint,4,opt,name=blockHeight,proto3" json:"blockHeight,omitempty"`
}
func (m *MsgReissueRDDLResult) Reset() { *m = MsgReissueRDDLResult{} }
@ -280,7 +280,7 @@ func (m *MsgReissueRDDLResult) GetTxId() string {
return ""
}
func (m *MsgReissueRDDLResult) GetBlockHeight() uint64 {
func (m *MsgReissueRDDLResult) GetBlockHeight() int64 {
if m != nil {
return m.BlockHeight
}
@ -335,32 +335,32 @@ func init() {
func init() { proto.RegisterFile("planetmintgo/dao/tx.proto", fileDescriptor_7117c47dbc1828c7) }
var fileDescriptor_7117c47dbc1828c7 = []byte{
// 400 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x53, 0xc1, 0x6a, 0xdb, 0x40,
0x10, 0xf5, 0xca, 0xa6, 0xad, 0xc7, 0xa5, 0xb4, 0xdb, 0x62, 0x54, 0xd1, 0x2e, 0x42, 0x01, 0xe3,
0x4b, 0xa4, 0xe0, 0x7c, 0x40, 0x20, 0xf8, 0x10, 0x43, 0x04, 0x61, 0x93, 0x53, 0x2e, 0x41, 0xb6,
0x17, 0x59, 0x58, 0xd6, 0xca, 0xda, 0x15, 0x28, 0xb7, 0x90, 0x2f, 0xc8, 0xf7, 0xe4, 0x0b, 0x72,
0xf4, 0x31, 0xc7, 0x60, 0xff, 0x48, 0xb0, 0x14, 0xc9, 0x22, 0x16, 0x8e, 0xc9, 0x6d, 0x76, 0xde,
0x9b, 0x9d, 0x37, 0x6f, 0x18, 0xf8, 0x1b, 0xfa, 0x4e, 0xc0, 0xe4, 0xcc, 0x0b, 0xa4, 0xcb, 0xad,
0xb1, 0xc3, 0x2d, 0x99, 0x98, 0x61, 0xc4, 0x25, 0xc7, 0x3f, 0xcb, 0x90, 0x39, 0x76, 0xb8, 0x76,
0xb0, 0x45, 0x5e, 0x87, 0x37, 0x11, 0x9b, 0xc7, 0x4c, 0xc8, 0xac, 0xcc, 0xb8, 0x43, 0xd0, 0xb6,
0x85, 0x4b, 0x99, 0x27, 0x44, 0xcc, 0x68, 0xbf, 0x7f, 0x7e, 0x11, 0xf1, 0x90, 0x0b, 0xc7, 0xc7,
0x2a, 0x7c, 0x1d, 0x45, 0xcc, 0x91, 0x3c, 0x52, 0x91, 0x8e, 0xba, 0x4d, 0x9a, 0x3f, 0xb1, 0x06,
0xdf, 0xc2, 0x94, 0xc5, 0x22, 0x55, 0x49, 0xa1, 0xe2, 0x8d, 0x7f, 0x80, 0x22, 0x13, 0xb5, 0x9e,
0x66, 0x15, 0x99, 0x60, 0x1d, 0x5a, 0x43, 0x9f, 0x8f, 0xa6, 0x13, 0xe6, 0xb9, 0x13, 0xa9, 0x36,
0x74, 0xd4, 0x6d, 0xd0, 0x72, 0xca, 0xd0, 0x81, 0x54, 0x2b, 0xa0, 0x4c, 0x84, 0x3c, 0x10, 0xcc,
0xf0, 0xe0, 0xbb, 0x2d, 0x5c, 0xdb, 0x0b, 0xe4, 0x15, 0x9f, 0xb2, 0x60, 0x87, 0xb2, 0x13, 0x68,
0xad, 0x87, 0xa4, 0xd9, 0x8c, 0xa9, 0xb8, 0x56, 0xef, 0xbf, 0xf9, 0xde, 0x1b, 0xd3, 0xde, 0x90,
0x68, 0xb9, 0xc2, 0x68, 0xc3, 0x9f, 0x72, 0xab, 0x42, 0xc2, 0x3d, 0x4a, 0x81, 0x92, 0x4a, 0xca,
0x44, 0xec, 0xcb, 0x4f, 0xba, 0x84, 0xa1, 0x21, 0x93, 0xc1, 0xf8, 0xcd, 0xa7, 0x34, 0x2e, 0x9c,
0x3a, 0xdb, 0x76, 0x2a, 0x4b, 0x19, 0x04, 0xfe, 0x55, 0x69, 0xc8, 0x45, 0xf6, 0x1e, 0x15, 0xa8,
0xdb, 0xc2, 0xc5, 0x73, 0xf8, 0x5d, 0xb5, 0xd0, 0x6e, 0x85, 0x0f, 0x95, 0xc6, 0x6b, 0x47, 0xfb,
0x32, 0xf3, 0xd6, 0xf8, 0x12, 0x9a, 0x9b, 0xfd, 0x90, 0xca, 0xf2, 0x02, 0xd7, 0x3a, 0xbb, 0xf1,
0xe2, 0xd3, 0x29, 0xfc, 0xda, 0x36, 0xbc, 0xf3, 0x91, 0xb6, 0x8c, 0xa7, 0x99, 0xfb, 0xf1, 0xf2,
0x66, 0xa7, 0x83, 0xa7, 0x25, 0x41, 0x8b, 0x25, 0x41, 0x2f, 0x4b, 0x82, 0x1e, 0x56, 0xa4, 0xb6,
0x58, 0x91, 0xda, 0xf3, 0x8a, 0xd4, 0xae, 0x2d, 0xd7, 0x93, 0x93, 0x78, 0x68, 0x8e, 0xf8, 0xcc,
0xda, 0xfc, 0x59, 0x0a, 0x0f, 0x5d, 0x6e, 0x25, 0xd9, 0x39, 0xde, 0x86, 0x4c, 0x0c, 0xbf, 0xa4,
0xb7, 0x75, 0xfc, 0x1a, 0x00, 0x00, 0xff, 0xff, 0x42, 0x3f, 0x72, 0xd4, 0xaf, 0x03, 0x00, 0x00,
// 396 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x93, 0x41, 0x6a, 0xe3, 0x30,
0x14, 0x86, 0x23, 0x27, 0xcc, 0x4c, 0x5e, 0x86, 0x61, 0x46, 0x33, 0x04, 0x8f, 0x99, 0x11, 0xc6,
0x85, 0x90, 0x4d, 0xed, 0x92, 0x1e, 0xa0, 0x50, 0xb2, 0x68, 0xa0, 0x86, 0xa2, 0x76, 0xd5, 0x4d,
0x71, 0x12, 0xe1, 0x98, 0x38, 0x96, 0x63, 0xc9, 0xe0, 0xee, 0x4a, 0x4f, 0xd0, 0xf3, 0xf4, 0x04,
0x5d, 0x66, 0xd9, 0x65, 0x49, 0x2e, 0x52, 0x62, 0xd7, 0x8e, 0x69, 0x4c, 0x1a, 0xba, 0x7b, 0xd2,
0xff, 0x3f, 0xbd, 0x4f, 0xbf, 0x10, 0xfc, 0x0d, 0x7d, 0x27, 0x60, 0x72, 0xe6, 0x05, 0xd2, 0xe5,
0xd6, 0xd8, 0xe1, 0x96, 0x4c, 0xcc, 0x30, 0xe2, 0x92, 0xe3, 0x9f, 0x65, 0xc9, 0x1c, 0x3b, 0x5c,
0x3b, 0xd8, 0x32, 0xaf, 0xcb, 0x9b, 0x88, 0xcd, 0x63, 0x26, 0x64, 0xd6, 0x66, 0xdc, 0x21, 0x68,
0xdb, 0xc2, 0xa5, 0xcc, 0x13, 0x22, 0x66, 0xb4, 0xdf, 0x3f, 0xbf, 0x88, 0x78, 0xc8, 0x85, 0xe3,
0x63, 0x15, 0xbe, 0x8e, 0x22, 0xe6, 0x48, 0x1e, 0xa9, 0x48, 0x47, 0xdd, 0x26, 0xcd, 0x97, 0x58,
0x83, 0x6f, 0x61, 0xea, 0x62, 0x91, 0xaa, 0xa4, 0x52, 0xb1, 0xc6, 0x3f, 0x40, 0x91, 0x89, 0x5a,
0x4f, 0x77, 0x15, 0x99, 0x60, 0x1d, 0x5a, 0x43, 0x9f, 0x8f, 0xa6, 0x67, 0xcc, 0x73, 0x27, 0x52,
0x6d, 0xe8, 0xa8, 0x5b, 0xa7, 0xe5, 0x2d, 0x43, 0x07, 0x52, 0x4d, 0x40, 0x99, 0x08, 0x79, 0x20,
0x98, 0xe1, 0xc1, 0x77, 0x5b, 0xb8, 0xb6, 0x17, 0xc8, 0x2b, 0x3e, 0x65, 0xc1, 0x0e, 0xb2, 0x13,
0x68, 0xad, 0x2f, 0x49, 0xb3, 0x3b, 0xa6, 0x70, 0xad, 0xde, 0x7f, 0xf3, 0x7d, 0x36, 0xa6, 0xbd,
0x31, 0xd1, 0x72, 0x87, 0xd1, 0x86, 0x3f, 0xe5, 0x51, 0x05, 0xc2, 0x3d, 0x4a, 0x85, 0x12, 0x25,
0x65, 0x22, 0xf6, 0xe5, 0x27, 0x53, 0xc2, 0xd0, 0x90, 0xc9, 0x60, 0xfc, 0x96, 0x53, 0x5a, 0xef,
0x91, 0x14, 0x81, 0x7f, 0x55, 0x0c, 0x39, 0x64, 0xef, 0x51, 0x81, 0xba, 0x2d, 0x5c, 0x3c, 0x87,
0xdf, 0x55, 0x0f, 0xda, 0xad, 0xc8, 0xa1, 0x32, 0x78, 0xed, 0x68, 0x5f, 0x67, 0x3e, 0x1a, 0x5f,
0x42, 0x73, 0xf3, 0x3e, 0xa4, 0xb2, 0xbd, 0xd0, 0xb5, 0xce, 0x6e, 0xbd, 0x38, 0x74, 0x0a, 0xbf,
0xb6, 0x03, 0xef, 0x7c, 0xc4, 0x96, 0xf9, 0x34, 0x73, 0x3f, 0x5f, 0x3e, 0xec, 0x74, 0xf0, 0xb4,
0x24, 0x68, 0xb1, 0x24, 0xe8, 0x65, 0x49, 0xd0, 0xc3, 0x8a, 0xd4, 0x16, 0x2b, 0x52, 0x7b, 0x5e,
0x91, 0xda, 0xb5, 0xe5, 0x7a, 0x72, 0x12, 0x0f, 0xcd, 0x11, 0x9f, 0x59, 0x9b, 0x33, 0x4b, 0xe5,
0xa1, 0xcb, 0xad, 0x24, 0xfb, 0x8e, 0xb7, 0x21, 0x13, 0xc3, 0x2f, 0xe9, 0xdf, 0x3a, 0x7e, 0x0d,
0x00, 0x00, 0xff, 0xff, 0x29, 0x98, 0xe0, 0x51, 0xaf, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -535,8 +535,8 @@ func (m *MsgReissueRDDLProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)
_ = i
var l int
_ = l
if m.Blockheight != 0 {
i = encodeVarintTx(dAtA, i, uint64(m.Blockheight))
if m.BlockHeight != 0 {
i = encodeVarintTx(dAtA, i, uint64(m.BlockHeight))
i--
dAtA[i] = 0x20
}
@ -753,8 +753,8 @@ func (m *MsgReissueRDDLProposal) Size() (n int) {
if l > 0 {
n += 1 + l + sovTx(uint64(l))
}
if m.Blockheight != 0 {
n += 1 + sovTx(uint64(m.Blockheight))
if m.BlockHeight != 0 {
n += 1 + sovTx(uint64(m.BlockHeight))
}
return n
}
@ -960,9 +960,9 @@ func (m *MsgReissueRDDLProposal) Unmarshal(dAtA []byte) error {
iNdEx = postIndex
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Blockheight", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
}
m.Blockheight = 0
m.BlockHeight = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTx
@ -972,7 +972,7 @@ func (m *MsgReissueRDDLProposal) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.Blockheight |= uint64(b&0x7F) << shift
m.BlockHeight |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
@ -1355,7 +1355,7 @@ func (m *MsgReissueRDDLResult) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
m.BlockHeight |= uint64(b&0x7F) << shift
m.BlockHeight |= int64(b&0x7F) << shift
if b < 0x80 {
break
}

2
x/dao/util.go
View File

@ -4,7 +4,7 @@ func GetReissuanceCommand(asset_id string, BlockHeight int64) string {
return "reissueasset " + asset_id + " 99869000000"
}
func IsValidReissuanceCommand(reissuance_str string, asset_id string, BlockHeight uint64) bool {
func IsValidReissuanceCommand(reissuance_str string, asset_id string, BlockHeight int64) bool {
expected := "reissueasset " + asset_id + " 99869000000"
return reissuance_str == expected
}