juno-network 0.5.3 → 0.6.0

package/module/codegen/cosmwasm/bundle.js

@@ -0,0 +1,31 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import * as _45 from "./wasm/v1/genesis";
+import * as _46 from "./wasm/v1/ibc";
+import * as _47 from "./wasm/v1/proposal";
+import * as _48 from "./wasm/v1/query";
+import * as _49 from "./wasm/v1/tx";
+import * as _50 from "./wasm/v1/types";
+import * as _131 from "./wasm/v1/tx.amino";
+import * as _132 from "./wasm/v1/tx.registry";
+import * as _133 from "./wasm/v1/query.lcd";
+import * as _134 from "./wasm/v1/query.rpc.query";
+import * as _135 from "./wasm/v1/tx.rpc.msg";
+import * as _161 from "./lcd";
+import * as _162 from "./rpc.query";
+import * as _163 from "./rpc.tx";
+export let cosmwasm;
+
+(function (_cosmwasm) {
+  let wasm;
+
+  (function (_wasm) {
+    const v1 = _wasm.v1 = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, _45), _46), _47), _48), _49), _50), _131), _132), _133), _134), _135);
+  })(wasm || (wasm = _cosmwasm.wasm || (_cosmwasm.wasm = {})));
+
+  const ClientFactory = _cosmwasm.ClientFactory = _objectSpread(_objectSpread(_objectSpread({}, _161), _162), _163);
+})(cosmwasm || (cosmwasm = {}));

package/module/codegen/cosmwasm/client.js

@@ -0,0 +1,39 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { Registry } from "@cosmjs/proto-signing";
+import { defaultRegistryTypes, AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+import * as cosmwasmWasmV1TxRegistry from "./wasm/v1/tx.registry";
+import * as cosmwasmWasmV1TxAmino from "./wasm/v1/tx.amino";
+export const cosmwasmAminoConverters = _objectSpread({}, cosmwasmWasmV1TxAmino.AminoConverter);
+export const cosmwasmProtoRegistry = [...cosmwasmWasmV1TxRegistry.registry];
+export const getSigningCosmwasmClientOptions = ({
+  defaultTypes = defaultRegistryTypes
+} = {}) => {
+  const registry = new Registry([...defaultTypes, ...cosmwasmProtoRegistry]);
+  const aminoTypes = new AminoTypes(_objectSpread({}, cosmwasmAminoConverters));
+  return {
+    registry,
+    aminoTypes
+  };
+};
+export const getSigningCosmwasmClient = async ({
+  rpcEndpoint,
+  signer,
+  defaultTypes = defaultRegistryTypes
+}) => {
+  const {
+    registry,
+    aminoTypes
+  } = getSigningCosmwasmClientOptions({
+    defaultTypes
+  });
+  const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+    registry,
+    aminoTypes
+  });
+  return client;
+};

package/module/codegen/cosmwasm/lcd.js

