@bandprotocol/bandchain.js
Version:
TypeScript library for Cosmos SDK and BandChain
404 lines (403 loc) • 12.9 kB
JavaScript
//@ts-nocheck
import { Coin } from "../../../cosmos/base/v1beta1/coin";
import { Params } from "./genesis";
import { BinaryReader, BinaryWriter } from "../../../binary";
function createBaseMsgStake() {
return {
stakerAddress: "",
coins: []
};
}
export const MsgStake = {
typeUrl: "/band.restake.v1beta1.MsgStake",
encode(message, writer = BinaryWriter.create()) {
if (message.stakerAddress !== "") {
writer.uint32(10).string(message.stakerAddress);
}
for (const v of message.coins) {
Coin.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgStake();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.stakerAddress = reader.string();
break;
case 2:
message.coins.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgStake();
message.stakerAddress = object.stakerAddress ?? "";
message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgStake();
if (object.staker_address !== undefined && object.staker_address !== null) {
message.stakerAddress = object.staker_address;
}
message.coins = object.coins?.map(e => Coin.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.staker_address = message.stakerAddress === "" ? undefined : message.stakerAddress;
if (message.coins) {
obj.coins = message.coins.map(e => e ? Coin.toAmino(e) : undefined);
}
else {
obj.coins = message.coins;
}
return obj;
},
fromAminoMsg(object) {
return MsgStake.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "restake/MsgStake",
value: MsgStake.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgStake.decode(message.value);
},
toProto(message) {
return MsgStake.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/band.restake.v1beta1.MsgStake",
value: MsgStake.encode(message).finish()
};
}
};
function createBaseMsgStakeResponse() {
return {};
}
export const MsgStakeResponse = {
typeUrl: "/band.restake.v1beta1.MsgStakeResponse",
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgStakeResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgStakeResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgStakeResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgStakeResponse.fromAmino(object.value);
},
fromProtoMsg(message) {
return MsgStakeResponse.decode(message.value);
},
toProto(message) {
return MsgStakeResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/band.restake.v1beta1.MsgStakeResponse",
value: MsgStakeResponse.encode(message).finish()
};
}
};
function createBaseMsgUnstake() {
return {
stakerAddress: "",
coins: []
};
}
export const MsgUnstake = {
typeUrl: "/band.restake.v1beta1.MsgUnstake",
encode(message, writer = BinaryWriter.create()) {
if (message.stakerAddress !== "") {
writer.uint32(10).string(message.stakerAddress);
}
for (const v of message.coins) {
Coin.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgUnstake();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.stakerAddress = reader.string();
break;
case 2:
message.coins.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUnstake();
message.stakerAddress = object.stakerAddress ?? "";
message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
return message;
},
fromAmino(object) {
const message = createBaseMsgUnstake();
if (object.staker_address !== undefined && object.staker_address !== null) {
message.stakerAddress = object.staker_address;
}
message.coins = object.coins?.map(e => Coin.fromAmino(e)) || [];
return message;
},
toAmino(message) {
const obj = {};
obj.staker_address = message.stakerAddress === "" ? undefined : message.stakerAddress;
if (message.coins) {
obj.coins = message.coins.map(e => e ? Coin.toAmino(e) : undefined);
}
else {
obj.coins = message.coins;
}
return obj;
},
fromAminoMsg(object) {
return MsgUnstake.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "restake/MsgUnstake",
value: MsgUnstake.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUnstake.decode(message.value);
},
toProto(message) {
return MsgUnstake.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/band.restake.v1beta1.MsgUnstake",
value: MsgUnstake.encode(message).finish()
};
}
};
function createBaseMsgUnstakeResponse() {
return {};
}
export const MsgUnstakeResponse = {
typeUrl: "/band.restake.v1beta1.MsgUnstakeResponse",
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgUnstakeResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUnstakeResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUnstakeResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUnstakeResponse.fromAmino(object.value);
},
fromProtoMsg(message) {
return MsgUnstakeResponse.decode(message.value);
},
toProto(message) {
return MsgUnstakeResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/band.restake.v1beta1.MsgUnstakeResponse",
value: MsgUnstakeResponse.encode(message).finish()
};
}
};
function createBaseMsgUpdateParams() {
return {
authority: "",
params: Params.fromPartial({})
};
}
export const MsgUpdateParams = {
typeUrl: "/band.restake.v1beta1.MsgUpdateParams",
encode(message, writer = BinaryWriter.create()) {
if (message.authority !== "") {
writer.uint32(10).string(message.authority);
}
if (message.params !== undefined) {
Params.encode(message.params, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgUpdateParams();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.authority = reader.string();
break;
case 2:
message.params = Params.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(object) {
const message = createBaseMsgUpdateParams();
message.authority = object.authority ?? "";
message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
return message;
},
fromAmino(object) {
const message = createBaseMsgUpdateParams();
if (object.authority !== undefined && object.authority !== null) {
message.authority = object.authority;
}
if (object.params !== undefined && object.params !== null) {
message.params = Params.fromAmino(object.params);
}
return message;
},
toAmino(message) {
const obj = {};
obj.authority = message.authority === "" ? undefined : message.authority;
obj.params = message.params ? Params.toAmino(message.params) : undefined;
return obj;
},
fromAminoMsg(object) {
return MsgUpdateParams.fromAmino(object.value);
},
toAminoMsg(message) {
return {
type: "restake/MsgUpdateParams",
value: MsgUpdateParams.toAmino(message)
};
},
fromProtoMsg(message) {
return MsgUpdateParams.decode(message.value);
},
toProto(message) {
return MsgUpdateParams.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/band.restake.v1beta1.MsgUpdateParams",
value: MsgUpdateParams.encode(message).finish()
};
}
};
function createBaseMsgUpdateParamsResponse() {
return {};
}
export const MsgUpdateParamsResponse = {
typeUrl: "/band.restake.v1beta1.MsgUpdateParamsResponse",
encode(_, writer = BinaryWriter.create()) {
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMsgUpdateParamsResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromPartial(_) {
const message = createBaseMsgUpdateParamsResponse();
return message;
},
fromAmino(_) {
const message = createBaseMsgUpdateParamsResponse();
return message;
},
toAmino(_) {
const obj = {};
return obj;
},
fromAminoMsg(object) {
return MsgUpdateParamsResponse.fromAmino(object.value);
},
fromProtoMsg(message) {
return MsgUpdateParamsResponse.decode(message.value);
},
toProto(message) {
return MsgUpdateParamsResponse.encode(message).finish();
},
toProtoMsg(message) {
return {
typeUrl: "/band.restake.v1beta1.MsgUpdateParamsResponse",
value: MsgUpdateParamsResponse.encode(message).finish()
};
}
};