@block52/poker-vm-sdk 1.2.3 → 1.2.5

package/dist/index.js

@@ -5,6 +5,7 @@ var stargate = require('@cosmjs/stargate');
 var events = require('events');
 var crypto = require('@cosmjs/crypto');
 var crypto$1 = require('crypto');
+var encoding = require('@cosmjs/encoding');
 
 /// <reference path="./types.d.ts" />
 const defaultFee$q = {
@@ -4169,6 +4170,74 @@ const MsgDeleteGame = {
         return message;
     },
 };
+function createBaseMsgForceCloseGame() {
+    return { creator: "", gameId: "" };
+}
+const MsgForceCloseGame = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.gameId !== "") {
+            writer.uint32(18).string(message.gameId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgForceCloseGame();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.creator = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.gameId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            creator: isSet$2b(object.creator) ? globalThis.String(object.creator) : "",
+            gameId: isSet$2b(object.gameId) ? globalThis.String(object.gameId) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.creator !== "") {
+            obj.creator = message.creator;
+        }
+        if (message.gameId !== "") {
+            obj.gameId = message.gameId;
+        }
+        return obj;
+    },
+    create(base) {
+        return MsgForceCloseGame.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseMsgForceCloseGame();
+        message.creator = object.creator ?? "";
+        message.gameId = object.gameId ?? "";
+        return message;
+    },
+};
 function createBaseMsgRegisterNftAvatar() {
     return { creator: "", ethAddress: "", contractAddress: "", tokenId: "", ethSignature: "" };
 }
@@ -4302,6 +4371,7 @@ const msgTypes$u = [
     ["/pokerchain.poker.v1.MsgUpdateEthBlockHeight", MsgUpdateEthBlockHeight],
     ["/pokerchain.poker.v1.MsgTopUp", MsgTopUp],
     ["/pokerchain.poker.v1.MsgDeleteGame", MsgDeleteGame],
+    ["/pokerchain.poker.v1.MsgForceCloseGame", MsgForceCloseGame],
     ["/pokerchain.poker.v1.MsgRegisterNftAvatar", MsgRegisterNftAvatar],
 ];
 