@@ -0,0 +1,57 @@
+import { LCDClient } from "@osmonauts/lcd";
+export const createLCDClient = async ({
+  restEndpoint
+}) => {
+  const requestClient = new LCDClient({
+    restEndpoint
+  });
+  return {
+    cosmos: {
+      authz: {
+        v1beta1: new (await import("../cosmos/authz/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      bank: {
+        v1beta1: new (await import("../cosmos/bank/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      distribution: {
+        v1beta1: new (await import("../cosmos/distribution/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      gov: {
+        v1: new (await import("../cosmos/gov/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        }),
+        v1beta1: new (await import("../cosmos/gov/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      staking: {
+        v1beta1: new (await import("../cosmos/staking/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      tx: {
+        v1beta1: new (await import("../cosmos/tx/v1beta1/service.lcd")).LCDQueryClient({
+          requestClient
+        })
+      },
+      upgrade: {
+        v1beta1: new (await import("../cosmos/upgrade/v1beta1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      }
+    },
+    cosmwasm: {
+      wasm: {
+        v1: new (await import("./wasm/v1/query.lcd")).LCDQueryClient({
+          requestClient
+        })
+      }
+    }
+  };
+};

package/module/codegen/cosmwasm/rpc.query.js

@@ -0,0 +1,39 @@
+import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
+import { QueryClient } from "@cosmjs/stargate";
+export const createRPCQueryClient = async ({
+  rpcEndpoint
+}) => {
+  const tmClient = await Tendermint34Client.connect(rpcEndpoint);
+  const client = new QueryClient(tmClient);
+  return {
+    cosmos: {
+      authz: {
+        v1beta1: (await import("../cosmos/authz/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      },
+      bank: {
+        v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      },
+      distribution: {
+        v1beta1: (await import("../cosmos/distribution/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      },
+      gov: {
+        v1: (await import("../cosmos/gov/v1/query.rpc.query")).createRpcQueryExtension(client),
+        v1beta1: (await import("../cosmos/gov/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      },
+      staking: {
+        v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      },
+      tx: {
+        v1beta1: (await import("../cosmos/tx/v1beta1/service.rpc.svc")).createRpcQueryExtension(client)
+      },
+      upgrade: {
+        v1beta1: (await import("../cosmos/upgrade/v1beta1/query.rpc.query")).createRpcQueryExtension(client)
+      }
+    },
+    cosmwasm: {
+      wasm: {
+        v1: (await import("./wasm/v1/query.rpc.query")).createRpcQueryExtension(client)
+      }
+    }
+  };
+};

package/module/codegen/cosmwasm/rpc.tx.js

@@ -0,0 +1,30 @@
+export const createRPCMsgClient = async ({
+  rpc
+}) => ({
+  cosmos: {
+    authz: {
+      v1beta1: new (await import("../cosmos/authz/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    bank: {
+      v1beta1: new (await import("../cosmos/bank/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    distribution: {
+      v1beta1: new (await import("../cosmos/distribution/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    gov: {
+      v1: new (await import("../cosmos/gov/v1/tx.rpc.msg")).MsgClientImpl(rpc),
+      v1beta1: new (await import("../cosmos/gov/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    staking: {
+      v1beta1: new (await import("../cosmos/staking/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    },
+    upgrade: {
+      v1beta1: new (await import("../cosmos/upgrade/v1beta1/tx.rpc.msg")).MsgClientImpl(rpc)
+    }
+  },
+  cosmwasm: {
+    wasm: {
+      v1: new (await import("./wasm/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+    }
+  }
+});

package/module/codegen/cosmwasm/wasm/v1/genesis.js

@@ -0,0 +1,358 @@
+import { MsgStoreCode, MsgInstantiateContract, MsgExecuteContract } from "./tx";
+import { Params, CodeInfo, ContractInfo, Model } from "./types";
+import * as _m0 from "protobufjs/minimal";
+import { Long } from "@osmonauts/helpers";
+/** GenesisState - genesis state of x/wasm */
+
+function createBaseGenesisState() {
+  return {
+    params: undefined,
+    codes: [],
+    contracts: [],
+    sequences: [],
+    genMsgs: []
+  };
+}
+
+export const GenesisState = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+
+    for (const v of message.codes) {
+      Code.encode(v, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.contracts) {
+      Contract.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+
+    for (const v of message.sequences) {
+      Sequence.encode(v, writer.uint32(34).fork()).ldelim();
+    }
+
+    for (const v of message.genMsgs) {
+      GenesisState_GenMsgs.encode(v, writer.uint32(42).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.codes.push(Code.decode(reader, reader.uint32()));
+          break;
+
+        case 3:
+          message.contracts.push(Contract.decode(reader, reader.uint32()));
+          break;
+
+        case 4:
+          message.sequences.push(Sequence.decode(reader, reader.uint32()));
+          break;
+
+        case 5:
+          message.genMsgs.push(GenesisState_GenMsgs.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$codes, _object$contracts, _object$sequences, _object$genMsgs;
+
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.codes = ((_object$codes = object.codes) === null || _object$codes === void 0 ? void 0 : _object$codes.map(e => Code.fromPartial(e))) || [];
+    message.contracts = ((_object$contracts = object.contracts) === null || _object$contracts === void 0 ? void 0 : _object$contracts.map(e => Contract.fromPartial(e))) || [];
+    message.sequences = ((_object$sequences = object.sequences) === null || _object$sequences === void 0 ? void 0 : _object$sequences.map(e => Sequence.fromPartial(e))) || [];
+    message.genMsgs = ((_object$genMsgs = object.genMsgs) === null || _object$genMsgs === void 0 ? void 0 : _object$genMsgs.map(e => GenesisState_GenMsgs.fromPartial(e))) || [];
+    return message;
+  }
+
+};
+
+function createBaseGenesisState_GenMsgs() {
+  return {
+    storeCode: undefined,
+    instantiateContract: undefined,
+    executeContract: undefined
+  };
+}
+
+export const GenesisState_GenMsgs = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.storeCode !== undefined) {
+      MsgStoreCode.encode(message.storeCode, writer.uint32(10).fork()).ldelim();
+    }
+
+    if (message.instantiateContract !== undefined) {
+      MsgInstantiateContract.encode(message.instantiateContract, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.executeContract !== undefined) {
+      MsgExecuteContract.encode(message.executeContract, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState_GenMsgs();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.storeCode = MsgStoreCode.decode(reader, reader.uint32());
+          break;
+
+        case 2:
+          message.instantiateContract = MsgInstantiateContract.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.executeContract = MsgExecuteContract.decode(reader, reader.uint32());
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    const message = createBaseGenesisState_GenMsgs();
+    message.storeCode = object.storeCode !== undefined && object.storeCode !== null ? MsgStoreCode.fromPartial(object.storeCode) : undefined;
+    message.instantiateContract = object.instantiateContract !== undefined && object.instantiateContract !== null ? MsgInstantiateContract.fromPartial(object.instantiateContract) : undefined;
+    message.executeContract = object.executeContract !== undefined && object.executeContract !== null ? MsgExecuteContract.fromPartial(object.executeContract) : undefined;
+    return message;
+  }
+
+};
+
+function createBaseCode() {
+  return {
+    codeId: Long.UZERO,
+    codeInfo: undefined,
+    codeBytes: new Uint8Array(),
+    pinned: false
+  };
+}
+
+export const Code = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (!message.codeId.isZero()) {
+      writer.uint32(8).uint64(message.codeId);
+    }
+
+    if (message.codeInfo !== undefined) {
+      CodeInfo.encode(message.codeInfo, writer.uint32(18).fork()).ldelim();
+    }
+
+    if (message.codeBytes.length !== 0) {
+      writer.uint32(26).bytes(message.codeBytes);
+    }
+
+    if (message.pinned === true) {
+      writer.uint32(32).bool(message.pinned);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCode();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.codeId = reader.uint64();
+          break;
+
+        case 2:
+          message.codeInfo = CodeInfo.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.codeBytes = reader.bytes();
+          break;
+
+        case 4:
+          message.pinned = reader.bool();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$codeBytes, _object$pinned;
+
+    const message = createBaseCode();
+    message.codeId = object.codeId !== undefined && object.codeId !== null ? Long.fromValue(object.codeId) : Long.UZERO;
+    message.codeInfo = object.codeInfo !== undefined && object.codeInfo !== null ? CodeInfo.fromPartial(object.codeInfo) : undefined;
+    message.codeBytes = (_object$codeBytes = object.codeBytes) !== null && _object$codeBytes !== void 0 ? _object$codeBytes : new Uint8Array();
+    message.pinned = (_object$pinned = object.pinned) !== null && _object$pinned !== void 0 ? _object$pinned : false;
+    return message;
+  }
+
+};
+
+function createBaseContract() {
+  return {
+    contractAddress: "",
+    contractInfo: undefined,
+    contractState: []
+  };
+}
+
+export const Contract = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.contractAddress !== "") {
+      writer.uint32(10).string(message.contractAddress);
+    }
+
+    if (message.contractInfo !== undefined) {
+      ContractInfo.encode(message.contractInfo, writer.uint32(18).fork()).ldelim();
+    }
+
+    for (const v of message.contractState) {
+      Model.encode(v, writer.uint32(26).fork()).ldelim();
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseContract();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.contractAddress = reader.string();
+          break;
+
+        case 2:
+          message.contractInfo = ContractInfo.decode(reader, reader.uint32());
+          break;
+
+        case 3:
+          message.contractState.push(Model.decode(reader, reader.uint32()));
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$contractAddre, _object$contractState;
+
+    const message = createBaseContract();
+    message.contractAddress = (_object$contractAddre = object.contractAddress) !== null && _object$contractAddre !== void 0 ? _object$contractAddre : "";
+    message.contractInfo = object.contractInfo !== undefined && object.contractInfo !== null ? ContractInfo.fromPartial(object.contractInfo) : undefined;
+    message.contractState = ((_object$contractState = object.contractState) === null || _object$contractState === void 0 ? void 0 : _object$contractState.map(e => Model.fromPartial(e))) || [];
+    return message;
+  }
+
+};
+
+function createBaseSequence() {
+  return {
+    idKey: new Uint8Array(),
+    value: Long.UZERO
+  };
+}
+
+export const Sequence = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.idKey.length !== 0) {
+      writer.uint32(10).bytes(message.idKey);
+    }
+
+    if (!message.value.isZero()) {
+      writer.uint32(16).uint64(message.value);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSequence();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 1:
+          message.idKey = reader.bytes();
+          break;
+
+        case 2:
+          message.value = reader.uint64();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$idKey;
+
+    const message = createBaseSequence();
+    message.idKey = (_object$idKey = object.idKey) !== null && _object$idKey !== void 0 ? _object$idKey : new Uint8Array();
+    message.value = object.value !== undefined && object.value !== null ? Long.fromValue(object.value) : Long.UZERO;
+    return message;
+  }
+
+};

package/module/codegen/cosmwasm/wasm/v1/ibc.js

@@ -0,0 +1,127 @@
+import * as _m0 from "protobufjs/minimal";
+import { Long } from "@osmonauts/helpers";
+/** MsgIBCSend */
+
+function createBaseMsgIBCSend() {
+  return {
+    channel: "",
+    timeoutHeight: Long.UZERO,
+    timeoutTimestamp: Long.UZERO,
+    data: new Uint8Array()
+  };
+}
+
+export const MsgIBCSend = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.channel !== "") {
+      writer.uint32(18).string(message.channel);
+    }
+
+    if (!message.timeoutHeight.isZero()) {
+      writer.uint32(32).uint64(message.timeoutHeight);
+    }
+
+    if (!message.timeoutTimestamp.isZero()) {
+      writer.uint32(40).uint64(message.timeoutTimestamp);
+    }
+
+    if (message.data.length !== 0) {
+      writer.uint32(50).bytes(message.data);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgIBCSend();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 2:
+          message.channel = reader.string();
+          break;
+
+        case 4:
+          message.timeoutHeight = reader.uint64();
+          break;
+
+        case 5:
+          message.timeoutTimestamp = reader.uint64();
+          break;
+
+        case 6:
+          message.data = reader.bytes();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$channel, _object$data;
+
+    const message = createBaseMsgIBCSend();
+    message.channel = (_object$channel = object.channel) !== null && _object$channel !== void 0 ? _object$channel : "";
+    message.timeoutHeight = object.timeoutHeight !== undefined && object.timeoutHeight !== null ? Long.fromValue(object.timeoutHeight) : Long.UZERO;
+    message.timeoutTimestamp = object.timeoutTimestamp !== undefined && object.timeoutTimestamp !== null ? Long.fromValue(object.timeoutTimestamp) : Long.UZERO;
+    message.data = (_object$data = object.data) !== null && _object$data !== void 0 ? _object$data : new Uint8Array();
+    return message;
+  }
+
+};
+
+function createBaseMsgIBCCloseChannel() {
+  return {
+    channel: ""
+  };
+}
+
+export const MsgIBCCloseChannel = {
+  encode(message, writer = _m0.Writer.create()) {
+    if (message.channel !== "") {
+      writer.uint32(18).string(message.channel);
+    }
+
+    return writer;
+  },
+
+  decode(input, length) {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgIBCCloseChannel();
+
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+
+      switch (tag >>> 3) {
+        case 2:
+          message.channel = reader.string();
+          break;
+
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+
+    return message;
+  },
+
+  fromPartial(object) {
+    var _object$channel2;
+
+    const message = createBaseMsgIBCCloseChannel();
+    message.channel = (_object$channel2 = object.channel) !== null && _object$channel2 !== void 0 ? _object$channel2 : "";
+    return message;
+  }
+
+};