diff --git a/config.json b/config.json index 9a54b0b..07b768f 100644 --- a/config.json +++ b/config.json @@ -33,6 +33,18 @@ "type": "vote", "prefix": "irishub/gov/MsgVote" }, + "addLiquidity": { + "type": "add_liquidity", + "prefix": "irishub/coinswap/MsgAddLiquidity" + }, + "removeLiquidity": { + "type": "remove_liquidity", + "prefix": "irishub/coinswap/MsgRemoveLiquidity" + }, + "swapOrder": { + "type": "swap_order", + "prefix": "irishub/coinswap/MsgSwapOrder" + }, "stdTx": { "type": "", "prefix": "irishub/bank/StdTx" diff --git a/package.json b/package.json index 61d5810..91b6af4 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "irisnet-crypto", - "version": "1.3.3", + "version": "1.3.4", "description": "irisnet-crypto", "main": "index.js", "scripts": { diff --git a/src/chains/base.js b/src/chains/base.js index a7c1450..a8c503e 100644 --- a/src/chains/base.js +++ b/src/chains/base.js @@ -99,5 +99,8 @@ amino.RegisterConcrete(R_Iris.irisnet.tx.MsgWithdrawDelegatorRewardsAll, Config. amino.RegisterConcrete(R_Iris.irisnet.tx.MsgWithdrawDelegatorReward, Config.iris.tx.withdrawDelegationReward.prefix); amino.RegisterConcrete(R_Iris.irisnet.tx.MsgDeposit, Config.iris.tx.deposit.prefix); amino.RegisterConcrete(R_Iris.irisnet.tx.MsgVote, Config.iris.tx.vote.prefix); +amino.RegisterConcrete(R_Iris.irisnet.tx.MsgSwapOrder, Config.iris.tx.swapOrder.prefix); +amino.RegisterConcrete(R_Iris.irisnet.tx.MsgAddLiquidity, Config.iris.tx.addLiquidity.prefix); +amino.RegisterConcrete(R_Iris.irisnet.tx.MsgRemoveLiquidity, Config.iris.tx.removeLiquidity.prefix); amino.RegisterConcrete(R_Iris.irisnet.tx.StdTx, Config.iris.tx.stdTx.prefix); module.exports = amino; diff --git a/src/chains/cosmos/stdTx.js b/src/chains/cosmos/stdTx.js index 48586b1..8c30067 100644 --- a/src/chains/cosmos/stdTx.js +++ b/src/chains/cosmos/stdTx.js @@ -99,7 +99,16 @@ class StdTx { } - GetData() { + /** + * + * @param mode string {block|sync|async} + * block: the client waits for the tx to be committed in a block. + * sync: the client waits for a CheckTx execution response only. + * async: the client returns immediately without execute CheckTx + * @returns {{mode: string, tx: {msg: [], fee: {amount: *, gas: string}, memo: *, signatures: []}}} + * @constructor + */ + GetData(mode = 'sync') { let signatures = []; if (this.signatures){ this.signatures.forEach(function(sig) { @@ -137,7 +146,7 @@ class StdTx { signatures: signatures, memo: this.memo }, - 'mode': 'sync' + 'mode': mode } } @@ -180,4 +189,4 @@ module.exports = class Bank { stdMsg.ValidateBasic(); return new StdTx(stdMsg) } -}; \ No newline at end of file +}; diff --git a/src/chains/iris/builder.js b/src/chains/iris/builder.js index 4631131..6c9774d 100644 --- a/src/chains/iris/builder.js +++ b/src/chains/iris/builder.js @@ -5,6 +5,7 @@ const Bank = require('./bank'); const Stake = require('./stake'); const Distribution = require('./distribution'); const Gov = require('./gov'); +const Coinswap = require('./coinswap'); const IrisKeypair = require('./keypair'); const Codec = require("../../util/codec"); const Config = require('../../../config'); @@ -55,6 +56,18 @@ class IrisBuilder extends Builder { msg = Gov.createMsgVote(req); break; } + case Config.iris.tx.addLiquidity.type: { + msg = Coinswap.createMsgAddLiquidity(req); + break; + } + case Config.iris.tx.removeLiquidity.type: { + msg = Coinswap.createMsgRemoveLiquidity(req); + break; + } + case Config.iris.tx.swapOrder.type: { + msg = Coinswap.createMsgSwapOrder(req); + break; + } default: { throw new Error("not exist tx type"); } diff --git a/src/chains/iris/coinswap.js b/src/chains/iris/coinswap.js new file mode 100644 index 0000000..07fe1b9 --- /dev/null +++ b/src/chains/iris/coinswap.js @@ -0,0 +1,278 @@ +const Config = require('../../../config'); +const Amino = require('../base'); +const Root = require('./tx/tx'); +const BECH32 = require('bech32'); +const Utils = require('../../util/utils'); + +const MsgSwapOrder = Root.irisnet.tx.MsgSwapOrder; +MsgSwapOrder.prototype.type = Config.iris.tx.swapOrder.prefix; +MsgSwapOrder.prototype.GetSignBytes = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.input.address); + let receiver = BECH32.encode(Config.iris.bech32.accAddr, this.output.address); + let msg = { + input: { + address: sender, + coin: this.input.coin + }, + output: { + address: receiver, + coin: this.output.coin + }, + deadline: this.deadline, + is_buy_order: this.isBuyOrder + }; + let sortMsg = Utils.sortObjectKeys(msg); + return Amino.MarshalJSON(this.type, sortMsg); +}; +MsgSwapOrder.prototype.ValidateBasic = function () { + if (Utils.isEmpty(this.input)) { + throw new Error("input is empty"); + } + if (Utils.isEmpty(this.output)) { + throw new Error("output is empty"); + } + if (Utils.isEmpty(this.deadline)) { + throw new Error("deadline is empty"); + } + if (Utils.isEmpty(this.isBuyOrder)) { + throw new Error("isBuyOrder is empty"); + } +}; +MsgSwapOrder.prototype.GetMsg = function () { + let sender = BECH32.fromWords(this.input.address); + let receiver = BECH32.fromWords(this.output.address); + let input = { + address: sender, + coin: this.input.coin + }; + let output = { + address: receiver, + coin: this.output.coin + }; + return { + input: input, + output: output, + deadline: this.deadline, + isBuyOrder: this.isBuyOrder + } +}; +MsgSwapOrder.prototype.GetDisplayContent = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.input.address); + let receiver = BECH32.encode(Config.iris.bech32.accAddr, this.output.address); + return { + i18n_tx_type: "i18n_swap_order", + i18n_input: { + address: sender, + coin: this.input.coin + }, + i18n_output: { + address: receiver, + coin: this.output.coin + }, + i18n_deadline: this.deadline, + i18n_is_buy_order: this.isBuyOrder + } +}; +MsgSwapOrder.prototype.toJSON = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.input.address); + let receiver = BECH32.encode(Config.iris.bech32.accAddr, this.output.address); + + return { + input: { + address: sender, + coin: this.input.coin + }, + output: { + address: receiver, + coin: this.output.coin + }, + deadline: this.deadline, + is_buy_order: this.isBuyOrder + } +}; + +const MsgAddLiquidity = Root.irisnet.tx.MsgAddLiquidity; +MsgAddLiquidity.prototype.type = Config.iris.tx.addLiquidity.prefix; +MsgAddLiquidity.prototype.GetSignBytes = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.sender); + let msg = { + max_token: this.maxToken, + exact_iris_amt: this.exactIrisAmt, + min_liquidity: this.minLiquidity, + deadline: this.deadline, + sender: sender + }; + let sortMsg = Utils.sortObjectKeys(msg); + return Amino.MarshalJSON(this.type, sortMsg) +}; +MsgAddLiquidity.prototype.ValidateBasic = function () { + if (Utils.isEmpty(this.maxToken)) { + throw new Error("maxToken is empty"); + } + if (Utils.isEmpty(this.exactIrisAmt)) { + throw new Error("exactIrisAmt is empty"); + } + if (Utils.isEmpty(this.minLiquidity)) { + throw new Error("minLiquidity is empty"); + } + if (Utils.isEmpty(this.deadline)) { + throw new Error("deadline is empty"); + } + if (Utils.isEmpty(this.sender)) { + throw new Error("sender is empty"); + } +}; +MsgAddLiquidity.prototype.GetMsg = function () { + let sender = BECH32.fromWords(this.sender); + return { + maxToken: this.maxToken, + exactIrisAmt: this.exactIrisAmt, + minLiquidity: this.minLiquidity, + deadline: this.deadline, + sender: sender + } +}; +MsgAddLiquidity.prototype.GetDisplayContent = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.sender); + return { + i18n_tx_type: "i18n_add_liquidity", + i18n_max_token: this.maxToken, + i18n_exact_iris_amt: this.exactIrisAmt, + i18n_deadline: this.deadline, + i18n_min_liquidity: this.minLiquidity, + i18n_sender: sender + } +}; +MsgAddLiquidity.prototype.toJSON = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.sender); + return { + max_token: this.maxToken, + exact_iris_amt: this.exactIrisAmt, + min_liquidity: this.minLiquidity, + deadline: this.deadline, + sender: sender + } +}; + +const MsgRemoveLiquidity = Root.irisnet.tx.MsgRemoveLiquidity; +MsgRemoveLiquidity.prototype.type = Config.iris.tx.removeLiquidity.prefix; +MsgRemoveLiquidity.prototype.GetSignBytes = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.sender); + let msg = { + min_token: this.minToken, + withdraw_liquidity: this.withdrawLiquidity, + min_iris_amt: this.minIrisAmt, + deadline: this.deadline, + sender: sender + }; + let sortMsg = Utils.sortObjectKeys(msg); + return Amino.MarshalJSON(this.type, sortMsg) +}; +MsgRemoveLiquidity.prototype.ValidateBasic = function () { + if (Utils.isEmpty(this.minToken)) { + throw new Error("minToken is empty"); + } + if (Utils.isEmpty(this.withdrawLiquidity)) { + throw new Error("withdrawLiquidity is empty"); + } + if (Utils.isEmpty(this.minIrisAmt)) { + throw new Error("minIrisAmt is empty"); + } + if (Utils.isEmpty(this.deadline)) { + throw new Error("deadline is empty"); + } + if (Utils.isEmpty(this.sender)) { + throw new Error("sender is empty"); + } +}; +MsgRemoveLiquidity.prototype.GetMsg = function () { + let sender = BECH32.fromWords(this.sender); + return { + minToken: this.minToken, + withdrawLiquidity: this.withdrawLiquidity, + minIrisAmt: this.minIrisAmt, + deadline: this.deadline, + sender: sender + } +}; +MsgRemoveLiquidity.prototype.GetDisplayContent = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.sender); + return { + i18n_tx_type: "i18n_remove_liquidity", + i18n_min_token: this.minToken, + i18n_withdraw_liquidity: this.withdrawLiquidity, + i18n_min_iris_amt: this.minIrisAmt, + i18n_deadline: this.deadline, + i18n_sender: sender + } +}; +MsgRemoveLiquidity.prototype.toJSON = function () { + let sender = BECH32.encode(Config.iris.bech32.accAddr, this.sender); + return { + min_token: this.minToken, + withdraw_liquidity: this.withdrawLiquidity, + min_iris_amt: this.minIrisAmt, + deadline: this.deadline, + sender: sender + } +}; + +module.exports = class CoinSwap { + static createMsgAddLiquidity(req) { + let maxToken = { + denom: req.msg.max_token.denom, + amount: Utils.toString(req.msg.max_token.amount), + }; + let exactIrisAmt = Utils.toString(req.msg.exact_iris_amt); + let minLiquidity = Utils.toString(req.msg.min_liquidity); + return new MsgAddLiquidity({ + maxToken: maxToken, + exactIrisAmt: exactIrisAmt, + minLiquidity: minLiquidity, + deadline: Utils.toString(req.msg.deadline), + sender: BECH32.decode(req.from).words + }) + } + + static createMsgRemoveLiquidity(req) { + let withdrawLiquidity = { + denom: req.msg.withdraw_liquidity.denom, + amount: Utils.toString(req.msg.withdraw_liquidity.amount), + }; + let minIrisAmt = Utils.toString(req.msg.min_iris_amt); + let minToken = Utils.toString(req.msg.min_token); + return new MsgRemoveLiquidity({ + minToken: minToken, + withdrawLiquidity: withdrawLiquidity, + minIrisAmt: minIrisAmt, + deadline: Utils.toString(req.msg.deadline), + sender: BECH32.decode(req.from).words + }) + } + + static createMsgSwapOrder(req) { + let sender = BECH32.decode(req.msg.input.address).words; + let receiver = BECH32.decode(req.msg.output.address).words; + + let input = { + address: sender, + coin: { + denom: req.msg.input.coin.denom, + amount: Utils.toString(req.msg.input.coin.amount), + }, + }; + let output = { + address: receiver, + coin: { + denom: req.msg.output.coin.denom, + amount: Utils.toString(req.msg.output.coin.amount), + }, + }; + return new MsgSwapOrder({ + input: input, + output: output, + deadline: Utils.toString(req.msg.deadline), + isBuyOrder: req.msg.isBuyOrder, + }); + } +}; \ No newline at end of file diff --git a/src/chains/iris/proto/tx.proto b/src/chains/iris/proto/tx.proto index e0785f4..f1cefc4 100644 --- a/src/chains/iris/proto/tx.proto +++ b/src/chains/iris/proto/tx.proto @@ -61,6 +61,36 @@ message MsgVote { required uint64 option = 3; } +message SwapInput { + required bytes address = 1; + required Coin coin = 2; +} +message SwapOutput { + required bytes address = 1; + required Coin coin = 2; +} +message MsgSwapOrder { + required SwapInput input = 1; + required SwapOutput output = 2; + required int64 deadline = 3; + required bool isBuyOrder = 4; +} +message MsgAddLiquidity { + required Coin maxToken = 1; + required string exactIrisAmt = 2; + required string minLiquidity = 3; + required int64 deadline = 4; + required bytes sender = 5; +} + +message MsgRemoveLiquidity { + required string minToken = 1; + required Coin withdrawLiquidity = 2; + required string minIrisAmt = 3; + required int64 deadline = 4; + required bytes sender = 5; +} + message StdFee { repeated Coin amount = 1; required int64 gas = 2; diff --git a/src/chains/iris/tx/tx.js b/src/chains/iris/tx/tx.js index 7b844c3..067873a 100644 --- a/src/chains/iris/tx/tx.js +++ b/src/chains/iris/tx/tx.js @@ -2728,6 +2728,1346 @@ $root.irisnet = (function() { return MsgVote; })(); + tx.SwapInput = (function() { + + /** + * Properties of a SwapInput. + * @memberof irisnet.tx + * @interface ISwapInput + * @property {Uint8Array} address SwapInput address + * @property {irisnet.tx.ICoin} coin SwapInput coin + */ + + /** + * Constructs a new SwapInput. + * @memberof irisnet.tx + * @classdesc Represents a SwapInput. + * @implements ISwapInput + * @constructor + * @param {irisnet.tx.ISwapInput=} [properties] Properties to set + */ + function SwapInput(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SwapInput address. + * @member {Uint8Array} address + * @memberof irisnet.tx.SwapInput + * @instance + */ + SwapInput.prototype.address = $util.newBuffer([]); + + /** + * SwapInput coin. + * @member {irisnet.tx.ICoin} coin + * @memberof irisnet.tx.SwapInput + * @instance + */ + SwapInput.prototype.coin = null; + + /** + * Creates a new SwapInput instance using the specified properties. + * @function create + * @memberof irisnet.tx.SwapInput + * @static + * @param {irisnet.tx.ISwapInput=} [properties] Properties to set + * @returns {irisnet.tx.SwapInput} SwapInput instance + */ + SwapInput.create = function create(properties) { + return new SwapInput(properties); + }; + + /** + * Encodes the specified SwapInput message. Does not implicitly {@link irisnet.tx.SwapInput.verify|verify} messages. + * @function encode + * @memberof irisnet.tx.SwapInput + * @static + * @param {irisnet.tx.ISwapInput} message SwapInput message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SwapInput.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.address); + $root.irisnet.tx.Coin.encode(message.coin, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified SwapInput message, length delimited. Does not implicitly {@link irisnet.tx.SwapInput.verify|verify} messages. + * @function encodeDelimited + * @memberof irisnet.tx.SwapInput + * @static + * @param {irisnet.tx.ISwapInput} message SwapInput message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SwapInput.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SwapInput message from the specified reader or buffer. + * @function decode + * @memberof irisnet.tx.SwapInput + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {irisnet.tx.SwapInput} SwapInput + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SwapInput.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.irisnet.tx.SwapInput(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.address = reader.bytes(); + break; + case 2: + message.coin = $root.irisnet.tx.Coin.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + if (!message.hasOwnProperty("address")) + throw $util.ProtocolError("missing required 'address'", { instance: message }); + if (!message.hasOwnProperty("coin")) + throw $util.ProtocolError("missing required 'coin'", { instance: message }); + return message; + }; + + /** + * Decodes a SwapInput message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof irisnet.tx.SwapInput + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {irisnet.tx.SwapInput} SwapInput + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SwapInput.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SwapInput message. + * @function verify + * @memberof irisnet.tx.SwapInput + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SwapInput.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (!(message.address && typeof message.address.length === "number" || $util.isString(message.address))) + return "address: buffer expected"; + { + var error = $root.irisnet.tx.Coin.verify(message.coin); + if (error) + return "coin." + error; + } + return null; + }; + + /** + * Creates a SwapInput message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof irisnet.tx.SwapInput + * @static + * @param {Object.} object Plain object + * @returns {irisnet.tx.SwapInput} SwapInput + */ + SwapInput.fromObject = function fromObject(object) { + if (object instanceof $root.irisnet.tx.SwapInput) + return object; + var message = new $root.irisnet.tx.SwapInput(); + if (object.address != null) + if (typeof object.address === "string") + $util.base64.decode(object.address, message.address = $util.newBuffer($util.base64.length(object.address)), 0); + else if (object.address.length) + message.address = object.address; + if (object.coin != null) { + if (typeof object.coin !== "object") + throw TypeError(".irisnet.tx.SwapInput.coin: object expected"); + message.coin = $root.irisnet.tx.Coin.fromObject(object.coin); + } + return message; + }; + + /** + * Creates a plain object from a SwapInput message. Also converts values to other types if specified. + * @function toObject + * @memberof irisnet.tx.SwapInput + * @static + * @param {irisnet.tx.SwapInput} message SwapInput + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SwapInput.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + if (options.bytes === String) + object.address = ""; + else { + object.address = []; + if (options.bytes !== Array) + object.address = $util.newBuffer(object.address); + } + object.coin = null; + } + if (message.address != null && message.hasOwnProperty("address")) + object.address = options.bytes === String ? $util.base64.encode(message.address, 0, message.address.length) : options.bytes === Array ? Array.prototype.slice.call(message.address) : message.address; + if (message.coin != null && message.hasOwnProperty("coin")) + object.coin = $root.irisnet.tx.Coin.toObject(message.coin, options); + return object; + }; + + /** + * Converts this SwapInput to JSON. + * @function toJSON + * @memberof irisnet.tx.SwapInput + * @instance + * @returns {Object.} JSON object + */ + SwapInput.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SwapInput; + })(); + + tx.SwapOutput = (function() { + + /** + * Properties of a SwapOutput. + * @memberof irisnet.tx + * @interface ISwapOutput + * @property {Uint8Array} address SwapOutput address + * @property {irisnet.tx.ICoin} coin SwapOutput coin + */ + + /** + * Constructs a new SwapOutput. + * @memberof irisnet.tx + * @classdesc Represents a SwapOutput. + * @implements ISwapOutput + * @constructor + * @param {irisnet.tx.ISwapOutput=} [properties] Properties to set + */ + function SwapOutput(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * SwapOutput address. + * @member {Uint8Array} address + * @memberof irisnet.tx.SwapOutput + * @instance + */ + SwapOutput.prototype.address = $util.newBuffer([]); + + /** + * SwapOutput coin. + * @member {irisnet.tx.ICoin} coin + * @memberof irisnet.tx.SwapOutput + * @instance + */ + SwapOutput.prototype.coin = null; + + /** + * Creates a new SwapOutput instance using the specified properties. + * @function create + * @memberof irisnet.tx.SwapOutput + * @static + * @param {irisnet.tx.ISwapOutput=} [properties] Properties to set + * @returns {irisnet.tx.SwapOutput} SwapOutput instance + */ + SwapOutput.create = function create(properties) { + return new SwapOutput(properties); + }; + + /** + * Encodes the specified SwapOutput message. Does not implicitly {@link irisnet.tx.SwapOutput.verify|verify} messages. + * @function encode + * @memberof irisnet.tx.SwapOutput + * @static + * @param {irisnet.tx.ISwapOutput} message SwapOutput message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SwapOutput.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.address); + $root.irisnet.tx.Coin.encode(message.coin, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + return writer; + }; + + /** + * Encodes the specified SwapOutput message, length delimited. Does not implicitly {@link irisnet.tx.SwapOutput.verify|verify} messages. + * @function encodeDelimited + * @memberof irisnet.tx.SwapOutput + * @static + * @param {irisnet.tx.ISwapOutput} message SwapOutput message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + SwapOutput.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a SwapOutput message from the specified reader or buffer. + * @function decode + * @memberof irisnet.tx.SwapOutput + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {irisnet.tx.SwapOutput} SwapOutput + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SwapOutput.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.irisnet.tx.SwapOutput(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.address = reader.bytes(); + break; + case 2: + message.coin = $root.irisnet.tx.Coin.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + if (!message.hasOwnProperty("address")) + throw $util.ProtocolError("missing required 'address'", { instance: message }); + if (!message.hasOwnProperty("coin")) + throw $util.ProtocolError("missing required 'coin'", { instance: message }); + return message; + }; + + /** + * Decodes a SwapOutput message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof irisnet.tx.SwapOutput + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {irisnet.tx.SwapOutput} SwapOutput + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + SwapOutput.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a SwapOutput message. + * @function verify + * @memberof irisnet.tx.SwapOutput + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + SwapOutput.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (!(message.address && typeof message.address.length === "number" || $util.isString(message.address))) + return "address: buffer expected"; + { + var error = $root.irisnet.tx.Coin.verify(message.coin); + if (error) + return "coin." + error; + } + return null; + }; + + /** + * Creates a SwapOutput message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof irisnet.tx.SwapOutput + * @static + * @param {Object.} object Plain object + * @returns {irisnet.tx.SwapOutput} SwapOutput + */ + SwapOutput.fromObject = function fromObject(object) { + if (object instanceof $root.irisnet.tx.SwapOutput) + return object; + var message = new $root.irisnet.tx.SwapOutput(); + if (object.address != null) + if (typeof object.address === "string") + $util.base64.decode(object.address, message.address = $util.newBuffer($util.base64.length(object.address)), 0); + else if (object.address.length) + message.address = object.address; + if (object.coin != null) { + if (typeof object.coin !== "object") + throw TypeError(".irisnet.tx.SwapOutput.coin: object expected"); + message.coin = $root.irisnet.tx.Coin.fromObject(object.coin); + } + return message; + }; + + /** + * Creates a plain object from a SwapOutput message. Also converts values to other types if specified. + * @function toObject + * @memberof irisnet.tx.SwapOutput + * @static + * @param {irisnet.tx.SwapOutput} message SwapOutput + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + SwapOutput.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + if (options.bytes === String) + object.address = ""; + else { + object.address = []; + if (options.bytes !== Array) + object.address = $util.newBuffer(object.address); + } + object.coin = null; + } + if (message.address != null && message.hasOwnProperty("address")) + object.address = options.bytes === String ? $util.base64.encode(message.address, 0, message.address.length) : options.bytes === Array ? Array.prototype.slice.call(message.address) : message.address; + if (message.coin != null && message.hasOwnProperty("coin")) + object.coin = $root.irisnet.tx.Coin.toObject(message.coin, options); + return object; + }; + + /** + * Converts this SwapOutput to JSON. + * @function toJSON + * @memberof irisnet.tx.SwapOutput + * @instance + * @returns {Object.} JSON object + */ + SwapOutput.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return SwapOutput; + })(); + + tx.MsgSwapOrder = (function() { + + /** + * Properties of a MsgSwapOrder. + * @memberof irisnet.tx + * @interface IMsgSwapOrder + * @property {irisnet.tx.ISwapInput} input MsgSwapOrder input + * @property {irisnet.tx.ISwapOutput} output MsgSwapOrder output + * @property {number|Long} deadline MsgSwapOrder deadline + * @property {boolean} isBuyOrder MsgSwapOrder isBuyOrder + */ + + /** + * Constructs a new MsgSwapOrder. + * @memberof irisnet.tx + * @classdesc Represents a MsgSwapOrder. + * @implements IMsgSwapOrder + * @constructor + * @param {irisnet.tx.IMsgSwapOrder=} [properties] Properties to set + */ + function MsgSwapOrder(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * MsgSwapOrder input. + * @member {irisnet.tx.ISwapInput} input + * @memberof irisnet.tx.MsgSwapOrder + * @instance + */ + MsgSwapOrder.prototype.input = null; + + /** + * MsgSwapOrder output. + * @member {irisnet.tx.ISwapOutput} output + * @memberof irisnet.tx.MsgSwapOrder + * @instance + */ + MsgSwapOrder.prototype.output = null; + + /** + * MsgSwapOrder deadline. + * @member {number|Long} deadline + * @memberof irisnet.tx.MsgSwapOrder + * @instance + */ + MsgSwapOrder.prototype.deadline = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * MsgSwapOrder isBuyOrder. + * @member {boolean} isBuyOrder + * @memberof irisnet.tx.MsgSwapOrder + * @instance + */ + MsgSwapOrder.prototype.isBuyOrder = false; + + /** + * Creates a new MsgSwapOrder instance using the specified properties. + * @function create + * @memberof irisnet.tx.MsgSwapOrder + * @static + * @param {irisnet.tx.IMsgSwapOrder=} [properties] Properties to set + * @returns {irisnet.tx.MsgSwapOrder} MsgSwapOrder instance + */ + MsgSwapOrder.create = function create(properties) { + return new MsgSwapOrder(properties); + }; + + /** + * Encodes the specified MsgSwapOrder message. Does not implicitly {@link irisnet.tx.MsgSwapOrder.verify|verify} messages. + * @function encode + * @memberof irisnet.tx.MsgSwapOrder + * @static + * @param {irisnet.tx.IMsgSwapOrder} message MsgSwapOrder message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + MsgSwapOrder.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + $root.irisnet.tx.SwapInput.encode(message.input, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + $root.irisnet.tx.SwapOutput.encode(message.output, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + writer.uint32(/* id 3, wireType 0 =*/24).int64(message.deadline); + writer.uint32(/* id 4, wireType 0 =*/32).bool(message.isBuyOrder); + return writer; + }; + + /** + * Encodes the specified MsgSwapOrder message, length delimited. Does not implicitly {@link irisnet.tx.MsgSwapOrder.verify|verify} messages. + * @function encodeDelimited + * @memberof irisnet.tx.MsgSwapOrder + * @static + * @param {irisnet.tx.IMsgSwapOrder} message MsgSwapOrder message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + MsgSwapOrder.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a MsgSwapOrder message from the specified reader or buffer. + * @function decode + * @memberof irisnet.tx.MsgSwapOrder + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {irisnet.tx.MsgSwapOrder} MsgSwapOrder + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + MsgSwapOrder.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.irisnet.tx.MsgSwapOrder(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.input = $root.irisnet.tx.SwapInput.decode(reader, reader.uint32()); + break; + case 2: + message.output = $root.irisnet.tx.SwapOutput.decode(reader, reader.uint32()); + break; + case 3: + message.deadline = reader.int64(); + break; + case 4: + message.isBuyOrder = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + if (!message.hasOwnProperty("input")) + throw $util.ProtocolError("missing required 'input'", { instance: message }); + if (!message.hasOwnProperty("output")) + throw $util.ProtocolError("missing required 'output'", { instance: message }); + if (!message.hasOwnProperty("deadline")) + throw $util.ProtocolError("missing required 'deadline'", { instance: message }); + if (!message.hasOwnProperty("isBuyOrder")) + throw $util.ProtocolError("missing required 'isBuyOrder'", { instance: message }); + return message; + }; + + /** + * Decodes a MsgSwapOrder message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof irisnet.tx.MsgSwapOrder + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {irisnet.tx.MsgSwapOrder} MsgSwapOrder + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + MsgSwapOrder.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a MsgSwapOrder message. + * @function verify + * @memberof irisnet.tx.MsgSwapOrder + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + MsgSwapOrder.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + { + var error = $root.irisnet.tx.SwapInput.verify(message.input); + if (error) + return "input." + error; + } + { + var error = $root.irisnet.tx.SwapOutput.verify(message.output); + if (error) + return "output." + error; + } + if (!$util.isInteger(message.deadline) && !(message.deadline && $util.isInteger(message.deadline.low) && $util.isInteger(message.deadline.high))) + return "deadline: integer|Long expected"; + if (typeof message.isBuyOrder !== "boolean") + return "isBuyOrder: boolean expected"; + return null; + }; + + /** + * Creates a MsgSwapOrder message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof irisnet.tx.MsgSwapOrder + * @static + * @param {Object.} object Plain object + * @returns {irisnet.tx.MsgSwapOrder} MsgSwapOrder + */ + MsgSwapOrder.fromObject = function fromObject(object) { + if (object instanceof $root.irisnet.tx.MsgSwapOrder) + return object; + var message = new $root.irisnet.tx.MsgSwapOrder(); + if (object.input != null) { + if (typeof object.input !== "object") + throw TypeError(".irisnet.tx.MsgSwapOrder.input: object expected"); + message.input = $root.irisnet.tx.SwapInput.fromObject(object.input); + } + if (object.output != null) { + if (typeof object.output !== "object") + throw TypeError(".irisnet.tx.MsgSwapOrder.output: object expected"); + message.output = $root.irisnet.tx.SwapOutput.fromObject(object.output); + } + if (object.deadline != null) + if ($util.Long) + (message.deadline = $util.Long.fromValue(object.deadline)).unsigned = false; + else if (typeof object.deadline === "string") + message.deadline = parseInt(object.deadline, 10); + else if (typeof object.deadline === "number") + message.deadline = object.deadline; + else if (typeof object.deadline === "object") + message.deadline = new $util.LongBits(object.deadline.low >>> 0, object.deadline.high >>> 0).toNumber(); + if (object.isBuyOrder != null) + message.isBuyOrder = Boolean(object.isBuyOrder); + return message; + }; + + /** + * Creates a plain object from a MsgSwapOrder message. Also converts values to other types if specified. + * @function toObject + * @memberof irisnet.tx.MsgSwapOrder + * @static + * @param {irisnet.tx.MsgSwapOrder} message MsgSwapOrder + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + MsgSwapOrder.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.input = null; + object.output = null; + if ($util.Long) { + var long = new $util.Long(0, 0, false); + object.deadline = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.deadline = options.longs === String ? "0" : 0; + object.isBuyOrder = false; + } + if (message.input != null && message.hasOwnProperty("input")) + object.input = $root.irisnet.tx.SwapInput.toObject(message.input, options); + if (message.output != null && message.hasOwnProperty("output")) + object.output = $root.irisnet.tx.SwapOutput.toObject(message.output, options); + if (message.deadline != null && message.hasOwnProperty("deadline")) + if (typeof message.deadline === "number") + object.deadline = options.longs === String ? String(message.deadline) : message.deadline; + else + object.deadline = options.longs === String ? $util.Long.prototype.toString.call(message.deadline) : options.longs === Number ? new $util.LongBits(message.deadline.low >>> 0, message.deadline.high >>> 0).toNumber() : message.deadline; + if (message.isBuyOrder != null && message.hasOwnProperty("isBuyOrder")) + object.isBuyOrder = message.isBuyOrder; + return object; + }; + + /** + * Converts this MsgSwapOrder to JSON. + * @function toJSON + * @memberof irisnet.tx.MsgSwapOrder + * @instance + * @returns {Object.} JSON object + */ + MsgSwapOrder.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return MsgSwapOrder; + })(); + + tx.MsgAddLiquidity = (function() { + + /** + * Properties of a MsgAddLiquidity. + * @memberof irisnet.tx + * @interface IMsgAddLiquidity + * @property {irisnet.tx.ICoin} maxToken MsgAddLiquidity maxToken + * @property {string} exactIrisAmt MsgAddLiquidity exactIrisAmt + * @property {string} minLiquidity MsgAddLiquidity minLiquidity + * @property {number|Long} deadline MsgAddLiquidity deadline + * @property {Uint8Array} sender MsgAddLiquidity sender + */ + + /** + * Constructs a new MsgAddLiquidity. + * @memberof irisnet.tx + * @classdesc Represents a MsgAddLiquidity. + * @implements IMsgAddLiquidity + * @constructor + * @param {irisnet.tx.IMsgAddLiquidity=} [properties] Properties to set + */ + function MsgAddLiquidity(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * MsgAddLiquidity maxToken. + * @member {irisnet.tx.ICoin} maxToken + * @memberof irisnet.tx.MsgAddLiquidity + * @instance + */ + MsgAddLiquidity.prototype.maxToken = null; + + /** + * MsgAddLiquidity exactIrisAmt. + * @member {string} exactIrisAmt + * @memberof irisnet.tx.MsgAddLiquidity + * @instance + */ + MsgAddLiquidity.prototype.exactIrisAmt = ""; + + /** + * MsgAddLiquidity minLiquidity. + * @member {string} minLiquidity + * @memberof irisnet.tx.MsgAddLiquidity + * @instance + */ + MsgAddLiquidity.prototype.minLiquidity = ""; + + /** + * MsgAddLiquidity deadline. + * @member {number|Long} deadline + * @memberof irisnet.tx.MsgAddLiquidity + * @instance + */ + MsgAddLiquidity.prototype.deadline = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * MsgAddLiquidity sender. + * @member {Uint8Array} sender + * @memberof irisnet.tx.MsgAddLiquidity + * @instance + */ + MsgAddLiquidity.prototype.sender = $util.newBuffer([]); + + /** + * Creates a new MsgAddLiquidity instance using the specified properties. + * @function create + * @memberof irisnet.tx.MsgAddLiquidity + * @static + * @param {irisnet.tx.IMsgAddLiquidity=} [properties] Properties to set + * @returns {irisnet.tx.MsgAddLiquidity} MsgAddLiquidity instance + */ + MsgAddLiquidity.create = function create(properties) { + return new MsgAddLiquidity(properties); + }; + + /** + * Encodes the specified MsgAddLiquidity message. Does not implicitly {@link irisnet.tx.MsgAddLiquidity.verify|verify} messages. + * @function encode + * @memberof irisnet.tx.MsgAddLiquidity + * @static + * @param {irisnet.tx.IMsgAddLiquidity} message MsgAddLiquidity message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + MsgAddLiquidity.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + $root.irisnet.tx.Coin.encode(message.maxToken, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim(); + writer.uint32(/* id 2, wireType 2 =*/18).string(message.exactIrisAmt); + writer.uint32(/* id 3, wireType 2 =*/26).string(message.minLiquidity); + writer.uint32(/* id 4, wireType 0 =*/32).int64(message.deadline); + writer.uint32(/* id 5, wireType 2 =*/42).bytes(message.sender); + return writer; + }; + + /** + * Encodes the specified MsgAddLiquidity message, length delimited. Does not implicitly {@link irisnet.tx.MsgAddLiquidity.verify|verify} messages. + * @function encodeDelimited + * @memberof irisnet.tx.MsgAddLiquidity + * @static + * @param {irisnet.tx.IMsgAddLiquidity} message MsgAddLiquidity message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + MsgAddLiquidity.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a MsgAddLiquidity message from the specified reader or buffer. + * @function decode + * @memberof irisnet.tx.MsgAddLiquidity + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {irisnet.tx.MsgAddLiquidity} MsgAddLiquidity + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + MsgAddLiquidity.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.irisnet.tx.MsgAddLiquidity(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.maxToken = $root.irisnet.tx.Coin.decode(reader, reader.uint32()); + break; + case 2: + message.exactIrisAmt = reader.string(); + break; + case 3: + message.minLiquidity = reader.string(); + break; + case 4: + message.deadline = reader.int64(); + break; + case 5: + message.sender = reader.bytes(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + if (!message.hasOwnProperty("maxToken")) + throw $util.ProtocolError("missing required 'maxToken'", { instance: message }); + if (!message.hasOwnProperty("exactIrisAmt")) + throw $util.ProtocolError("missing required 'exactIrisAmt'", { instance: message }); + if (!message.hasOwnProperty("minLiquidity")) + throw $util.ProtocolError("missing required 'minLiquidity'", { instance: message }); + if (!message.hasOwnProperty("deadline")) + throw $util.ProtocolError("missing required 'deadline'", { instance: message }); + if (!message.hasOwnProperty("sender")) + throw $util.ProtocolError("missing required 'sender'", { instance: message }); + return message; + }; + + /** + * Decodes a MsgAddLiquidity message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof irisnet.tx.MsgAddLiquidity + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {irisnet.tx.MsgAddLiquidity} MsgAddLiquidity + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + MsgAddLiquidity.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a MsgAddLiquidity message. + * @function verify + * @memberof irisnet.tx.MsgAddLiquidity + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + MsgAddLiquidity.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + { + var error = $root.irisnet.tx.Coin.verify(message.maxToken); + if (error) + return "maxToken." + error; + } + if (!$util.isString(message.exactIrisAmt)) + return "exactIrisAmt: string expected"; + if (!$util.isString(message.minLiquidity)) + return "minLiquidity: string expected"; + if (!$util.isInteger(message.deadline) && !(message.deadline && $util.isInteger(message.deadline.low) && $util.isInteger(message.deadline.high))) + return "deadline: integer|Long expected"; + if (!(message.sender && typeof message.sender.length === "number" || $util.isString(message.sender))) + return "sender: buffer expected"; + return null; + }; + + /** + * Creates a MsgAddLiquidity message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof irisnet.tx.MsgAddLiquidity + * @static + * @param {Object.} object Plain object + * @returns {irisnet.tx.MsgAddLiquidity} MsgAddLiquidity + */ + MsgAddLiquidity.fromObject = function fromObject(object) { + if (object instanceof $root.irisnet.tx.MsgAddLiquidity) + return object; + var message = new $root.irisnet.tx.MsgAddLiquidity(); + if (object.maxToken != null) { + if (typeof object.maxToken !== "object") + throw TypeError(".irisnet.tx.MsgAddLiquidity.maxToken: object expected"); + message.maxToken = $root.irisnet.tx.Coin.fromObject(object.maxToken); + } + if (object.exactIrisAmt != null) + message.exactIrisAmt = String(object.exactIrisAmt); + if (object.minLiquidity != null) + message.minLiquidity = String(object.minLiquidity); + if (object.deadline != null) + if ($util.Long) + (message.deadline = $util.Long.fromValue(object.deadline)).unsigned = false; + else if (typeof object.deadline === "string") + message.deadline = parseInt(object.deadline, 10); + else if (typeof object.deadline === "number") + message.deadline = object.deadline; + else if (typeof object.deadline === "object") + message.deadline = new $util.LongBits(object.deadline.low >>> 0, object.deadline.high >>> 0).toNumber(); + if (object.sender != null) + if (typeof object.sender === "string") + $util.base64.decode(object.sender, message.sender = $util.newBuffer($util.base64.length(object.sender)), 0); + else if (object.sender.length) + message.sender = object.sender; + return message; + }; + + /** + * Creates a plain object from a MsgAddLiquidity message. Also converts values to other types if specified. + * @function toObject + * @memberof irisnet.tx.MsgAddLiquidity + * @static + * @param {irisnet.tx.MsgAddLiquidity} message MsgAddLiquidity + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + MsgAddLiquidity.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.maxToken = null; + object.exactIrisAmt = ""; + object.minLiquidity = ""; + if ($util.Long) { + var long = new $util.Long(0, 0, false); + object.deadline = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.deadline = options.longs === String ? "0" : 0; + if (options.bytes === String) + object.sender = ""; + else { + object.sender = []; + if (options.bytes !== Array) + object.sender = $util.newBuffer(object.sender); + } + } + if (message.maxToken != null && message.hasOwnProperty("maxToken")) + object.maxToken = $root.irisnet.tx.Coin.toObject(message.maxToken, options); + if (message.exactIrisAmt != null && message.hasOwnProperty("exactIrisAmt")) + object.exactIrisAmt = message.exactIrisAmt; + if (message.minLiquidity != null && message.hasOwnProperty("minLiquidity")) + object.minLiquidity = message.minLiquidity; + if (message.deadline != null && message.hasOwnProperty("deadline")) + if (typeof message.deadline === "number") + object.deadline = options.longs === String ? String(message.deadline) : message.deadline; + else + object.deadline = options.longs === String ? $util.Long.prototype.toString.call(message.deadline) : options.longs === Number ? new $util.LongBits(message.deadline.low >>> 0, message.deadline.high >>> 0).toNumber() : message.deadline; + if (message.sender != null && message.hasOwnProperty("sender")) + object.sender = options.bytes === String ? $util.base64.encode(message.sender, 0, message.sender.length) : options.bytes === Array ? Array.prototype.slice.call(message.sender) : message.sender; + return object; + }; + + /** + * Converts this MsgAddLiquidity to JSON. + * @function toJSON + * @memberof irisnet.tx.MsgAddLiquidity + * @instance + * @returns {Object.} JSON object + */ + MsgAddLiquidity.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return MsgAddLiquidity; + })(); + + tx.MsgRemoveLiquidity = (function() { + + /** + * Properties of a MsgRemoveLiquidity. + * @memberof irisnet.tx + * @interface IMsgRemoveLiquidity + * @property {string} minToken MsgRemoveLiquidity minToken + * @property {irisnet.tx.ICoin} withdrawLiquidity MsgRemoveLiquidity withdrawLiquidity + * @property {string} minIrisAmt MsgRemoveLiquidity minIrisAmt + * @property {number|Long} deadline MsgRemoveLiquidity deadline + * @property {Uint8Array} sender MsgRemoveLiquidity sender + */ + + /** + * Constructs a new MsgRemoveLiquidity. + * @memberof irisnet.tx + * @classdesc Represents a MsgRemoveLiquidity. + * @implements IMsgRemoveLiquidity + * @constructor + * @param {irisnet.tx.IMsgRemoveLiquidity=} [properties] Properties to set + */ + function MsgRemoveLiquidity(properties) { + if (properties) + for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i) + if (properties[keys[i]] != null) + this[keys[i]] = properties[keys[i]]; + } + + /** + * MsgRemoveLiquidity minToken. + * @member {string} minToken + * @memberof irisnet.tx.MsgRemoveLiquidity + * @instance + */ + MsgRemoveLiquidity.prototype.minToken = ""; + + /** + * MsgRemoveLiquidity withdrawLiquidity. + * @member {irisnet.tx.ICoin} withdrawLiquidity + * @memberof irisnet.tx.MsgRemoveLiquidity + * @instance + */ + MsgRemoveLiquidity.prototype.withdrawLiquidity = null; + + /** + * MsgRemoveLiquidity minIrisAmt. + * @member {string} minIrisAmt + * @memberof irisnet.tx.MsgRemoveLiquidity + * @instance + */ + MsgRemoveLiquidity.prototype.minIrisAmt = ""; + + /** + * MsgRemoveLiquidity deadline. + * @member {number|Long} deadline + * @memberof irisnet.tx.MsgRemoveLiquidity + * @instance + */ + MsgRemoveLiquidity.prototype.deadline = $util.Long ? $util.Long.fromBits(0,0,false) : 0; + + /** + * MsgRemoveLiquidity sender. + * @member {Uint8Array} sender + * @memberof irisnet.tx.MsgRemoveLiquidity + * @instance + */ + MsgRemoveLiquidity.prototype.sender = $util.newBuffer([]); + + /** + * Creates a new MsgRemoveLiquidity instance using the specified properties. + * @function create + * @memberof irisnet.tx.MsgRemoveLiquidity + * @static + * @param {irisnet.tx.IMsgRemoveLiquidity=} [properties] Properties to set + * @returns {irisnet.tx.MsgRemoveLiquidity} MsgRemoveLiquidity instance + */ + MsgRemoveLiquidity.create = function create(properties) { + return new MsgRemoveLiquidity(properties); + }; + + /** + * Encodes the specified MsgRemoveLiquidity message. Does not implicitly {@link irisnet.tx.MsgRemoveLiquidity.verify|verify} messages. + * @function encode + * @memberof irisnet.tx.MsgRemoveLiquidity + * @static + * @param {irisnet.tx.IMsgRemoveLiquidity} message MsgRemoveLiquidity message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + MsgRemoveLiquidity.encode = function encode(message, writer) { + if (!writer) + writer = $Writer.create(); + writer.uint32(/* id 1, wireType 2 =*/10).string(message.minToken); + $root.irisnet.tx.Coin.encode(message.withdrawLiquidity, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim(); + writer.uint32(/* id 3, wireType 2 =*/26).string(message.minIrisAmt); + writer.uint32(/* id 4, wireType 0 =*/32).int64(message.deadline); + writer.uint32(/* id 5, wireType 2 =*/42).bytes(message.sender); + return writer; + }; + + /** + * Encodes the specified MsgRemoveLiquidity message, length delimited. Does not implicitly {@link irisnet.tx.MsgRemoveLiquidity.verify|verify} messages. + * @function encodeDelimited + * @memberof irisnet.tx.MsgRemoveLiquidity + * @static + * @param {irisnet.tx.IMsgRemoveLiquidity} message MsgRemoveLiquidity message or plain object to encode + * @param {$protobuf.Writer} [writer] Writer to encode to + * @returns {$protobuf.Writer} Writer + */ + MsgRemoveLiquidity.encodeDelimited = function encodeDelimited(message, writer) { + return this.encode(message, writer).ldelim(); + }; + + /** + * Decodes a MsgRemoveLiquidity message from the specified reader or buffer. + * @function decode + * @memberof irisnet.tx.MsgRemoveLiquidity + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @param {number} [length] Message length if known beforehand + * @returns {irisnet.tx.MsgRemoveLiquidity} MsgRemoveLiquidity + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + MsgRemoveLiquidity.decode = function decode(reader, length) { + if (!(reader instanceof $Reader)) + reader = $Reader.create(reader); + var end = length === undefined ? reader.len : reader.pos + length, message = new $root.irisnet.tx.MsgRemoveLiquidity(); + while (reader.pos < end) { + var tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.minToken = reader.string(); + break; + case 2: + message.withdrawLiquidity = $root.irisnet.tx.Coin.decode(reader, reader.uint32()); + break; + case 3: + message.minIrisAmt = reader.string(); + break; + case 4: + message.deadline = reader.int64(); + break; + case 5: + message.sender = reader.bytes(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + if (!message.hasOwnProperty("minToken")) + throw $util.ProtocolError("missing required 'minToken'", { instance: message }); + if (!message.hasOwnProperty("withdrawLiquidity")) + throw $util.ProtocolError("missing required 'withdrawLiquidity'", { instance: message }); + if (!message.hasOwnProperty("minIrisAmt")) + throw $util.ProtocolError("missing required 'minIrisAmt'", { instance: message }); + if (!message.hasOwnProperty("deadline")) + throw $util.ProtocolError("missing required 'deadline'", { instance: message }); + if (!message.hasOwnProperty("sender")) + throw $util.ProtocolError("missing required 'sender'", { instance: message }); + return message; + }; + + /** + * Decodes a MsgRemoveLiquidity message from the specified reader or buffer, length delimited. + * @function decodeDelimited + * @memberof irisnet.tx.MsgRemoveLiquidity + * @static + * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from + * @returns {irisnet.tx.MsgRemoveLiquidity} MsgRemoveLiquidity + * @throws {Error} If the payload is not a reader or valid buffer + * @throws {$protobuf.util.ProtocolError} If required fields are missing + */ + MsgRemoveLiquidity.decodeDelimited = function decodeDelimited(reader) { + if (!(reader instanceof $Reader)) + reader = new $Reader(reader); + return this.decode(reader, reader.uint32()); + }; + + /** + * Verifies a MsgRemoveLiquidity message. + * @function verify + * @memberof irisnet.tx.MsgRemoveLiquidity + * @static + * @param {Object.} message Plain object to verify + * @returns {string|null} `null` if valid, otherwise the reason why it is not + */ + MsgRemoveLiquidity.verify = function verify(message) { + if (typeof message !== "object" || message === null) + return "object expected"; + if (!$util.isString(message.minToken)) + return "minToken: string expected"; + { + var error = $root.irisnet.tx.Coin.verify(message.withdrawLiquidity); + if (error) + return "withdrawLiquidity." + error; + } + if (!$util.isString(message.minIrisAmt)) + return "minIrisAmt: string expected"; + if (!$util.isInteger(message.deadline) && !(message.deadline && $util.isInteger(message.deadline.low) && $util.isInteger(message.deadline.high))) + return "deadline: integer|Long expected"; + if (!(message.sender && typeof message.sender.length === "number" || $util.isString(message.sender))) + return "sender: buffer expected"; + return null; + }; + + /** + * Creates a MsgRemoveLiquidity message from a plain object. Also converts values to their respective internal types. + * @function fromObject + * @memberof irisnet.tx.MsgRemoveLiquidity + * @static + * @param {Object.} object Plain object + * @returns {irisnet.tx.MsgRemoveLiquidity} MsgRemoveLiquidity + */ + MsgRemoveLiquidity.fromObject = function fromObject(object) { + if (object instanceof $root.irisnet.tx.MsgRemoveLiquidity) + return object; + var message = new $root.irisnet.tx.MsgRemoveLiquidity(); + if (object.minToken != null) + message.minToken = String(object.minToken); + if (object.withdrawLiquidity != null) { + if (typeof object.withdrawLiquidity !== "object") + throw TypeError(".irisnet.tx.MsgRemoveLiquidity.withdrawLiquidity: object expected"); + message.withdrawLiquidity = $root.irisnet.tx.Coin.fromObject(object.withdrawLiquidity); + } + if (object.minIrisAmt != null) + message.minIrisAmt = String(object.minIrisAmt); + if (object.deadline != null) + if ($util.Long) + (message.deadline = $util.Long.fromValue(object.deadline)).unsigned = false; + else if (typeof object.deadline === "string") + message.deadline = parseInt(object.deadline, 10); + else if (typeof object.deadline === "number") + message.deadline = object.deadline; + else if (typeof object.deadline === "object") + message.deadline = new $util.LongBits(object.deadline.low >>> 0, object.deadline.high >>> 0).toNumber(); + if (object.sender != null) + if (typeof object.sender === "string") + $util.base64.decode(object.sender, message.sender = $util.newBuffer($util.base64.length(object.sender)), 0); + else if (object.sender.length) + message.sender = object.sender; + return message; + }; + + /** + * Creates a plain object from a MsgRemoveLiquidity message. Also converts values to other types if specified. + * @function toObject + * @memberof irisnet.tx.MsgRemoveLiquidity + * @static + * @param {irisnet.tx.MsgRemoveLiquidity} message MsgRemoveLiquidity + * @param {$protobuf.IConversionOptions} [options] Conversion options + * @returns {Object.} Plain object + */ + MsgRemoveLiquidity.toObject = function toObject(message, options) { + if (!options) + options = {}; + var object = {}; + if (options.defaults) { + object.minToken = ""; + object.withdrawLiquidity = null; + object.minIrisAmt = ""; + if ($util.Long) { + var long = new $util.Long(0, 0, false); + object.deadline = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long; + } else + object.deadline = options.longs === String ? "0" : 0; + if (options.bytes === String) + object.sender = ""; + else { + object.sender = []; + if (options.bytes !== Array) + object.sender = $util.newBuffer(object.sender); + } + } + if (message.minToken != null && message.hasOwnProperty("minToken")) + object.minToken = message.minToken; + if (message.withdrawLiquidity != null && message.hasOwnProperty("withdrawLiquidity")) + object.withdrawLiquidity = $root.irisnet.tx.Coin.toObject(message.withdrawLiquidity, options); + if (message.minIrisAmt != null && message.hasOwnProperty("minIrisAmt")) + object.minIrisAmt = message.minIrisAmt; + if (message.deadline != null && message.hasOwnProperty("deadline")) + if (typeof message.deadline === "number") + object.deadline = options.longs === String ? String(message.deadline) : message.deadline; + else + object.deadline = options.longs === String ? $util.Long.prototype.toString.call(message.deadline) : options.longs === Number ? new $util.LongBits(message.deadline.low >>> 0, message.deadline.high >>> 0).toNumber() : message.deadline; + if (message.sender != null && message.hasOwnProperty("sender")) + object.sender = options.bytes === String ? $util.base64.encode(message.sender, 0, message.sender.length) : options.bytes === Array ? Array.prototype.slice.call(message.sender) : message.sender; + return object; + }; + + /** + * Converts this MsgRemoveLiquidity to JSON. + * @function toJSON + * @memberof irisnet.tx.MsgRemoveLiquidity + * @instance + * @returns {Object.} JSON object + */ + MsgRemoveLiquidity.prototype.toJSON = function toJSON() { + return this.constructor.toObject(this, $protobuf.util.toJSONOptions); + }; + + return MsgRemoveLiquidity; + })(); + tx.StdFee = (function() { /** diff --git a/src/chains/iris/tx/tx_serializer.js b/src/chains/iris/tx/tx_serializer.js index 7cb1379..8ec193b 100644 --- a/src/chains/iris/tx/tx_serializer.js +++ b/src/chains/iris/tx/tx_serializer.js @@ -80,7 +80,6 @@ class TxSerializer { let uvarintBuf = Buffer.from(codec.Uvarint.encode(buf.length)); let bz = Buffer.concat([uvarintBuf, buf]); - const crypto = require('crypto'); const hash = crypto.createHash('sha256'); hash.update(bz); @@ -92,4 +91,4 @@ class TxSerializer { } } } -module.exports = TxSerializer; \ No newline at end of file +module.exports = TxSerializer; diff --git a/src/util/utils.js b/src/util/utils.js index 68528a0..3d30265 100644 --- a/src/util/utils.js +++ b/src/util/utils.js @@ -19,6 +19,8 @@ module.exports = class Utils { tmp[k] = sort(obj[k]); } else if (obj[k] != null && typeof(obj[k]) === "function") { tmp[k] = evil(obj[k].toString()) + } else if (obj[k] != null && typeof (obj[k]) === "boolean") { + tmp[k] = obj[k] } else { tmp[k] = new String(obj[k]).toString(); } diff --git a/test/common.js b/test/common.js index ab56327..65f7bc6 100644 --- a/test/common.js +++ b/test/common.js @@ -41,7 +41,7 @@ async function verifyTx(url, tx, privateKey, chainName,callback) { //console.log(JSON.stringify(stdTx)); let exp = stdTx.Hash(); //console.log(JSON.stringify(exp)); - let payload = stdTx.GetData(); + let payload = stdTx.GetData("block"); let response = await sendByAsync("POST",url,payload); callback(response,exp,payload); @@ -96,4 +96,4 @@ function sendByAsync(method,url,data){ }) } -module.exports = {randomWord,randomHex,verifyTx,verifyAccount,sendBySync,getSequence}; \ No newline at end of file +module.exports = {randomWord,randomHex,verifyTx,verifyAccount,sendBySync,getSequence}; diff --git a/test/test_tx_iris.js b/test/test_tx_iris.js index 5fd4dfc..147dff6 100644 --- a/test/test_tx_iris.js +++ b/test/test_tx_iris.js @@ -333,6 +333,84 @@ describe('iris transaction', function () { extracted(tx); }); + + it('test MsgSwapOrder', function () { + let tx = { + chain_id: chain_id, + from: from, + account_number: account_number, + sequence: 34, + fees: fees, + gas: gas, + memo: memo, + type: Irisnet.config.iris.tx.swapOrder.type, + msg: { + input : { + address:from, + coin:{ + denom: "iris-atto", + amount: "10000000000000000000000000000000" + }, + }, + output : { + address:from, + coin:{ + denom: "btc-min", + amount: "1" + }, + }, + deadline:1565777966877, + isBuyOrder:true + } + }; + extracted(tx); + }); + + it('test MsgAddLiquidity', function () { + let tx = { + chain_id: chain_id, + from: from, + account_number: account_number, + sequence: 29, + fees: fees, + gas: gas, + memo: memo, + type: Irisnet.config.iris.tx.addLiquidity.type, + msg: { + max_token : { + denom: "btc-min", + amount: "10" + }, + exact_iris_amt: "10000000000000000000000", + min_liquidity: "100000000000000000", + deadline:new Date().getTime() + } + }; + extracted(tx); + }); + + it('test MsgRemoveLiquidity', function () { + let tx = { + chain_id: chain_id, + from: from, + account_number: account_number, + sequence: 30, + fees: fees, + gas: gas, + memo: memo, + type: Irisnet.config.iris.tx.removeLiquidity.type, + msg: { + withdraw_liquidity : { + denom: "u-btc-min", + amount: "10000000000000000000000" + }, + min_iris_amt: "10000000000000000", + min_token: "1", + deadline:new Date().getTime() + } + }; + extracted(tx); + }); }); //冷钱包调用 @@ -364,8 +442,9 @@ describe('iris transaction', function () { console.log("hash", result.hash); console.log(`hash=${result.hash}`); + console.log(`hash=${result.hash}`) assert.notExists(resp.code,`tx commit failed,${resp.raw_log}`); - //console.log("displayContent", JSON.stringify(stdTx.GetDisplayContent())); + assert.equal(result.hash,resp.hash) } @@ -384,4 +463,5 @@ describe('iris transaction', function () { function verify(act,exp,data) { assert.notExists(act.check_tx.code,`tx commit failed,${act.check_tx.log}`); + assert.equal(act.hash,exp.hash) }