@@ -57681,6 +57751,2982 @@ const getDefaultCosmosConfig = (domain = "localhost") => ({
     gasPrice: "0.0stake" // Gas price in stake (not used in REST-only mode)
 });
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var tx = {};
+
+var any = {};
+
+var binary = {};
+
+var utf8 = {};
+
+/* eslint-disable */
+
+var hasRequiredUtf8;
+
+function requireUtf8 () {
+	if (hasRequiredUtf8) return utf8;
+	hasRequiredUtf8 = 1;
+	Object.defineProperty(utf8, "__esModule", { value: true });
+	utf8.utf8Write = utf8.utf8Read = utf8.utf8Length = void 0;
+	/**
+	 * Calculates the UTF8 byte length of a string.
+	 * @param {string} string String
+	 * @returns {number} Byte length
+	 */
+	function utf8Length(str) {
+	    let len = 0, c = 0;
+	    for (let i = 0; i < str.length; ++i) {
+	        c = str.charCodeAt(i);
+	        if (c < 128)
+	            len += 1;
+	        else if (c < 2048)
+	            len += 2;
+	        else if ((c & 0xfc00) === 0xd800 && (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
+	            ++i;
+	            len += 4;
+	        }
+	        else
+	            len += 3;
+	    }
+	    return len;
+	}
+	utf8.utf8Length = utf8Length;
+	/**
+	 * Reads UTF8 bytes as a string.
+	 * @param {Uint8Array} buffer Source buffer
+	 * @param {number} start Source start
+	 * @param {number} end Source end
+	 * @returns {string} String read
+	 */
+	function utf8Read(buffer, start, end) {
+	    const len = end - start;
+	    if (len < 1)
+	        return "";
+	    const chunk = [];
+	    let parts = [], i = 0, // char offset
+	    t; // temporary
+	    while (start < end) {
+	        t = buffer[start++];
+	        if (t < 128)
+	            chunk[i++] = t;
+	        else if (t > 191 && t < 224)
+	            chunk[i++] = ((t & 31) << 6) | (buffer[start++] & 63);
+	        else if (t > 239 && t < 365) {
+	            t =
+	                (((t & 7) << 18) |
+	                    ((buffer[start++] & 63) << 12) |
+	                    ((buffer[start++] & 63) << 6) |
+	                    (buffer[start++] & 63)) -
+	                    0x10000;
+	            chunk[i++] = 0xd800 + (t >> 10);
+	            chunk[i++] = 0xdc00 + (t & 1023);
+	        }
+	        else
+	            chunk[i++] = ((t & 15) << 12) | ((buffer[start++] & 63) << 6) | (buffer[start++] & 63);
+	        if (i > 8191) {
+	            (parts || (parts = [])).push(String.fromCharCode(...chunk));
+	            i = 0;
+	        }
+	    }
+	    if (parts) {
+	        if (i)
+	            parts.push(String.fromCharCode(...chunk.slice(0, i)));
+	        return parts.join("");
+	    }
+	    return String.fromCharCode(...chunk.slice(0, i));
+	}
+	utf8.utf8Read = utf8Read;
+	/**
+	 * Writes a string as UTF8 bytes.
+	 * @param {string} string Source string
+	 * @param {Uint8Array} buffer Destination buffer
+	 * @param {number} offset Destination offset
+	 * @returns {number} Bytes written
+	 */
+	function utf8Write(str, buffer, offset) {
+	    const start = offset;
+	    let c1, // character 1
+	    c2; // character 2
+	    for (let i = 0; i < str.length; ++i) {
+	        c1 = str.charCodeAt(i);
+	        if (c1 < 128) {
+	            buffer[offset++] = c1;
+	        }
+	        else if (c1 < 2048) {
+	            buffer[offset++] = (c1 >> 6) | 192;
+	            buffer[offset++] = (c1 & 63) | 128;
+	        }
+	        else if ((c1 & 0xfc00) === 0xd800 && ((c2 = str.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
+	            c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
+	            ++i;
+	            buffer[offset++] = (c1 >> 18) | 240;
+	            buffer[offset++] = ((c1 >> 12) & 63) | 128;
+	            buffer[offset++] = ((c1 >> 6) & 63) | 128;
+	            buffer[offset++] = (c1 & 63) | 128;
+	        }
+	        else {
+	            buffer[offset++] = (c1 >> 12) | 224;
+	            buffer[offset++] = ((c1 >> 6) & 63) | 128;
+	            buffer[offset++] = (c1 & 63) | 128;
+	        }
+	    }
+	    return offset - start;
+	}
+	utf8.utf8Write = utf8Write;
+	
+	return utf8;
+}
+
+var varint = {};
+
+var hasRequiredVarint;
+
+function requireVarint () {
+	if (hasRequiredVarint) return varint;
+	hasRequiredVarint = 1;
+	/* eslint-disable */
+	/**
+	 * This file and any referenced files were automatically generated by @cosmology/telescope@1.0.7
+	 * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+	 * and run the transpile command or yarn proto command to regenerate this bundle.
+	 */
+	Object.defineProperty(varint, "__esModule", { value: true });
+	varint.writeByte = varint.writeFixed32 = varint.int64Length = varint.writeVarint64 = varint.writeVarint32 = varint.readInt32 = varint.readUInt32 = varint.zzDecode = varint.zzEncode = varint.varint32read = varint.varint32write = varint.uInt64ToString = varint.int64ToString = varint.int64FromString = varint.varint64write = varint.varint64read = void 0;
+	// Copyright 2008 Google Inc.  All rights reserved.
+	//
+	// Redistribution and use in source and binary forms, with or without
+	// modification, are permitted provided that the following conditions are
+	// met:
+	//
+	// * Redistributions of source code must retain the above copyright
+	// notice, this list of conditions and the following disclaimer.
+	// * Redistributions in binary form must reproduce the above
+	// copyright notice, this list of conditions and the following disclaimer
+	// in the documentation and/or other materials provided with the
+	// distribution.
+	// * Neither the name of Google Inc. nor the names of its
+	// contributors may be used to endorse or promote products derived from
+	// this software without specific prior written permission.
+	//
+	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	//
+	// Code generated by the Protocol Buffer compiler is owned by the owner
+	// of the input file used when generating it.  This code is not
+	// standalone and requires a support library to be linked with it.  This
+	// support library is itself covered by the above license.
+	/* eslint-disable prefer-const,@typescript-eslint/restrict-plus-operands */
+	/**
+	 * Read a 64 bit varint as two JS numbers.
+	 *
+	 * Returns tuple:
+	 * [0]: low bits
+	 * [1]: high bits
+	 *
+	 * Copyright 2008 Google Inc.  All rights reserved.
+	 *
+	 * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+	 */
+	function varint64read() {
+	    let lowBits = 0;
+	    let highBits = 0;
+	    for (let shift = 0; shift < 28; shift += 7) {
+	        let b = this.buf[this.pos++];
+	        lowBits |= (b & 0x7f) << shift;
+	        if ((b & 0x80) == 0) {
+	            this.assertBounds();
+	            return [lowBits, highBits];
+	        }
+	    }
+	    let middleByte = this.buf[this.pos++];
+	    // last four bits of the first 32 bit number
+	    lowBits |= (middleByte & 0x0f) << 28;
+	    // 3 upper bits are part of the next 32 bit number
+	    highBits = (middleByte & 0x70) >> 4;
+	    if ((middleByte & 0x80) == 0) {
+	        this.assertBounds();
+	        return [lowBits, highBits];
+	    }
+	    for (let shift = 3; shift <= 31; shift += 7) {
+	        let b = this.buf[this.pos++];
+	        highBits |= (b & 0x7f) << shift;
+	        if ((b & 0x80) == 0) {
+	            this.assertBounds();
+	            return [lowBits, highBits];
+	        }
+	    }
+	    throw new Error("invalid varint");
+	}
+	varint.varint64read = varint64read;
+	/**
+	 * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+	 *
+	 * Copyright 2008 Google Inc.  All rights reserved.
+	 *
+	 * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+	 */
+	function varint64write(lo, hi, bytes) {
+	    for (let i = 0; i < 28; i = i + 7) {
+	        const shift = lo >>> i;
+	        const hasNext = !(shift >>> 7 == 0 && hi == 0);
+	        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+	        bytes.push(byte);
+	        if (!hasNext) {
+	            return;
+	        }
+	    }
+	    const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
+	    const hasMoreBits = !(hi >> 3 == 0);
+	    bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff);
+	    if (!hasMoreBits) {
+	        return;
+	    }
+	    for (let i = 3; i < 31; i = i + 7) {
+	        const shift = hi >>> i;
+	        const hasNext = !(shift >>> 7 == 0);
+	        const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+	        bytes.push(byte);
+	        if (!hasNext) {
+	            return;
+	        }
+	    }
+	    bytes.push((hi >>> 31) & 0x01);
+	}
+	varint.varint64write = varint64write;
+	// constants for binary math
+	const TWO_PWR_32_DBL = 0x100000000;
+	/**
+	 * Parse decimal string of 64 bit integer value as two JS numbers.
+	 *
+	 * Copyright 2008 Google Inc.  All rights reserved.
+	 *
+	 * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+	 */
+	function int64FromString(dec) {
+	    // Check for minus sign.
+	    const minus = dec[0] === "-";
+	    if (minus) {
+	        dec = dec.slice(1);
+	    }
+	    // Work 6 decimal digits at a time, acting like we're converting base 1e6
+	    // digits to binary. This is safe to do with floating point math because
+	    // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
+	    const base = 1e6;
+	    let lowBits = 0;
+	    let highBits = 0;
+	    function add1e6digit(begin, end) {
+	        // Note: Number('') is 0.
+	        const digit1e6 = Number(dec.slice(begin, end));
+	        highBits *= base;
+	        lowBits = lowBits * base + digit1e6;
+	        // Carry bits from lowBits to
+	        if (lowBits >= TWO_PWR_32_DBL) {
+	            highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
+	            lowBits = lowBits % TWO_PWR_32_DBL;
+	        }
+	    }
+	    add1e6digit(-24, -18);
+	    add1e6digit(-18, -12);
+	    add1e6digit(-12, -6);
+	    add1e6digit(-6);
+	    return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+	}
+	varint.int64FromString = int64FromString;
+	/**
+	 * Losslessly converts a 64-bit signed integer in 32:32 split representation
+	 * into a decimal string.
+	 *
+	 * Copyright 2008 Google Inc.  All rights reserved.
+	 *
+	 * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+	 */
+	function int64ToString(lo, hi) {
+	    let bits = newBits(lo, hi);
+	    // If we're treating the input as a signed value and the high bit is set, do
+	    // a manual two's complement conversion before the decimal conversion.
+	    const negative = bits.hi & 0x80000000;
+	    if (negative) {
+	        bits = negate(bits.lo, bits.hi);
+	    }
+	    const result = uInt64ToString(bits.lo, bits.hi);
+	    return negative ? "-" + result : result;
+	}
+	varint.int64ToString = int64ToString;
+	/**
+	 * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+	 * into a decimal string.
+	 *
+	 * Copyright 2008 Google Inc.  All rights reserved.
+	 *
+	 * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+	 */
+	function uInt64ToString(lo, hi) {
+	    ({ lo, hi } = toUnsigned(lo, hi));
+	    // Skip the expensive conversion if the number is small enough to use the
+	    // built-in conversions.
+	    // Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with
+	    // highBits <= 0x1FFFFF can be safely expressed with a double and retain
+	    // integer precision.
+	    // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true.
+	    if (hi <= 0x1fffff) {
+	        return String(TWO_PWR_32_DBL * hi + lo);
+	    }
+	    // What this code is doing is essentially converting the input number from
+	    // base-2 to base-1e7, which allows us to represent the 64-bit range with
+	    // only 3 (very large) digits. Those digits are then trivial to convert to
+	    // a base-10 string.
+	    // The magic numbers used here are -
+	    // 2^24 = 16777216 = (1,6777216) in base-1e7.
+	    // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
+	    // Split 32:32 representation into 16:24:24 representation so our
+	    // intermediate digits don't overflow.
+	    const low = lo & 0xffffff;
+	    const mid = ((lo >>> 24) | (hi << 8)) & 0xffffff;
+	    const high = (hi >> 16) & 0xffff;
+	    // Assemble our three base-1e7 digits, ignoring carries. The maximum
+	    // value in a digit at this step is representable as a 48-bit integer, which
+	    // can be stored in a 64-bit floating point number.
+	    let digitA = low + mid * 6777216 + high * 6710656;
+	    let digitB = mid + high * 8147497;
+	    let digitC = high * 2;
+	    // Apply carries from A to B and from B to C.
+	    const base = 10000000;
+	    if (digitA >= base) {
+	        digitB += Math.floor(digitA / base);
+	        digitA %= base;
+	    }
+	    if (digitB >= base) {
+	        digitC += Math.floor(digitB / base);
+	        digitB %= base;
+	    }
+	    // If digitC is 0, then we should have returned in the trivial code path
+	    // at the top for non-safe integers. Given this, we can assume both digitB
+	    // and digitA need leading zeros.
+	    return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) + decimalFrom1e7WithLeadingZeros(digitA);
+	}
+	varint.uInt64ToString = uInt64ToString;
+	function toUnsigned(lo, hi) {
+	    return { lo: lo >>> 0, hi: hi >>> 0 };
+	}
+	function newBits(lo, hi) {
+	    return { lo: lo | 0, hi: hi | 0 };
+	}
+	/**
+	 * Returns two's compliment negation of input.
+	 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers
+	 */
+	function negate(lowBits, highBits) {
+	    highBits = ~highBits;
+	    if (lowBits) {
+	        lowBits = ~lowBits + 1;
+	    }
+	    else {
+	        // If lowBits is 0, then bitwise-not is 0xFFFFFFFF,
+	        // adding 1 to that, results in 0x100000000, which leaves
+	        // the low bits 0x0 and simply adds one to the high bits.
+	        highBits += 1;
+	    }
+	    return newBits(lowBits, highBits);
+	}
+	/**
+	 * Returns decimal representation of digit1e7 with leading zeros.
+	 */
+	const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+	    const partial = String(digit1e7);
+	    return "0000000".slice(partial.length) + partial;
+	};
+	/**
+	 * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+	 *
+	 * Copyright 2008 Google Inc.  All rights reserved.
+	 *
+	 * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+	 */
+	function varint32write(value, bytes) {
+	    if (value >= 0) {
+	        // write value as varint 32
+	        while (value > 0x7f) {
+	            bytes.push((value & 0x7f) | 0x80);
+	            value = value >>> 7;
+	        }
+	        bytes.push(value);
+	    }
+	    else {
+	        for (let i = 0; i < 9; i++) {
+	            bytes.push((value & 127) | 128);
+	            value = value >> 7;
+	        }
+	        bytes.push(1);
+	    }
+	}
+	varint.varint32write = varint32write;
+	/**
+	 * Read an unsigned 32 bit varint.
+	 *
+	 * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+	 */
+	function varint32read() {
+	    let b = this.buf[this.pos++];
+	    let result = b & 0x7f;
+	    if ((b & 0x80) == 0) {
+	        this.assertBounds();
+	        return result;
+	    }
+	    b = this.buf[this.pos++];
+	    result |= (b & 0x7f) << 7;
+	    if ((b & 0x80) == 0) {
+	        this.assertBounds();
+	        return result;
+	    }
+	    b = this.buf[this.pos++];
+	    result |= (b & 0x7f) << 14;
+	    if ((b & 0x80) == 0) {
+	        this.assertBounds();
+	        return result;
+	    }
+	    b = this.buf[this.pos++];
+	    result |= (b & 0x7f) << 21;
+	    if ((b & 0x80) == 0) {
+	        this.assertBounds();
+	        return result;
+	    }
+	    // Extract only last 4 bits
+	    b = this.buf[this.pos++];
+	    result |= (b & 0x0f) << 28;
+	    for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++)
+	        b = this.buf[this.pos++];
+	    if ((b & 0x80) != 0)
+	        throw new Error("invalid varint");
+	    this.assertBounds();
+	    // Result can have 32 bits, convert it to unsigned
+	    return result >>> 0;
+	}
+	varint.varint32read = varint32read;
+	/**
+	 * encode zig zag
+	 */
+	function zzEncode(lo, hi) {
+	    let mask = hi >> 31;
+	    hi = (((hi << 1) | (lo >>> 31)) ^ mask) >>> 0;
+	    lo = ((lo << 1) ^ mask) >>> 0;
+	    return [lo, hi];
+	}
+	varint.zzEncode = zzEncode;
+	/**
+	 * decode zig zag
+	 */
+	function zzDecode(lo, hi) {
+	    let mask = -(lo & 1);
+	    lo = (((lo >>> 1) | (hi << 31)) ^ mask) >>> 0;
+	    hi = ((hi >>> 1) ^ mask) >>> 0;
+	    return [lo, hi];
+	}
+	varint.zzDecode = zzDecode;
+	/**
+	 * unsigned int32 without moving pos.
+	 */
+	function readUInt32(buf, pos) {
+	    return (buf[pos] | (buf[pos + 1] << 8) | (buf[pos + 2] << 16)) + buf[pos + 3] * 0x1000000;
+	}
+	varint.readUInt32 = readUInt32;
+	/**
+	 * signed int32 without moving pos.
+	 */
+	function readInt32(buf, pos) {
+	    return (buf[pos] | (buf[pos + 1] << 8) | (buf[pos + 2] << 16)) + (buf[pos + 3] << 24);
+	}
+	varint.readInt32 = readInt32;
+	/**
+	 * writing varint32 to pos
+	 */
+	function writeVarint32(val, buf, pos) {
+	    while (val > 127) {
+	        buf[pos++] = (val & 127) | 128;
+	        val >>>= 7;
+	    }
+	    buf[pos] = val;
+	}
+	varint.writeVarint32 = writeVarint32;
+	/**
+	 * writing varint64 to pos
+	 */
+	function writeVarint64(val, buf, pos) {
+	    while (val.hi) {
+	        buf[pos++] = (val.lo & 127) | 128;
+	        val.lo = ((val.lo >>> 7) | (val.hi << 25)) >>> 0;
+	        val.hi >>>= 7;
+	    }
+	    while (val.lo > 127) {
+	        buf[pos++] = (val.lo & 127) | 128;
+	        val.lo = val.lo >>> 7;
+	    }
+	    buf[pos++] = val.lo;
+	}
+	varint.writeVarint64 = writeVarint64;
+	function int64Length(lo, hi) {
+	    let part0 = lo, part1 = ((lo >>> 28) | (hi << 4)) >>> 0, part2 = hi >>> 24;
+	    return part2 === 0
+	        ? part1 === 0
+	            ? part0 < 16384
+	                ? part0 < 128
+	                    ? 1
+	                    : 2
+	                : part0 < 2097152
+	                    ? 3
+	                    : 4
+	            : part1 < 16384
+	                ? part1 < 128
+	                    ? 5
+	                    : 6
+	                : part1 < 2097152
+	                    ? 7
+	                    : 8
+	        : part2 < 128
+	            ? 9
+	            : 10;
+	}
+	varint.int64Length = int64Length;
+	function writeFixed32(val, buf, pos) {
+	    buf[pos] = val & 255;
+	    buf[pos + 1] = (val >>> 8) & 255;
+	    buf[pos + 2] = (val >>> 16) & 255;
+	    buf[pos + 3] = val >>> 24;
+	}
+	varint.writeFixed32 = writeFixed32;
+	function writeByte(val, buf, pos) {
+	    buf[pos] = val & 255;
+	}
+	varint.writeByte = writeByte;
+	
+	return varint;
+}
+
+var hasRequiredBinary;
+
+function requireBinary () {
+	if (hasRequiredBinary) return binary;
+	hasRequiredBinary = 1;
+	/* eslint-disable */
+	/**
+	 * This file and any referenced files were automatically generated by @cosmology/telescope@1.0.7
+	 * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+	 * and run the transpile command or yarn proto command to regenerate this bundle.
+	 */
+	Object.defineProperty(binary, "__esModule", { value: true });
+	binary.BinaryWriter = binary.BinaryReader = binary.WireType = void 0;
+	// Copyright (c) 2016, Daniel Wirtz  All rights reserved.
+	// Redistribution and use in source and binary forms, with or without
+	// modification, are permitted provided that the following conditions are
+	// met:
+	// * Redistributions of source code must retain the above copyright
+	//   notice, this list of conditions and the following disclaimer.
+	// * Redistributions in binary form must reproduce the above copyright
+	//   notice, this list of conditions and the following disclaimer in the
+	//   documentation and/or other materials provided with the distribution.
+	// * Neither the name of its author, nor the names of its contributors
+	//   may be used to endorse or promote products derived from this software
+	//   without specific prior written permission.
+	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	// ---
+	// Code generated by the command line utilities is owned by the owner
+	// of the input file used when generating it. This code is not
+	// standalone and requires a support library to be linked with it. This
+	// support library is itself covered by the above license.
+	const utf8_1 = requireUtf8();
+	const varint_1 = requireVarint();
+	var WireType;
+	(function (WireType) {
+	    WireType[WireType["Varint"] = 0] = "Varint";
+	    WireType[WireType["Fixed64"] = 1] = "Fixed64";
+	    WireType[WireType["Bytes"] = 2] = "Bytes";
+	    WireType[WireType["Fixed32"] = 5] = "Fixed32";
+	})(WireType || (binary.WireType = WireType = {}));
+	class BinaryReader {
+	    assertBounds() {
+	        if (this.pos > this.len)
+	            throw new RangeError("premature EOF");
+	    }
+	    constructor(buf) {
+	        this.buf = buf ? new Uint8Array(buf) : new Uint8Array(0);
+	        this.pos = 0;
+	        this.type = 0;
+	        this.len = this.buf.length;
+	    }
+	    tag() {
+	        const tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
+	        if (fieldNo <= 0 || wireType < 0 || wireType > 5)
+	            throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
+	        return [fieldNo, wireType, tag];
+	    }
+	    skip(length) {
+	        if (typeof length === "number") {
+	            if (this.pos + length > this.len)
+	                throw indexOutOfRange(this, length);
+	            this.pos += length;
+	        }
+	        else {
+	            do {
+	                if (this.pos >= this.len)
+	                    throw indexOutOfRange(this);
+	            } while (this.buf[this.pos++] & 128);
+	        }
+	        return this;
+	    }
+	    skipType(wireType) {
+	        switch (wireType) {
+	            case WireType.Varint:
+	                this.skip();
+	                break;
+	            case WireType.Fixed64:
+	                this.skip(8);
+	                break;
+	            case WireType.Bytes:
+	                this.skip(this.uint32());
+	                break;
+	            case 3:
+	                while ((wireType = this.uint32() & 7) !== 4) {
+	                    this.skipType(wireType);
+	                }
+	                break;
+	            case WireType.Fixed32:
+	                this.skip(4);
+	                break;
+	            /* istanbul ignore next */
+	            default:
+	                throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+	        }
+	        return this;
+	    }
+	    uint32() {
+	        return varint_1.varint32read.bind(this)();
+	    }
+	    int32() {
+	        return this.uint32() | 0;
+	    }
+	    sint32() {
+	        const num = this.uint32();
+	        return num % 2 === 1 ? (num + 1) / -2 : num / 2; // zigzag encoding
+	    }
+	    fixed32() {
+	        const val = (0, varint_1.readUInt32)(this.buf, this.pos);
+	        this.pos += 4;
+	        return val;
+	    }
+	    sfixed32() {
+	        const val = (0, varint_1.readInt32)(this.buf, this.pos);
+	        this.pos += 4;
+	        return val;
+	    }
+	    int64() {
+	        const [lo, hi] = varint_1.varint64read.bind(this)();
+	        return BigInt((0, varint_1.int64ToString)(lo, hi));
+	    }
+	    uint64() {
+	        const [lo, hi] = varint_1.varint64read.bind(this)();
+	        return BigInt((0, varint_1.uInt64ToString)(lo, hi));
+	    }
+	    sint64() {
+	        let [lo, hi] = varint_1.varint64read.bind(this)();
+	        // zig zag
+	        [lo, hi] = (0, varint_1.zzDecode)(lo, hi);
+	        return BigInt((0, varint_1.int64ToString)(lo, hi));
+	    }
+	    fixed64() {
+	        const lo = this.sfixed32();
+	        const hi = this.sfixed32();
+	        return BigInt((0, varint_1.uInt64ToString)(lo, hi));
+	    }
+	    sfixed64() {
+	        const lo = this.sfixed32();
+	        const hi = this.sfixed32();
+	        return BigInt((0, varint_1.int64ToString)(lo, hi));
+	    }
+	    float() {
+	        throw new Error("float not supported");
+	    }
+	    double() {
+	        throw new Error("double not supported");
+	    }
+	    bool() {
+	        const [lo, hi] = varint_1.varint64read.bind(this)();
+	        return lo !== 0 || hi !== 0;
+	    }
+	    bytes() {
+	        const len = this.uint32(), start = this.pos;
+	        this.pos += len;
+	        this.assertBounds();
+	        return this.buf.subarray(start, start + len);
+	    }
+	    string() {
+	        const bytes = this.bytes();
+	        return (0, utf8_1.utf8Read)(bytes, 0, bytes.length);
+	    }
+	}
+	binary.BinaryReader = BinaryReader;
+	class Op {
+	    constructor(fn, len, val) {
+	        this.fn = fn;
+	        this.len = len;
+	        this.val = val;
+	    }
+	    proceed(buf, pos) {
+	        if (this.fn) {
+	            this.fn(this.val, buf, pos);
+	        }
+	    }
+	}
+	class State {
+	    constructor(writer) {
+	        this.head = writer.head;
+	        this.tail = writer.tail;
+	        this.len = writer.len;
+	        this.next = writer.states;
+	    }
+	}
+	class BinaryWriter {
+	    constructor() {
+	        this.len = 0;
+	        // uint64 is the same with int64
+	        this.uint64 = BinaryWriter.prototype.int64;
+	        // sfixed64 is the same with fixed64
+	        this.sfixed64 = BinaryWriter.prototype.fixed64;
+	        // sfixed32 is the same with fixed32
+	        this.sfixed32 = BinaryWriter.prototype.fixed32;
+	        this.head = new Op(null, 0, 0);
+	        this.tail = this.head;
+	        this.states = null;
+	    }
+	    static create() {
+	        return new BinaryWriter();
+	    }
+	    static alloc(size) {
+	        if (typeof Uint8Array !== "undefined") {
+	            return pool((size) => new Uint8Array(size), Uint8Array.prototype.subarray)(size);
+	        }
+	        else {
+	            return new Array(size);
+	        }
+	    }
+	    _push(fn, len, val) {
+	        this.tail = this.tail.next = new Op(fn, len, val);
+	        this.len += len;
+	        return this;
+	    }
+	    finish() {
+	        let head = this.head.next, pos = 0;
+	        const buf = BinaryWriter.alloc(this.len);
+	        while (head) {
+	            head.proceed(buf, pos);
+	            pos += head.len;
+	            head = head.next;
+	        }
+	        return buf;
+	    }
+	    fork() {
+	        this.states = new State(this);
+	        this.head = this.tail = new Op(null, 0, 0);
+	        this.len = 0;
+	        return this;
+	    }
+	    reset() {
+	        if (this.states) {
+	            this.head = this.states.head;
+	            this.tail = this.states.tail;
+	            this.len = this.states.len;
+	            this.states = this.states.next;
+	        }
+	        else {
+	            this.head = this.tail = new Op(null, 0, 0);
+	            this.len = 0;
+	        }
+	        return this;
+	    }
+	    ldelim() {
+	        const head = this.head, tail = this.tail, len = this.len;
+	        this.reset().uint32(len);
+	        if (len) {
+	            this.tail.next = head.next; // skip noop
+	            this.tail = tail;
+	            this.len += len;
+	        }
+	        return this;
+	    }
+	    tag(fieldNo, type) {
+	        return this.uint32(((fieldNo << 3) | type) >>> 0);
+	    }
+	    uint32(value) {
+	        this.len += (this.tail = this.tail.next =
+	            new Op(varint_1.writeVarint32, (value = value >>> 0) < 128 ? 1 : value < 16384 ? 2 : value < 2097152 ? 3 : value < 268435456 ? 4 : 5, value)).len;
+	        return this;
+	    }
+	    int32(value) {
+	        return value < 0
+	            ? this._push(varint_1.writeVarint64, 10, (0, varint_1.int64FromString)(value.toString())) // 10 bytes per spec
+	            : this.uint32(value);
+	    }
+	    sint32(value) {
+	        return this.uint32(((value << 1) ^ (value >> 31)) >>> 0);
+	    }
+	    int64(value) {
+	        const { lo, hi } = (0, varint_1.int64FromString)(value.toString());
+	        return this._push(varint_1.writeVarint64, (0, varint_1.int64Length)(lo, hi), { lo, hi });
+	    }
+	    sint64(value) {
+	        let { lo, hi } = (0, varint_1.int64FromString)(value.toString());
+	        // zig zag
+	        [lo, hi] = (0, varint_1.zzEncode)(lo, hi);
+	        return this._push(varint_1.writeVarint64, (0, varint_1.int64Length)(lo, hi), { lo, hi });
+	    }
+	    fixed64(value) {
+	        const { lo, hi } = (0, varint_1.int64FromString)(value.toString());
+	        return this._push(varint_1.writeFixed32, 4, lo)._push(varint_1.writeFixed32, 4, hi);
+	    }
+	    bool(value) {
+	        return this._push(varint_1.writeByte, 1, value ? 1 : 0);
+	    }
+	    fixed32(value) {
+	        return this._push(varint_1.writeFixed32, 4, value >>> 0);
+	    }
+	    float(value) {
+	        throw new Error("float not supported" + value);
+	    }
+	    double(value) {
+	        throw new Error("double not supported" + value);
+	    }
+	    bytes(value) {
+	        const len = value.length >>> 0;
+	        if (!len)
+	            return this._push(varint_1.writeByte, 1, 0);
+	        return this.uint32(len)._push(writeBytes, len, value);
+	    }
+	    string(value) {
+	        const len = (0, utf8_1.utf8Length)(value);
+	        return len ? this.uint32(len)._push(utf8_1.utf8Write, len, value) : this._push(varint_1.writeByte, 1, 0);
+	    }
+	}
+	binary.BinaryWriter = BinaryWriter;
+	function writeBytes(val, buf, pos) {
+	    if (typeof Uint8Array !== "undefined") {
+	        buf.set(val, pos);
+	    }
+	    else {
+	        for (let i = 0; i < val.length; ++i)
+	            buf[pos + i] = val[i];
+	    }
+	}
+	function pool(alloc, slice, size) {
+	    const SIZE = 8192;
+	    const MAX = SIZE >>> 1;
+	    let slab = null;
+	    let offset = SIZE;
+	    return function pool_alloc(size) {
+	        if (size < 1 || size > MAX)
+	            return alloc(size);
+	        if (offset + size > SIZE) {
+	            slab = alloc(SIZE);
+	            offset = 0;
+	        }
+	        const buf = slice.call(slab, offset, (offset += size));
+	        if (offset & 7)
+	            // align to 32 bit
+	            offset = (offset | 7) + 1;
+	        return buf;
+	    };
+	}
+	function indexOutOfRange(reader, writeLength) {
+	    return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+	}
+	
+	return binary;
+}
+
+var helpers = {};
+
+var hasRequiredHelpers;
+
+function requireHelpers () {
+	if (hasRequiredHelpers) return helpers;
+	hasRequiredHelpers = 1;
+	/* eslint-disable */
+	/**
+	 * This file and any referenced files were automatically generated by @cosmology/telescope@1.0.7
+	 * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+	 * and run the transpile command or yarn proto command to regenerate this bundle.
+	 */
+	Object.defineProperty(helpers, "__esModule", { value: true });
+	helpers.fromJsonTimestamp = helpers.fromTimestamp = helpers.toTimestamp = helpers.setPaginationParams = helpers.isObject = helpers.isSet = helpers.fromDuration = helpers.toDuration = helpers.omitDefault = helpers.base64FromBytes = helpers.bytesFromBase64 = void 0;
+	var globalThis = (() => {
+	    if (typeof globalThis !== "undefined")
+	        return globalThis;
+	    if (typeof self !== "undefined")
+	        return self;
+	    if (typeof window !== "undefined")
+	        return window;
+	    if (typeof commonjsGlobal !== "undefined")
+	        return commonjsGlobal;
+	    throw "Unable to locate global object";
+	})();
+	const atob = globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
+	function bytesFromBase64(b64) {
+	    const bin = atob(b64);
+	    const arr = new Uint8Array(bin.length);
+	    for (let i = 0; i < bin.length; ++i) {
+	        arr[i] = bin.charCodeAt(i);
+	    }
+	    return arr;
+	}
+	helpers.bytesFromBase64 = bytesFromBase64;
+	const btoa = globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
+	function base64FromBytes(arr) {
+	    const bin = [];
+	    arr.forEach((byte) => {
+	        bin.push(String.fromCharCode(byte));
+	    });
+	    return btoa(bin.join(""));
+	}
+	helpers.base64FromBytes = base64FromBytes;
+	function omitDefault(input) {
+	    if (typeof input === "string") {
+	        return input === "" ? undefined : input;
+	    }
+	    if (typeof input === "number") {
+	        return input === 0 ? undefined : input;
+	    }
+	    if (typeof input === "bigint") {
+	        return input === BigInt(0) ? undefined : input;
+	    }
+	    throw new Error(`Got unsupported type ${typeof input}`);
+	}
+	helpers.omitDefault = omitDefault;
+	function toDuration(duration) {
+	    return {
+	        seconds: BigInt(Math.floor(parseInt(duration) / 1000000000)),
+	        nanos: parseInt(duration) % 1000000000,
+	    };
+	}
+	helpers.toDuration = toDuration;
+	function fromDuration(duration) {
+	    return (parseInt(duration.seconds.toString()) * 1000000000 + duration.nanos).toString();
+	}
+	helpers.fromDuration = fromDuration;
+	function isSet(value) {
+	    return value !== null && value !== undefined;
+	}
+	helpers.isSet = isSet;
+	function isObject(value) {
+	    return typeof value === "object" && value !== null;
+	}
+	helpers.isObject = isObject;
+	const setPaginationParams = (options, pagination) => {
+	    if (!pagination) {
+	        return options;
+	    }
+	    if (typeof pagination?.countTotal !== "undefined") {
+	        options.params["pagination.count_total"] = pagination.countTotal;
+	    }
+	    if (typeof pagination?.key !== "undefined") {
+	        // String to Uint8Array
+	        // let uint8arr = new Uint8Array(Buffer.from(data,'base64'));
+	        // Uint8Array to String
+	        options.params["pagination.key"] = Buffer.from(pagination.key).toString("base64");
+	    }
+	    if (typeof pagination?.limit !== "undefined") {
+	        options.params["pagination.limit"] = pagination.limit.toString();
+	    }
+	    if (typeof pagination?.offset !== "undefined") {
+	        options.params["pagination.offset"] = pagination.offset.toString();
+	    }
+	    if (typeof pagination?.reverse !== "undefined") {
+	        options.params["pagination.reverse"] = pagination.reverse;
+	    }
+	    return options;
+	};
+	helpers.setPaginationParams = setPaginationParams;
+	function toTimestamp(date) {
+	    const seconds = numberToLong(date.getTime() / 1000);
+	    const nanos = (date.getTime() % 1000) * 1000000;
+	    return {
+	        seconds,
+	        nanos,
+	    };
+	}
+	helpers.toTimestamp = toTimestamp;
+	function fromTimestamp(t) {
+	    let millis = Number(t.seconds) * 1000;
+	    millis += t.nanos / 1000000;
+	    return new Date(millis);
+	}
+	helpers.fromTimestamp = fromTimestamp;
+	const timestampFromJSON = (object) => {
+	    return {
+	        seconds: isSet(object.seconds) ? BigInt(object.seconds.toString()) : BigInt(0),
+	        nanos: isSet(object.nanos) ? Number(object.nanos) : 0,
+	    };
+	};
+	function fromJsonTimestamp(o) {
+	    if (o instanceof Date) {
+	        return toTimestamp(o);
+	    }
+	    else if (typeof o === "string") {
+	        return toTimestamp(new Date(o));
+	    }
+	    else {
+	        return timestampFromJSON(o);
+	    }
+	}
+	helpers.fromJsonTimestamp = fromJsonTimestamp;
+	function numberToLong(number) {
+	    return BigInt(Math.trunc(number));
+	}
+	
+	return helpers;
+}
+
+var hasRequiredAny;
+
+function requireAny () {
+	if (hasRequiredAny) return any;
+	hasRequiredAny = 1;
+	Object.defineProperty(any, "__esModule", { value: true });
+	any.Any = any.protobufPackage = void 0;
+	/* eslint-disable */
+	const binary_1 = requireBinary();
+	const helpers_1 = requireHelpers();
+	any.protobufPackage = "google.protobuf";
+	function createBaseAny() {
+	    return {
+	        typeUrl: "",
+	        value: new Uint8Array(),
+	    };
+	}
+	any.Any = {
+	    typeUrl: "/google.protobuf.Any",
+	    encode(message, writer = binary_1.BinaryWriter.create()) {
+	        if (message.typeUrl !== "") {
+	            writer.uint32(10).string(message.typeUrl);
+	        }
+	        if (message.value.length !== 0) {
+	            writer.uint32(18).bytes(message.value);
+	        }
+	        return writer;
+	    },
+	    decode(input, length) {
+	        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+	        let end = length === undefined ? reader.len : reader.pos + length;
+	        const message = createBaseAny();
+	        while (reader.pos < end) {
+	            const tag = reader.uint32();
+	            switch (tag >>> 3) {
+	                case 1:
+	                    message.typeUrl = reader.string();
+	                    break;
+	                case 2:
+	                    message.value = reader.bytes();
+	                    break;
+	                default:
+	                    reader.skipType(tag & 7);
+	                    break;
+	            }
+	        }
+	        return message;
+	    },
+	    fromJSON(object) {
+	        const obj = createBaseAny();
+	        if ((0, helpers_1.isSet)(object.typeUrl))
+	            obj.typeUrl = String(object.typeUrl);
+	        if ((0, helpers_1.isSet)(object.value))
+	            obj.value = (0, helpers_1.bytesFromBase64)(object.value);
+	        return obj;
+	    },
+	    toJSON(message) {
+	        const obj = {};
+	        message.typeUrl !== undefined && (obj.typeUrl = message.typeUrl);
+	        message.value !== undefined &&
+	            (obj.value = (0, helpers_1.base64FromBytes)(message.value !== undefined ? message.value : new Uint8Array()));
+	        return obj;
+	    },
+	    fromPartial(object) {
+	        const message = createBaseAny();
+	        message.typeUrl = object.typeUrl ?? "";
+	        message.value = object.value ?? new Uint8Array();
+	        return message;
+	    },
+	};
+	
+	return any;
+}
+
+var signing = {};
+
+var multisig = {};
+
+var hasRequiredMultisig;
+
+function requireMultisig () {
+	if (hasRequiredMultisig) return multisig;
+	hasRequiredMultisig = 1;
+	Object.defineProperty(multisig, "__esModule", { value: true });
+	multisig.CompactBitArray = multisig.MultiSignature = multisig.protobufPackage = void 0;
+	/* eslint-disable */
+	const binary_1 = requireBinary();
+	const helpers_1 = requireHelpers();
+	multisig.protobufPackage = "cosmos.crypto.multisig.v1beta1";
+	function createBaseMultiSignature() {
+	    return {
+	        signatures: [],
+	    };
+	}
+	multisig.MultiSignature = {
+	    typeUrl: "/cosmos.crypto.multisig.v1beta1.MultiSignature",
+	    encode(message, writer = binary_1.BinaryWriter.create()) {
+	        for (const v of message.signatures) {
+	            writer.uint32(10).bytes(v);
+	        }
+	        return writer;
+	    },
+	    decode(input, length) {
+	        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+	        let end = length === undefined ? reader.len : reader.pos + length;
+	        const message = createBaseMultiSignature();
+	        while (reader.pos < end) {
+	            const tag = reader.uint32();
+	            switch (tag >>> 3) {
+	                case 1:
+	                    message.signatures.push(reader.bytes());
+	                    break;
+	                default:
+	                    reader.skipType(tag & 7);
+	                    break;
+	            }
+	        }
+	        return message;
+	    },
+	    fromJSON(object) {
+	        const obj = createBaseMultiSignature();
+	        if (Array.isArray(object?.signatures))
+	            obj.signatures = object.signatures.map((e) => (0, helpers_1.bytesFromBase64)(e));
+	        return obj;
+	    },
+	    toJSON(message) {
+	        const obj = {};
+	        if (message.signatures) {
+	            obj.signatures = message.signatures.map((e) => (0, helpers_1.base64FromBytes)(e !== undefined ? e : new Uint8Array()));
+	        }
+	        else {
+	            obj.signatures = [];
+	        }
+	        return obj;
+	    },
+	    fromPartial(object) {
+	        const message = createBaseMultiSignature();
+	        message.signatures = object.signatures?.map((e) => e) || [];
+	        return message;
+	    },
+	};
+	function createBaseCompactBitArray() {
+	    return {
+	        extraBitsStored: 0,
+	        elems: new Uint8Array(),
+	    };
+	}
+	multisig.CompactBitArray = {
+	    typeUrl: "/cosmos.crypto.multisig.v1beta1.CompactBitArray",
+	    encode(message, writer = binary_1.BinaryWriter.create()) {
+	        if (message.extraBitsStored !== 0) {
+	            writer.uint32(8).uint32(message.extraBitsStored);
+	        }
+	        if (message.elems.length !== 0) {
+	            writer.uint32(18).bytes(message.elems);
+	        }
+	        return writer;
+	    },
+	    decode(input, length) {
+	        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+	        let end = length === undefined ? reader.len : reader.pos + length;
+	        const message = createBaseCompactBitArray();
+	        while (reader.pos < end) {
+	            const tag = reader.uint32();
+	            switch (tag >>> 3) {
+	                case 1:
+	                    message.extraBitsStored = reader.uint32();
+	                    break;
+	                case 2:
+	                    message.elems = reader.bytes();
+	                    break;
+	                default:
+	                    reader.skipType(tag & 7);
+	                    break;
+	            }
+	        }
+	        return message;
+	    },
+	    fromJSON(object) {
+	        const obj = createBaseCompactBitArray();
+	        if ((0, helpers_1.isSet)(object.extraBitsStored))
+	            obj.extraBitsStored = Number(object.extraBitsStored);
+	        if ((0, helpers_1.isSet)(object.elems))
+	            obj.elems = (0, helpers_1.bytesFromBase64)(object.elems);
+	        return obj;
+	    },
+	    toJSON(message) {
+	        const obj = {};
+	        message.extraBitsStored !== undefined && (obj.extraBitsStored = Math.round(message.extraBitsStored));
+	        message.elems !== undefined &&
+	            (obj.elems = (0, helpers_1.base64FromBytes)(message.elems !== undefined ? message.elems : new Uint8Array()));
+	        return obj;
+	    },
+	    fromPartial(object) {
+	        const message = createBaseCompactBitArray();
+	        message.extraBitsStored = object.extraBitsStored ?? 0;
+	        message.elems = object.elems ?? new Uint8Array();
+	        return message;
+	    },
+	};
+	
+	return multisig;
+}
+
+var hasRequiredSigning;
+
+function requireSigning () {
+	if (hasRequiredSigning) return signing;
+	hasRequiredSigning = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.SignatureDescriptor_Data_Multi = exports$1.SignatureDescriptor_Data_Single = exports$1.SignatureDescriptor_Data = exports$1.SignatureDescriptor = exports$1.SignatureDescriptors = exports$1.signModeToJSON = exports$1.signModeFromJSON = exports$1.SignMode = exports$1.protobufPackage = void 0;
+		/* eslint-disable */
+		const multisig_1 = requireMultisig();
+		const any_1 = requireAny();
+		const binary_1 = requireBinary();
+		const helpers_1 = requireHelpers();
+		exports$1.protobufPackage = "cosmos.tx.signing.v1beta1";
+		/**
+		 * SignMode represents a signing mode with its own security guarantees.
+		 *
+		 * This enum should be considered a registry of all known sign modes
+		 * in the Cosmos ecosystem. Apps are not expected to support all known
+		 * sign modes. Apps that would like to support custom  sign modes are
+		 * encouraged to open a small PR against this file to add a new case
+		 * to this SignMode enum describing their sign mode so that different
+		 * apps have a consistent version of this enum.
+		 */
+		var SignMode;
+		(function (SignMode) {
+		    /**
+		     * SIGN_MODE_UNSPECIFIED - SIGN_MODE_UNSPECIFIED specifies an unknown signing mode and will be
+		     * rejected.
+		     */
+		    SignMode[SignMode["SIGN_MODE_UNSPECIFIED"] = 0] = "SIGN_MODE_UNSPECIFIED";
+		    /**
+		     * SIGN_MODE_DIRECT - SIGN_MODE_DIRECT specifies a signing mode which uses SignDoc and is
+		     * verified with raw bytes from Tx.
+		     */
+		    SignMode[SignMode["SIGN_MODE_DIRECT"] = 1] = "SIGN_MODE_DIRECT";
+		    /**
+		     * SIGN_MODE_TEXTUAL - SIGN_MODE_TEXTUAL is a future signing mode that will verify some
+		     * human-readable textual representation on top of the binary representation
+		     * from SIGN_MODE_DIRECT. It is currently not supported.
+		     */
+		    SignMode[SignMode["SIGN_MODE_TEXTUAL"] = 2] = "SIGN_MODE_TEXTUAL";
+		    /**
+		     * SIGN_MODE_DIRECT_AUX - SIGN_MODE_DIRECT_AUX specifies a signing mode which uses
+		     * SignDocDirectAux. As opposed to SIGN_MODE_DIRECT, this sign mode does not
+		     * require signers signing over other signers' `signer_info`. It also allows
+		     * for adding Tips in transactions.
+		     *
+		     * Since: cosmos-sdk 0.46
+		     */
+		    SignMode[SignMode["SIGN_MODE_DIRECT_AUX"] = 3] = "SIGN_MODE_DIRECT_AUX";
+		    /**
+		     * SIGN_MODE_LEGACY_AMINO_JSON - SIGN_MODE_LEGACY_AMINO_JSON is a backwards compatibility mode which uses
+		     * Amino JSON and will be removed in the future.
+		     */
+		    SignMode[SignMode["SIGN_MODE_LEGACY_AMINO_JSON"] = 127] = "SIGN_MODE_LEGACY_AMINO_JSON";
+		    /**
+		     * SIGN_MODE_EIP_191 - SIGN_MODE_EIP_191 specifies the sign mode for EIP 191 signing on the Cosmos
+		     * SDK. Ref: https://eips.ethereum.org/EIPS/eip-191
+		     *
+		     * Currently, SIGN_MODE_EIP_191 is registered as a SignMode enum variant,
+		     * but is not implemented on the SDK by default. To enable EIP-191, you need
+		     * to pass a custom `TxConfig` that has an implementation of
+		     * `SignModeHandler` for EIP-191. The SDK may decide to fully support
+		     * EIP-191 in the future.
+		     *
+		     * Since: cosmos-sdk 0.45.2
+		     */
+		    SignMode[SignMode["SIGN_MODE_EIP_191"] = 191] = "SIGN_MODE_EIP_191";
+		    SignMode[SignMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+		})(SignMode || (exports$1.SignMode = SignMode = {}));
+		function signModeFromJSON(object) {
+		    switch (object) {
+		        case 0:
+		        case "SIGN_MODE_UNSPECIFIED":
+		            return SignMode.SIGN_MODE_UNSPECIFIED;
+		        case 1:
+		        case "SIGN_MODE_DIRECT":
+		            return SignMode.SIGN_MODE_DIRECT;
+		        case 2:
+		        case "SIGN_MODE_TEXTUAL":
+		            return SignMode.SIGN_MODE_TEXTUAL;
+		        case 3:
+		        case "SIGN_MODE_DIRECT_AUX":
+		            return SignMode.SIGN_MODE_DIRECT_AUX;
+		        case 127:
+		        case "SIGN_MODE_LEGACY_AMINO_JSON":
+		            return SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+		        case 191:
+		        case "SIGN_MODE_EIP_191":
+		            return SignMode.SIGN_MODE_EIP_191;
+		        case -1:
+		        case "UNRECOGNIZED":
+		        default:
+		            return SignMode.UNRECOGNIZED;
+		    }
+		}
+		exports$1.signModeFromJSON = signModeFromJSON;
+		function signModeToJSON(object) {
+		    switch (object) {
+		        case SignMode.SIGN_MODE_UNSPECIFIED:
+		            return "SIGN_MODE_UNSPECIFIED";
+		        case SignMode.SIGN_MODE_DIRECT:
+		            return "SIGN_MODE_DIRECT";
+		        case SignMode.SIGN_MODE_TEXTUAL:
+		            return "SIGN_MODE_TEXTUAL";
+		        case SignMode.SIGN_MODE_DIRECT_AUX:
+		            return "SIGN_MODE_DIRECT_AUX";
+		        case SignMode.SIGN_MODE_LEGACY_AMINO_JSON:
+		            return "SIGN_MODE_LEGACY_AMINO_JSON";
+		        case SignMode.SIGN_MODE_EIP_191:
+		            return "SIGN_MODE_EIP_191";
+		        case SignMode.UNRECOGNIZED:
+		        default:
+		            return "UNRECOGNIZED";
+		    }
+		}
+		exports$1.signModeToJSON = signModeToJSON;
+		function createBaseSignatureDescriptors() {
+		    return {
+		        signatures: [],
+		    };
+		}
+		exports$1.SignatureDescriptors = {
+		    typeUrl: "/cosmos.tx.signing.v1beta1.SignatureDescriptors",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        for (const v of message.signatures) {
+		            exports$1.SignatureDescriptor.encode(v, writer.uint32(10).fork()).ldelim();
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseSignatureDescriptors();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.signatures.push(exports$1.SignatureDescriptor.decode(reader, reader.uint32()));
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseSignatureDescriptors();
+		        if (Array.isArray(object?.signatures))
+		            obj.signatures = object.signatures.map((e) => exports$1.SignatureDescriptor.fromJSON(e));
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        if (message.signatures) {
+		            obj.signatures = message.signatures.map((e) => (e ? exports$1.SignatureDescriptor.toJSON(e) : undefined));
+		        }
+		        else {
+		            obj.signatures = [];
+		        }
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseSignatureDescriptors();
+		        message.signatures = object.signatures?.map((e) => exports$1.SignatureDescriptor.fromPartial(e)) || [];
+		        return message;
+		    },
+		};
+		function createBaseSignatureDescriptor() {
+		    return {
+		        publicKey: undefined,
+		        data: undefined,
+		        sequence: BigInt(0),
+		    };
+		}
+		exports$1.SignatureDescriptor = {
+		    typeUrl: "/cosmos.tx.signing.v1beta1.SignatureDescriptor",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.publicKey !== undefined) {
+		            any_1.Any.encode(message.publicKey, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.data !== undefined) {
+		            exports$1.SignatureDescriptor_Data.encode(message.data, writer.uint32(18).fork()).ldelim();
+		        }
+		        if (message.sequence !== BigInt(0)) {
+		            writer.uint32(24).uint64(message.sequence);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseSignatureDescriptor();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.publicKey = any_1.Any.decode(reader, reader.uint32());
+		                    break;
+		                case 2:
+		                    message.data = exports$1.SignatureDescriptor_Data.decode(reader, reader.uint32());
+		                    break;
+		                case 3:
+		                    message.sequence = reader.uint64();
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseSignatureDescriptor();
+		        if ((0, helpers_1.isSet)(object.publicKey))
+		            obj.publicKey = any_1.Any.fromJSON(object.publicKey);
+		        if ((0, helpers_1.isSet)(object.data))
+		            obj.data = exports$1.SignatureDescriptor_Data.fromJSON(object.data);
+		        if ((0, helpers_1.isSet)(object.sequence))
+		            obj.sequence = BigInt(object.sequence.toString());
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.publicKey !== undefined &&
+		            (obj.publicKey = message.publicKey ? any_1.Any.toJSON(message.publicKey) : undefined);
+		        message.data !== undefined &&
+		            (obj.data = message.data ? exports$1.SignatureDescriptor_Data.toJSON(message.data) : undefined);
+		        message.sequence !== undefined && (obj.sequence = (message.sequence || BigInt(0)).toString());
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseSignatureDescriptor();
+		        if (object.publicKey !== undefined && object.publicKey !== null) {
+		            message.publicKey = any_1.Any.fromPartial(object.publicKey);
+		        }
+		        if (object.data !== undefined && object.data !== null) {
+		            message.data = exports$1.SignatureDescriptor_Data.fromPartial(object.data);
+		        }
+		        if (object.sequence !== undefined && object.sequence !== null) {
+		            message.sequence = BigInt(object.sequence.toString());
+		        }
+		        return message;
+		    },
+		};
+		function createBaseSignatureDescriptor_Data() {
+		    return {
+		        single: undefined,
+		        multi: undefined,
+		    };
+		}
+		exports$1.SignatureDescriptor_Data = {
+		    typeUrl: "/cosmos.tx.signing.v1beta1.Data",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.single !== undefined) {
+		            exports$1.SignatureDescriptor_Data_Single.encode(message.single, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.multi !== undefined) {
+		            exports$1.SignatureDescriptor_Data_Multi.encode(message.multi, writer.uint32(18).fork()).ldelim();
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseSignatureDescriptor_Data();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.single = exports$1.SignatureDescriptor_Data_Single.decode(reader, reader.uint32());
+		                    break;
+		                case 2:
+		                    message.multi = exports$1.SignatureDescriptor_Data_Multi.decode(reader, reader.uint32());
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseSignatureDescriptor_Data();
+		        if ((0, helpers_1.isSet)(object.single))
+		            obj.single = exports$1.SignatureDescriptor_Data_Single.fromJSON(object.single);
+		        if ((0, helpers_1.isSet)(object.multi))
+		            obj.multi = exports$1.SignatureDescriptor_Data_Multi.fromJSON(object.multi);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.single !== undefined &&
+		            (obj.single = message.single ? exports$1.SignatureDescriptor_Data_Single.toJSON(message.single) : undefined);
+		        message.multi !== undefined &&
+		            (obj.multi = message.multi ? exports$1.SignatureDescriptor_Data_Multi.toJSON(message.multi) : undefined);
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseSignatureDescriptor_Data();
+		        if (object.single !== undefined && object.single !== null) {
+		            message.single = exports$1.SignatureDescriptor_Data_Single.fromPartial(object.single);
+		        }
+		        if (object.multi !== undefined && object.multi !== null) {
+		            message.multi = exports$1.SignatureDescriptor_Data_Multi.fromPartial(object.multi);
+		        }
+		        return message;
+		    },
+		};
+		function createBaseSignatureDescriptor_Data_Single() {
+		    return {
+		        mode: 0,
+		        signature: new Uint8Array(),
+		    };
+		}
+		exports$1.SignatureDescriptor_Data_Single = {
+		    typeUrl: "/cosmos.tx.signing.v1beta1.Single",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.mode !== 0) {
+		            writer.uint32(8).int32(message.mode);
+		        }
+		        if (message.signature.length !== 0) {
+		            writer.uint32(18).bytes(message.signature);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseSignatureDescriptor_Data_Single();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.mode = reader.int32();
+		                    break;
+		                case 2:
+		                    message.signature = reader.bytes();
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseSignatureDescriptor_Data_Single();
+		        if ((0, helpers_1.isSet)(object.mode))
+		            obj.mode = signModeFromJSON(object.mode);
+		        if ((0, helpers_1.isSet)(object.signature))
+		            obj.signature = (0, helpers_1.bytesFromBase64)(object.signature);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.mode !== undefined && (obj.mode = signModeToJSON(message.mode));
+		        message.signature !== undefined &&
+		            (obj.signature = (0, helpers_1.base64FromBytes)(message.signature !== undefined ? message.signature : new Uint8Array()));
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseSignatureDescriptor_Data_Single();
+		        message.mode = object.mode ?? 0;
+		        message.signature = object.signature ?? new Uint8Array();
+		        return message;
+		    },
+		};
+		function createBaseSignatureDescriptor_Data_Multi() {
+		    return {
+		        bitarray: undefined,
+		        signatures: [],
+		    };
+		}
+		exports$1.SignatureDescriptor_Data_Multi = {
+		    typeUrl: "/cosmos.tx.signing.v1beta1.Multi",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.bitarray !== undefined) {
+		            multisig_1.CompactBitArray.encode(message.bitarray, writer.uint32(10).fork()).ldelim();
+		        }
+		        for (const v of message.signatures) {
+		            exports$1.SignatureDescriptor_Data.encode(v, writer.uint32(18).fork()).ldelim();
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseSignatureDescriptor_Data_Multi();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.bitarray = multisig_1.CompactBitArray.decode(reader, reader.uint32());
+		                    break;
+		                case 2:
+		                    message.signatures.push(exports$1.SignatureDescriptor_Data.decode(reader, reader.uint32()));
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseSignatureDescriptor_Data_Multi();
+		        if ((0, helpers_1.isSet)(object.bitarray))
+		            obj.bitarray = multisig_1.CompactBitArray.fromJSON(object.bitarray);
+		        if (Array.isArray(object?.signatures))
+		            obj.signatures = object.signatures.map((e) => exports$1.SignatureDescriptor_Data.fromJSON(e));
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.bitarray !== undefined &&
+		            (obj.bitarray = message.bitarray ? multisig_1.CompactBitArray.toJSON(message.bitarray) : undefined);
+		        if (message.signatures) {
+		            obj.signatures = message.signatures.map((e) => (e ? exports$1.SignatureDescriptor_Data.toJSON(e) : undefined));
+		        }
+		        else {
+		            obj.signatures = [];
+		        }
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseSignatureDescriptor_Data_Multi();
+		        if (object.bitarray !== undefined && object.bitarray !== null) {
+		            message.bitarray = multisig_1.CompactBitArray.fromPartial(object.bitarray);
+		        }
+		        message.signatures = object.signatures?.map((e) => exports$1.SignatureDescriptor_Data.fromPartial(e)) || [];
+		        return message;
+		    },
+		};
+		
+	} (signing));
+	return signing;
+}
+
+var coin = {};
+
+var hasRequiredCoin;
+
+function requireCoin () {
+	if (hasRequiredCoin) return coin;
+	hasRequiredCoin = 1;
+	Object.defineProperty(coin, "__esModule", { value: true });
+	coin.DecProto = coin.IntProto = coin.DecCoin = coin.Coin = coin.protobufPackage = void 0;
+	/* eslint-disable */
+	const binary_1 = requireBinary();
+	const helpers_1 = requireHelpers();
+	coin.protobufPackage = "cosmos.base.v1beta1";
+	function createBaseCoin() {
+	    return {
+	        denom: "",
+	        amount: "",
+	    };
+	}
+	coin.Coin = {
+	    typeUrl: "/cosmos.base.v1beta1.Coin",
+	    encode(message, writer = binary_1.BinaryWriter.create()) {
+	        if (message.denom !== "") {
+	            writer.uint32(10).string(message.denom);
+	        }
+	        if (message.amount !== "") {
+	            writer.uint32(18).string(message.amount);
+	        }
+	        return writer;
+	    },
+	    decode(input, length) {
+	        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+	        let end = length === undefined ? reader.len : reader.pos + length;
+	        const message = createBaseCoin();
+	        while (reader.pos < end) {
+	            const tag = reader.uint32();
+	            switch (tag >>> 3) {
+	                case 1:
+	                    message.denom = reader.string();
+	                    break;
+	                case 2:
+	                    message.amount = reader.string();
+	                    break;
+	                default:
+	                    reader.skipType(tag & 7);
+	                    break;
+	            }
+	        }
+	        return message;
+	    },
+	    fromJSON(object) {
+	        const obj = createBaseCoin();
+	        if ((0, helpers_1.isSet)(object.denom))
+	            obj.denom = String(object.denom);
+	        if ((0, helpers_1.isSet)(object.amount))
+	            obj.amount = String(object.amount);
+	        return obj;
+	    },
+	    toJSON(message) {
+	        const obj = {};
+	        message.denom !== undefined && (obj.denom = message.denom);
+	        message.amount !== undefined && (obj.amount = message.amount);
+	        return obj;
+	    },
+	    fromPartial(object) {
+	        const message = createBaseCoin();
+	        message.denom = object.denom ?? "";
+	        message.amount = object.amount ?? "";
+	        return message;
+	    },
+	};
+	function createBaseDecCoin() {
+	    return {
+	        denom: "",
+	        amount: "",
+	    };
+	}
+	coin.DecCoin = {
+	    typeUrl: "/cosmos.base.v1beta1.DecCoin",
+	    encode(message, writer = binary_1.BinaryWriter.create()) {
+	        if (message.denom !== "") {
+	            writer.uint32(10).string(message.denom);
+	        }
+	        if (message.amount !== "") {
+	            writer.uint32(18).string(message.amount);
+	        }
+	        return writer;
+	    },
+	    decode(input, length) {
+	        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+	        let end = length === undefined ? reader.len : reader.pos + length;
+	        const message = createBaseDecCoin();
+	        while (reader.pos < end) {
+	            const tag = reader.uint32();
+	            switch (tag >>> 3) {
+	                case 1:
+	                    message.denom = reader.string();
+	                    break;
+	                case 2:
+	                    message.amount = reader.string();
+	                    break;
+	                default:
+	                    reader.skipType(tag & 7);
+	                    break;
+	            }
+	        }
+	        return message;
+	    },
+	    fromJSON(object) {
+	        const obj = createBaseDecCoin();
+	        if ((0, helpers_1.isSet)(object.denom))
+	            obj.denom = String(object.denom);
+	        if ((0, helpers_1.isSet)(object.amount))
+	            obj.amount = String(object.amount);
+	        return obj;
+	    },
+	    toJSON(message) {
+	        const obj = {};
+	        message.denom !== undefined && (obj.denom = message.denom);
+	        message.amount !== undefined && (obj.amount = message.amount);
+	        return obj;
+	    },
+	    fromPartial(object) {
+	        const message = createBaseDecCoin();
+	        message.denom = object.denom ?? "";
+	        message.amount = object.amount ?? "";
+	        return message;
+	    },
+	};
+	function createBaseIntProto() {
+	    return {
+	        int: "",
+	    };
+	}
+	coin.IntProto = {
+	    typeUrl: "/cosmos.base.v1beta1.IntProto",
+	    encode(message, writer = binary_1.BinaryWriter.create()) {
+	        if (message.int !== "") {
+	            writer.uint32(10).string(message.int);
+	        }
+	        return writer;
+	    },
+	    decode(input, length) {
+	        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+	        let end = length === undefined ? reader.len : reader.pos + length;
+	        const message = createBaseIntProto();
+	        while (reader.pos < end) {
+	            const tag = reader.uint32();
+	            switch (tag >>> 3) {
+	                case 1:
+	                    message.int = reader.string();
+	                    break;
+	                default:
+	                    reader.skipType(tag & 7);
+	                    break;
+	            }
+	        }
+	        return message;
+	    },
+	    fromJSON(object) {
+	        const obj = createBaseIntProto();
+	        if ((0, helpers_1.isSet)(object.int))
+	            obj.int = String(object.int);
+	        return obj;
+	    },
+	    toJSON(message) {
+	        const obj = {};
+	        message.int !== undefined && (obj.int = message.int);
+	        return obj;
+	    },
+	    fromPartial(object) {
+	        const message = createBaseIntProto();
+	        message.int = object.int ?? "";
+	        return message;
+	    },
+	};
+	function createBaseDecProto() {
+	    return {
+	        dec: "",
+	    };
+	}
+	coin.DecProto = {
+	    typeUrl: "/cosmos.base.v1beta1.DecProto",
+	    encode(message, writer = binary_1.BinaryWriter.create()) {
+	        if (message.dec !== "") {
+	            writer.uint32(10).string(message.dec);
+	        }
+	        return writer;
+	    },
+	    decode(input, length) {
+	        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+	        let end = length === undefined ? reader.len : reader.pos + length;
+	        const message = createBaseDecProto();
+	        while (reader.pos < end) {
+	            const tag = reader.uint32();
+	            switch (tag >>> 3) {
+	                case 1:
+	                    message.dec = reader.string();
+	                    break;
+	                default:
+	                    reader.skipType(tag & 7);
+	                    break;
+	            }
+	        }
+	        return message;
+	    },
+	    fromJSON(object) {
+	        const obj = createBaseDecProto();
+	        if ((0, helpers_1.isSet)(object.dec))
+	            obj.dec = String(object.dec);
+	        return obj;
+	    },
+	    toJSON(message) {
+	        const obj = {};
+	        message.dec !== undefined && (obj.dec = message.dec);
+	        return obj;
+	    },
+	    fromPartial(object) {
+	        const message = createBaseDecProto();
+	        message.dec = object.dec ?? "";
+	        return message;
+	    },
+	};
+	
+	return coin;
+}
+
+var hasRequiredTx;
+
+function requireTx () {
+	if (hasRequiredTx) return tx;
+	hasRequiredTx = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.AuxSignerData = exports$1.Tip = exports$1.Fee = exports$1.ModeInfo_Multi = exports$1.ModeInfo_Single = exports$1.ModeInfo = exports$1.SignerInfo = exports$1.AuthInfo = exports$1.TxBody = exports$1.SignDocDirectAux = exports$1.SignDoc = exports$1.TxRaw = exports$1.Tx = exports$1.protobufPackage = void 0;
+		/* eslint-disable */
+		const any_1 = requireAny();
+		const signing_1 = requireSigning();
+		const multisig_1 = requireMultisig();
+		const coin_1 = requireCoin();
+		const binary_1 = requireBinary();
+		const helpers_1 = requireHelpers();
+		exports$1.protobufPackage = "cosmos.tx.v1beta1";
+		function createBaseTx() {
+		    return {
+		        body: undefined,
+		        authInfo: undefined,
+		        signatures: [],
+		    };
+		}
+		exports$1.Tx = {
+		    typeUrl: "/cosmos.tx.v1beta1.Tx",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.body !== undefined) {
+		            exports$1.TxBody.encode(message.body, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.authInfo !== undefined) {
+		            exports$1.AuthInfo.encode(message.authInfo, writer.uint32(18).fork()).ldelim();
+		        }
+		        for (const v of message.signatures) {
+		            writer.uint32(26).bytes(v);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseTx();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.body = exports$1.TxBody.decode(reader, reader.uint32());
+		                    break;
+		                case 2:
+		                    message.authInfo = exports$1.AuthInfo.decode(reader, reader.uint32());
+		                    break;
+		                case 3:
+		                    message.signatures.push(reader.bytes());
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseTx();
+		        if ((0, helpers_1.isSet)(object.body))
+		            obj.body = exports$1.TxBody.fromJSON(object.body);
+		        if ((0, helpers_1.isSet)(object.authInfo))
+		            obj.authInfo = exports$1.AuthInfo.fromJSON(object.authInfo);
+		        if (Array.isArray(object?.signatures))
+		            obj.signatures = object.signatures.map((e) => (0, helpers_1.bytesFromBase64)(e));
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.body !== undefined && (obj.body = message.body ? exports$1.TxBody.toJSON(message.body) : undefined);
+		        message.authInfo !== undefined &&
+		            (obj.authInfo = message.authInfo ? exports$1.AuthInfo.toJSON(message.authInfo) : undefined);
+		        if (message.signatures) {
+		            obj.signatures = message.signatures.map((e) => (0, helpers_1.base64FromBytes)(e !== undefined ? e : new Uint8Array()));
+		        }
+		        else {
+		            obj.signatures = [];
+		        }
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseTx();
+		        if (object.body !== undefined && object.body !== null) {
+		            message.body = exports$1.TxBody.fromPartial(object.body);
+		        }
+		        if (object.authInfo !== undefined && object.authInfo !== null) {
+		            message.authInfo = exports$1.AuthInfo.fromPartial(object.authInfo);
+		        }
+		        message.signatures = object.signatures?.map((e) => e) || [];
+		        return message;
+		    },
+		};
+		function createBaseTxRaw() {
+		    return {
+		        bodyBytes: new Uint8Array(),
+		        authInfoBytes: new Uint8Array(),
+		        signatures: [],
+		    };
+		}
+		exports$1.TxRaw = {
+		    typeUrl: "/cosmos.tx.v1beta1.TxRaw",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.bodyBytes.length !== 0) {
+		            writer.uint32(10).bytes(message.bodyBytes);
+		        }
+		        if (message.authInfoBytes.length !== 0) {
+		            writer.uint32(18).bytes(message.authInfoBytes);
+		        }
+		        for (const v of message.signatures) {
+		            writer.uint32(26).bytes(v);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseTxRaw();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.bodyBytes = reader.bytes();
+		                    break;
+		                case 2:
+		                    message.authInfoBytes = reader.bytes();
+		                    break;
+		                case 3:
+		                    message.signatures.push(reader.bytes());
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseTxRaw();
+		        if ((0, helpers_1.isSet)(object.bodyBytes))
+		            obj.bodyBytes = (0, helpers_1.bytesFromBase64)(object.bodyBytes);
+		        if ((0, helpers_1.isSet)(object.authInfoBytes))
+		            obj.authInfoBytes = (0, helpers_1.bytesFromBase64)(object.authInfoBytes);
+		        if (Array.isArray(object?.signatures))
+		            obj.signatures = object.signatures.map((e) => (0, helpers_1.bytesFromBase64)(e));
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.bodyBytes !== undefined &&
+		            (obj.bodyBytes = (0, helpers_1.base64FromBytes)(message.bodyBytes !== undefined ? message.bodyBytes : new Uint8Array()));
+		        message.authInfoBytes !== undefined &&
+		            (obj.authInfoBytes = (0, helpers_1.base64FromBytes)(message.authInfoBytes !== undefined ? message.authInfoBytes : new Uint8Array()));
+		        if (message.signatures) {
+		            obj.signatures = message.signatures.map((e) => (0, helpers_1.base64FromBytes)(e !== undefined ? e : new Uint8Array()));
+		        }
+		        else {
+		            obj.signatures = [];
+		        }
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseTxRaw();
+		        message.bodyBytes = object.bodyBytes ?? new Uint8Array();
+		        message.authInfoBytes = object.authInfoBytes ?? new Uint8Array();
+		        message.signatures = object.signatures?.map((e) => e) || [];
+		        return message;
+		    },
+		};
+		function createBaseSignDoc() {
+		    return {
+		        bodyBytes: new Uint8Array(),
+		        authInfoBytes: new Uint8Array(),
+		        chainId: "",
+		        accountNumber: BigInt(0),
+		    };
+		}
+		exports$1.SignDoc = {
+		    typeUrl: "/cosmos.tx.v1beta1.SignDoc",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.bodyBytes.length !== 0) {
+		            writer.uint32(10).bytes(message.bodyBytes);
+		        }
+		        if (message.authInfoBytes.length !== 0) {
+		            writer.uint32(18).bytes(message.authInfoBytes);
+		        }
+		        if (message.chainId !== "") {
+		            writer.uint32(26).string(message.chainId);
+		        }
+		        if (message.accountNumber !== BigInt(0)) {
+		            writer.uint32(32).uint64(message.accountNumber);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseSignDoc();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.bodyBytes = reader.bytes();
+		                    break;
+		                case 2:
+		                    message.authInfoBytes = reader.bytes();
+		                    break;
+		                case 3:
+		                    message.chainId = reader.string();
+		                    break;
+		                case 4:
+		                    message.accountNumber = reader.uint64();
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseSignDoc();
+		        if ((0, helpers_1.isSet)(object.bodyBytes))
+		            obj.bodyBytes = (0, helpers_1.bytesFromBase64)(object.bodyBytes);
+		        if ((0, helpers_1.isSet)(object.authInfoBytes))
+		            obj.authInfoBytes = (0, helpers_1.bytesFromBase64)(object.authInfoBytes);
+		        if ((0, helpers_1.isSet)(object.chainId))
+		            obj.chainId = String(object.chainId);
+		        if ((0, helpers_1.isSet)(object.accountNumber))
+		            obj.accountNumber = BigInt(object.accountNumber.toString());
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.bodyBytes !== undefined &&
+		            (obj.bodyBytes = (0, helpers_1.base64FromBytes)(message.bodyBytes !== undefined ? message.bodyBytes : new Uint8Array()));
+		        message.authInfoBytes !== undefined &&
+		            (obj.authInfoBytes = (0, helpers_1.base64FromBytes)(message.authInfoBytes !== undefined ? message.authInfoBytes : new Uint8Array()));
+		        message.chainId !== undefined && (obj.chainId = message.chainId);
+		        message.accountNumber !== undefined &&
+		            (obj.accountNumber = (message.accountNumber || BigInt(0)).toString());
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseSignDoc();
+		        message.bodyBytes = object.bodyBytes ?? new Uint8Array();
+		        message.authInfoBytes = object.authInfoBytes ?? new Uint8Array();
+		        message.chainId = object.chainId ?? "";
+		        if (object.accountNumber !== undefined && object.accountNumber !== null) {
+		            message.accountNumber = BigInt(object.accountNumber.toString());
+		        }
+		        return message;
+		    },
+		};
+		function createBaseSignDocDirectAux() {
+		    return {
+		        bodyBytes: new Uint8Array(),
+		        publicKey: undefined,
+		        chainId: "",
+		        accountNumber: BigInt(0),
+		        sequence: BigInt(0),
+		        tip: undefined,
+		    };
+		}
+		exports$1.SignDocDirectAux = {
+		    typeUrl: "/cosmos.tx.v1beta1.SignDocDirectAux",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.bodyBytes.length !== 0) {
+		            writer.uint32(10).bytes(message.bodyBytes);
+		        }
+		        if (message.publicKey !== undefined) {
+		            any_1.Any.encode(message.publicKey, writer.uint32(18).fork()).ldelim();
+		        }
+		        if (message.chainId !== "") {
+		            writer.uint32(26).string(message.chainId);
+		        }
+		        if (message.accountNumber !== BigInt(0)) {
+		            writer.uint32(32).uint64(message.accountNumber);
+		        }
+		        if (message.sequence !== BigInt(0)) {
+		            writer.uint32(40).uint64(message.sequence);
+		        }
+		        if (message.tip !== undefined) {
+		            exports$1.Tip.encode(message.tip, writer.uint32(50).fork()).ldelim();
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseSignDocDirectAux();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.bodyBytes = reader.bytes();
+		                    break;
+		                case 2:
+		                    message.publicKey = any_1.Any.decode(reader, reader.uint32());
+		                    break;
+		                case 3:
+		                    message.chainId = reader.string();
+		                    break;
+		                case 4:
+		                    message.accountNumber = reader.uint64();
+		                    break;
+		                case 5:
+		                    message.sequence = reader.uint64();
+		                    break;
+		                case 6:
+		                    message.tip = exports$1.Tip.decode(reader, reader.uint32());
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseSignDocDirectAux();
+		        if ((0, helpers_1.isSet)(object.bodyBytes))
+		            obj.bodyBytes = (0, helpers_1.bytesFromBase64)(object.bodyBytes);
+		        if ((0, helpers_1.isSet)(object.publicKey))
+		            obj.publicKey = any_1.Any.fromJSON(object.publicKey);
+		        if ((0, helpers_1.isSet)(object.chainId))
+		            obj.chainId = String(object.chainId);
+		        if ((0, helpers_1.isSet)(object.accountNumber))
+		            obj.accountNumber = BigInt(object.accountNumber.toString());
+		        if ((0, helpers_1.isSet)(object.sequence))
+		            obj.sequence = BigInt(object.sequence.toString());
+		        if ((0, helpers_1.isSet)(object.tip))
+		            obj.tip = exports$1.Tip.fromJSON(object.tip);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.bodyBytes !== undefined &&
+		            (obj.bodyBytes = (0, helpers_1.base64FromBytes)(message.bodyBytes !== undefined ? message.bodyBytes : new Uint8Array()));
+		        message.publicKey !== undefined &&
+		            (obj.publicKey = message.publicKey ? any_1.Any.toJSON(message.publicKey) : undefined);
+		        message.chainId !== undefined && (obj.chainId = message.chainId);
+		        message.accountNumber !== undefined &&
+		            (obj.accountNumber = (message.accountNumber || BigInt(0)).toString());
+		        message.sequence !== undefined && (obj.sequence = (message.sequence || BigInt(0)).toString());
+		        message.tip !== undefined && (obj.tip = message.tip ? exports$1.Tip.toJSON(message.tip) : undefined);
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseSignDocDirectAux();
+		        message.bodyBytes = object.bodyBytes ?? new Uint8Array();
+		        if (object.publicKey !== undefined && object.publicKey !== null) {
+		            message.publicKey = any_1.Any.fromPartial(object.publicKey);
+		        }
+		        message.chainId = object.chainId ?? "";
+		        if (object.accountNumber !== undefined && object.accountNumber !== null) {
+		            message.accountNumber = BigInt(object.accountNumber.toString());
+		        }
+		        if (object.sequence !== undefined && object.sequence !== null) {
+		            message.sequence = BigInt(object.sequence.toString());
+		        }
+		        if (object.tip !== undefined && object.tip !== null) {
+		            message.tip = exports$1.Tip.fromPartial(object.tip);
+		        }
+		        return message;
+		    },
+		};
+		function createBaseTxBody() {
+		    return {
+		        messages: [],
+		        memo: "",
+		        timeoutHeight: BigInt(0),
+		        extensionOptions: [],
+		        nonCriticalExtensionOptions: [],
+		    };
+		}
+		exports$1.TxBody = {
+		    typeUrl: "/cosmos.tx.v1beta1.TxBody",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        for (const v of message.messages) {
+		            any_1.Any.encode(v, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.memo !== "") {
+		            writer.uint32(18).string(message.memo);
+		        }
+		        if (message.timeoutHeight !== BigInt(0)) {
+		            writer.uint32(24).uint64(message.timeoutHeight);
+		        }
+		        for (const v of message.extensionOptions) {
+		            any_1.Any.encode(v, writer.uint32(8186).fork()).ldelim();
+		        }
+		        for (const v of message.nonCriticalExtensionOptions) {
+		            any_1.Any.encode(v, writer.uint32(16378).fork()).ldelim();
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseTxBody();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.messages.push(any_1.Any.decode(reader, reader.uint32()));
+		                    break;
+		                case 2:
+		                    message.memo = reader.string();
+		                    break;
+		                case 3:
+		                    message.timeoutHeight = reader.uint64();
+		                    break;
+		                case 1023:
+		                    message.extensionOptions.push(any_1.Any.decode(reader, reader.uint32()));
+		                    break;
+		                case 2047:
+		                    message.nonCriticalExtensionOptions.push(any_1.Any.decode(reader, reader.uint32()));
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseTxBody();
+		        if (Array.isArray(object?.messages))
+		            obj.messages = object.messages.map((e) => any_1.Any.fromJSON(e));
+		        if ((0, helpers_1.isSet)(object.memo))
+		            obj.memo = String(object.memo);
+		        if ((0, helpers_1.isSet)(object.timeoutHeight))
+		            obj.timeoutHeight = BigInt(object.timeoutHeight.toString());
+		        if (Array.isArray(object?.extensionOptions))
+		            obj.extensionOptions = object.extensionOptions.map((e) => any_1.Any.fromJSON(e));
+		        if (Array.isArray(object?.nonCriticalExtensionOptions))
+		            obj.nonCriticalExtensionOptions = object.nonCriticalExtensionOptions.map((e) => any_1.Any.fromJSON(e));
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        if (message.messages) {
+		            obj.messages = message.messages.map((e) => (e ? any_1.Any.toJSON(e) : undefined));
+		        }
+		        else {
+		            obj.messages = [];
+		        }
+		        message.memo !== undefined && (obj.memo = message.memo);
+		        message.timeoutHeight !== undefined &&
+		            (obj.timeoutHeight = (message.timeoutHeight || BigInt(0)).toString());
+		        if (message.extensionOptions) {
+		            obj.extensionOptions = message.extensionOptions.map((e) => (e ? any_1.Any.toJSON(e) : undefined));
+		        }
+		        else {
+		            obj.extensionOptions = [];
+		        }
+		        if (message.nonCriticalExtensionOptions) {
+		            obj.nonCriticalExtensionOptions = message.nonCriticalExtensionOptions.map((e) => e ? any_1.Any.toJSON(e) : undefined);
+		        }
+		        else {
+		            obj.nonCriticalExtensionOptions = [];
+		        }
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseTxBody();
+		        message.messages = object.messages?.map((e) => any_1.Any.fromPartial(e)) || [];
+		        message.memo = object.memo ?? "";
+		        if (object.timeoutHeight !== undefined && object.timeoutHeight !== null) {
+		            message.timeoutHeight = BigInt(object.timeoutHeight.toString());
+		        }
+		        message.extensionOptions = object.extensionOptions?.map((e) => any_1.Any.fromPartial(e)) || [];
+		        message.nonCriticalExtensionOptions =
+		            object.nonCriticalExtensionOptions?.map((e) => any_1.Any.fromPartial(e)) || [];
+		        return message;
+		    },
+		};
+		function createBaseAuthInfo() {
+		    return {
+		        signerInfos: [],
+		        fee: undefined,
+		        tip: undefined,
+		    };
+		}
+		exports$1.AuthInfo = {
+		    typeUrl: "/cosmos.tx.v1beta1.AuthInfo",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        for (const v of message.signerInfos) {
+		            exports$1.SignerInfo.encode(v, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.fee !== undefined) {
+		            exports$1.Fee.encode(message.fee, writer.uint32(18).fork()).ldelim();
+		        }
+		        if (message.tip !== undefined) {
+		            exports$1.Tip.encode(message.tip, writer.uint32(26).fork()).ldelim();
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseAuthInfo();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.signerInfos.push(exports$1.SignerInfo.decode(reader, reader.uint32()));
+		                    break;
+		                case 2:
+		                    message.fee = exports$1.Fee.decode(reader, reader.uint32());
+		                    break;
+		                case 3:
+		                    message.tip = exports$1.Tip.decode(reader, reader.uint32());
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseAuthInfo();
+		        if (Array.isArray(object?.signerInfos))
+		            obj.signerInfos = object.signerInfos.map((e) => exports$1.SignerInfo.fromJSON(e));
+		        if ((0, helpers_1.isSet)(object.fee))
+		            obj.fee = exports$1.Fee.fromJSON(object.fee);
+		        if ((0, helpers_1.isSet)(object.tip))
+		            obj.tip = exports$1.Tip.fromJSON(object.tip);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        if (message.signerInfos) {
+		            obj.signerInfos = message.signerInfos.map((e) => (e ? exports$1.SignerInfo.toJSON(e) : undefined));
+		        }
+		        else {
+		            obj.signerInfos = [];
+		        }
+		        message.fee !== undefined && (obj.fee = message.fee ? exports$1.Fee.toJSON(message.fee) : undefined);
+		        message.tip !== undefined && (obj.tip = message.tip ? exports$1.Tip.toJSON(message.tip) : undefined);
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseAuthInfo();
+		        message.signerInfos = object.signerInfos?.map((e) => exports$1.SignerInfo.fromPartial(e)) || [];
+		        if (object.fee !== undefined && object.fee !== null) {
+		            message.fee = exports$1.Fee.fromPartial(object.fee);
+		        }
+		        if (object.tip !== undefined && object.tip !== null) {
+		            message.tip = exports$1.Tip.fromPartial(object.tip);
+		        }
+		        return message;
+		    },
+		};
+		function createBaseSignerInfo() {
+		    return {
+		        publicKey: undefined,
+		        modeInfo: undefined,
+		        sequence: BigInt(0),
+		    };
+		}
+		exports$1.SignerInfo = {
+		    typeUrl: "/cosmos.tx.v1beta1.SignerInfo",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.publicKey !== undefined) {
+		            any_1.Any.encode(message.publicKey, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.modeInfo !== undefined) {
+		            exports$1.ModeInfo.encode(message.modeInfo, writer.uint32(18).fork()).ldelim();
+		        }
+		        if (message.sequence !== BigInt(0)) {
+		            writer.uint32(24).uint64(message.sequence);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseSignerInfo();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.publicKey = any_1.Any.decode(reader, reader.uint32());
+		                    break;
+		                case 2:
+		                    message.modeInfo = exports$1.ModeInfo.decode(reader, reader.uint32());
+		                    break;
+		                case 3:
+		                    message.sequence = reader.uint64();
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseSignerInfo();
+		        if ((0, helpers_1.isSet)(object.publicKey))
+		            obj.publicKey = any_1.Any.fromJSON(object.publicKey);
+		        if ((0, helpers_1.isSet)(object.modeInfo))
+		            obj.modeInfo = exports$1.ModeInfo.fromJSON(object.modeInfo);
+		        if ((0, helpers_1.isSet)(object.sequence))
+		            obj.sequence = BigInt(object.sequence.toString());
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.publicKey !== undefined &&
+		            (obj.publicKey = message.publicKey ? any_1.Any.toJSON(message.publicKey) : undefined);
+		        message.modeInfo !== undefined &&
+		            (obj.modeInfo = message.modeInfo ? exports$1.ModeInfo.toJSON(message.modeInfo) : undefined);
+		        message.sequence !== undefined && (obj.sequence = (message.sequence || BigInt(0)).toString());
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseSignerInfo();
+		        if (object.publicKey !== undefined && object.publicKey !== null) {
+		            message.publicKey = any_1.Any.fromPartial(object.publicKey);
+		        }
+		        if (object.modeInfo !== undefined && object.modeInfo !== null) {
+		            message.modeInfo = exports$1.ModeInfo.fromPartial(object.modeInfo);
+		        }
+		        if (object.sequence !== undefined && object.sequence !== null) {
+		            message.sequence = BigInt(object.sequence.toString());
+		        }
+		        return message;
+		    },
+		};
+		function createBaseModeInfo() {
+		    return {
+		        single: undefined,
+		        multi: undefined,
+		    };
+		}
+		exports$1.ModeInfo = {
+		    typeUrl: "/cosmos.tx.v1beta1.ModeInfo",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.single !== undefined) {
+		            exports$1.ModeInfo_Single.encode(message.single, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.multi !== undefined) {
+		            exports$1.ModeInfo_Multi.encode(message.multi, writer.uint32(18).fork()).ldelim();
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseModeInfo();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.single = exports$1.ModeInfo_Single.decode(reader, reader.uint32());
+		                    break;
+		                case 2:
+		                    message.multi = exports$1.ModeInfo_Multi.decode(reader, reader.uint32());
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseModeInfo();
+		        if ((0, helpers_1.isSet)(object.single))
+		            obj.single = exports$1.ModeInfo_Single.fromJSON(object.single);
+		        if ((0, helpers_1.isSet)(object.multi))
+		            obj.multi = exports$1.ModeInfo_Multi.fromJSON(object.multi);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.single !== undefined &&
+		            (obj.single = message.single ? exports$1.ModeInfo_Single.toJSON(message.single) : undefined);
+		        message.multi !== undefined &&
+		            (obj.multi = message.multi ? exports$1.ModeInfo_Multi.toJSON(message.multi) : undefined);
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseModeInfo();
+		        if (object.single !== undefined && object.single !== null) {
+		            message.single = exports$1.ModeInfo_Single.fromPartial(object.single);
+		        }
+		        if (object.multi !== undefined && object.multi !== null) {
+		            message.multi = exports$1.ModeInfo_Multi.fromPartial(object.multi);
+		        }
+		        return message;
+		    },
+		};
+		function createBaseModeInfo_Single() {
+		    return {
+		        mode: 0,
+		    };
+		}
+		exports$1.ModeInfo_Single = {
+		    typeUrl: "/cosmos.tx.v1beta1.Single",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.mode !== 0) {
+		            writer.uint32(8).int32(message.mode);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseModeInfo_Single();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.mode = reader.int32();
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseModeInfo_Single();
+		        if ((0, helpers_1.isSet)(object.mode))
+		            obj.mode = (0, signing_1.signModeFromJSON)(object.mode);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.mode !== undefined && (obj.mode = (0, signing_1.signModeToJSON)(message.mode));
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseModeInfo_Single();
+		        message.mode = object.mode ?? 0;
+		        return message;
+		    },
+		};
+		function createBaseModeInfo_Multi() {
+		    return {
+		        bitarray: undefined,
+		        modeInfos: [],
+		    };
+		}
+		exports$1.ModeInfo_Multi = {
+		    typeUrl: "/cosmos.tx.v1beta1.Multi",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.bitarray !== undefined) {
+		            multisig_1.CompactBitArray.encode(message.bitarray, writer.uint32(10).fork()).ldelim();
+		        }
+		        for (const v of message.modeInfos) {
+		            exports$1.ModeInfo.encode(v, writer.uint32(18).fork()).ldelim();
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseModeInfo_Multi();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.bitarray = multisig_1.CompactBitArray.decode(reader, reader.uint32());
+		                    break;
+		                case 2:
+		                    message.modeInfos.push(exports$1.ModeInfo.decode(reader, reader.uint32()));
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseModeInfo_Multi();
+		        if ((0, helpers_1.isSet)(object.bitarray))
+		            obj.bitarray = multisig_1.CompactBitArray.fromJSON(object.bitarray);
+		        if (Array.isArray(object?.modeInfos))
+		            obj.modeInfos = object.modeInfos.map((e) => exports$1.ModeInfo.fromJSON(e));
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.bitarray !== undefined &&
+		            (obj.bitarray = message.bitarray ? multisig_1.CompactBitArray.toJSON(message.bitarray) : undefined);
+		        if (message.modeInfos) {
+		            obj.modeInfos = message.modeInfos.map((e) => (e ? exports$1.ModeInfo.toJSON(e) : undefined));
+		        }
+		        else {
+		            obj.modeInfos = [];
+		        }
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseModeInfo_Multi();
+		        if (object.bitarray !== undefined && object.bitarray !== null) {
+		            message.bitarray = multisig_1.CompactBitArray.fromPartial(object.bitarray);
+		        }
+		        message.modeInfos = object.modeInfos?.map((e) => exports$1.ModeInfo.fromPartial(e)) || [];
+		        return message;
+		    },
+		};
+		function createBaseFee() {
+		    return {
+		        amount: [],
+		        gasLimit: BigInt(0),
+		        payer: "",
+		        granter: "",
+		    };
+		}
+		exports$1.Fee = {
+		    typeUrl: "/cosmos.tx.v1beta1.Fee",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        for (const v of message.amount) {
+		            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.gasLimit !== BigInt(0)) {
+		            writer.uint32(16).uint64(message.gasLimit);
+		        }
+		        if (message.payer !== "") {
+		            writer.uint32(26).string(message.payer);
+		        }
+		        if (message.granter !== "") {
+		            writer.uint32(34).string(message.granter);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseFee();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
+		                    break;
+		                case 2:
+		                    message.gasLimit = reader.uint64();
+		                    break;
+		                case 3:
+		                    message.payer = reader.string();
+		                    break;
+		                case 4:
+		                    message.granter = reader.string();
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseFee();
+		        if (Array.isArray(object?.amount))
+		            obj.amount = object.amount.map((e) => coin_1.Coin.fromJSON(e));
+		        if ((0, helpers_1.isSet)(object.gasLimit))
+		            obj.gasLimit = BigInt(object.gasLimit.toString());
+		        if ((0, helpers_1.isSet)(object.payer))
+		            obj.payer = String(object.payer);
+		        if ((0, helpers_1.isSet)(object.granter))
+		            obj.granter = String(object.granter);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        if (message.amount) {
+		            obj.amount = message.amount.map((e) => (e ? coin_1.Coin.toJSON(e) : undefined));
+		        }
+		        else {
+		            obj.amount = [];
+		        }
+		        message.gasLimit !== undefined && (obj.gasLimit = (message.gasLimit || BigInt(0)).toString());
+		        message.payer !== undefined && (obj.payer = message.payer);
+		        message.granter !== undefined && (obj.granter = message.granter);
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseFee();
+		        message.amount = object.amount?.map((e) => coin_1.Coin.fromPartial(e)) || [];
+		        if (object.gasLimit !== undefined && object.gasLimit !== null) {
+		            message.gasLimit = BigInt(object.gasLimit.toString());
+		        }
+		        message.payer = object.payer ?? "";
+		        message.granter = object.granter ?? "";
+		        return message;
+		    },
+		};
+		function createBaseTip() {
+		    return {
+		        amount: [],
+		        tipper: "",
+		    };
+		}
+		exports$1.Tip = {
+		    typeUrl: "/cosmos.tx.v1beta1.Tip",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        for (const v of message.amount) {
+		            coin_1.Coin.encode(v, writer.uint32(10).fork()).ldelim();
+		        }
+		        if (message.tipper !== "") {
+		            writer.uint32(18).string(message.tipper);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseTip();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.amount.push(coin_1.Coin.decode(reader, reader.uint32()));
+		                    break;
+		                case 2:
+		                    message.tipper = reader.string();
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseTip();
+		        if (Array.isArray(object?.amount))
+		            obj.amount = object.amount.map((e) => coin_1.Coin.fromJSON(e));
+		        if ((0, helpers_1.isSet)(object.tipper))
+		            obj.tipper = String(object.tipper);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        if (message.amount) {
+		            obj.amount = message.amount.map((e) => (e ? coin_1.Coin.toJSON(e) : undefined));
+		        }
+		        else {
+		            obj.amount = [];
+		        }
+		        message.tipper !== undefined && (obj.tipper = message.tipper);
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseTip();
+		        message.amount = object.amount?.map((e) => coin_1.Coin.fromPartial(e)) || [];
+		        message.tipper = object.tipper ?? "";
+		        return message;
+		    },
+		};
+		function createBaseAuxSignerData() {
+		    return {
+		        address: "",
+		        signDoc: undefined,
+		        mode: 0,
+		        sig: new Uint8Array(),
+		    };
+		}
+		exports$1.AuxSignerData = {
+		    typeUrl: "/cosmos.tx.v1beta1.AuxSignerData",
+		    encode(message, writer = binary_1.BinaryWriter.create()) {
+		        if (message.address !== "") {
+		            writer.uint32(10).string(message.address);
+		        }
+		        if (message.signDoc !== undefined) {
+		            exports$1.SignDocDirectAux.encode(message.signDoc, writer.uint32(18).fork()).ldelim();
+		        }
+		        if (message.mode !== 0) {
+		            writer.uint32(24).int32(message.mode);
+		        }
+		        if (message.sig.length !== 0) {
+		            writer.uint32(34).bytes(message.sig);
+		        }
+		        return writer;
+		    },
+		    decode(input, length) {
+		        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+		        let end = length === undefined ? reader.len : reader.pos + length;
+		        const message = createBaseAuxSignerData();
+		        while (reader.pos < end) {
+		            const tag = reader.uint32();
+		            switch (tag >>> 3) {
+		                case 1:
+		                    message.address = reader.string();
+		                    break;
+		                case 2:
+		                    message.signDoc = exports$1.SignDocDirectAux.decode(reader, reader.uint32());
+		                    break;
+		                case 3:
+		                    message.mode = reader.int32();
+		                    break;
+		                case 4:
+		                    message.sig = reader.bytes();
+		                    break;
+		                default:
+		                    reader.skipType(tag & 7);
+		                    break;
+		            }
+		        }
+		        return message;
+		    },
+		    fromJSON(object) {
+		        const obj = createBaseAuxSignerData();
+		        if ((0, helpers_1.isSet)(object.address))
+		            obj.address = String(object.address);
+		        if ((0, helpers_1.isSet)(object.signDoc))
+		            obj.signDoc = exports$1.SignDocDirectAux.fromJSON(object.signDoc);
+		        if ((0, helpers_1.isSet)(object.mode))
+		            obj.mode = (0, signing_1.signModeFromJSON)(object.mode);
+		        if ((0, helpers_1.isSet)(object.sig))
+		            obj.sig = (0, helpers_1.bytesFromBase64)(object.sig);
+		        return obj;
+		    },
+		    toJSON(message) {
+		        const obj = {};
+		        message.address !== undefined && (obj.address = message.address);
+		        message.signDoc !== undefined &&
+		            (obj.signDoc = message.signDoc ? exports$1.SignDocDirectAux.toJSON(message.signDoc) : undefined);
+		        message.mode !== undefined && (obj.mode = (0, signing_1.signModeToJSON)(message.mode));
+		        message.sig !== undefined &&
+		            (obj.sig = (0, helpers_1.base64FromBytes)(message.sig !== undefined ? message.sig : new Uint8Array()));
+		        return obj;
+		    },
+		    fromPartial(object) {
+		        const message = createBaseAuxSignerData();
+		        message.address = object.address ?? "";
+		        if (object.signDoc !== undefined && object.signDoc !== null) {
+		            message.signDoc = exports$1.SignDocDirectAux.fromPartial(object.signDoc);
+		        }
+		        message.mode = object.mode ?? 0;
+		        message.sig = object.sig ?? new Uint8Array();
+		        return message;
+		    },
+		};
+		
+	} (tx));
+	return tx;
+}
+
+var txExports = requireTx();
+
 /**
  * Default gas limit for all transactions
  */
@@ -58095,6 +61141,53 @@ class SigningCosmosClient extends CosmosClient {
             throw error;
         }
     }
+    /**
+     * Signs a MsgPerformAction and returns the base64-encoded TxRaw WITHOUT
+     * broadcasting. Used by the optimistic gateway settlement relay
+     * (OPTIMISTIC_ACTION_ARCHITECTURE.md §6.10): the FE hands the signed bytes
+     * to the gateway, which relays them to the chain's existing tx pipeline —
+     * no chain changes, valid player signature.
+     *
+     * Pass `signerData` to use a locally-tracked sequence (the caller queries
+     * the account once and increments +1 per action, avoiding a per-action
+     * sequence query — required because optimistic actions are signed faster
+     * than the chain commits). Omit it to fetch account_number/sequence from
+     * the chain (one-shot, e.g. the first action of a session).
+     *
+     * Requires the player account to EXIST on-chain (funded). Same gasless
+     * fee + msg shape as {@link performActionSync}.
+     */
+    async signPerformAction(gameId, action, amount = 0n, data, signerData) {
+        await this.initializeSigningClient();
+        if (!this.signingClient || !this.wallet) {
+            throw new Error("Signing client not initialized");
+        }
+        const [account] = await this.wallet.getAccounts();
+        const player = account.address;
+        const msgPerformAction = {
+            player,
+            gameId,
+            action,
+            amount: Long.fromString(amount.toString(), true),
+            data: data || ""
+        };
+        const msg = {
+            typeUrl: "/pokerchain.poker.v1.MsgPerformAction",
+            value: msgPerformAction
+        };
+        let explicit = signerData;
+        if (!explicit) {
+            const accountInfo = await this.getAccount(player);
+            explicit = {
+                accountNumber: Number(accountInfo.account.account_number),
+                sequence: Number(accountInfo.account.sequence),
+                chainId: this.config.chainId
+            };
+        }
+        const txRaw = await this.signingClient.sign(player, [msg], gaslessFee(), `Poker action (relay): ${action}`, explicit);
+        const base64 = encoding.toBase64(txExports.TxRaw.encode(txRaw).finish());
+        return { base64, sequence: explicit.sequence, accountNumber: explicit.accountNumber };
+    }
     /**
      * Top up a player's stack at a table
      * The player must be seated at the table and have sufficient wallet balance.