@injectivelabs/wallet-ledger 1.16.24 → 1.16.25-alpha.0

package/dist/cjs/index.cjs

@@ -0,0 +1,2364 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let viem = require("viem");
+let __injectivelabs_exceptions = require("@injectivelabs/exceptions");
+let __injectivelabs_ts_types = require("@injectivelabs/ts-types");
+let alchemy_sdk = require("alchemy-sdk");
+let __injectivelabs_sdk_ts = require("@injectivelabs/sdk-ts");
+let __injectivelabs_wallet_base = require("@injectivelabs/wallet-base");
+let viem_chains = require("viem/chains");
+viem_chains = __toESM(viem_chains);
+
+//#region src/types.ts
+const LedgerDerivationPathType = {
+	LedgerLive: "ledger-live",
+	LedgerMew: "ledger-mew"
+};
+const WalletLedger = {
+	Ledger: "ledger",
+	LedgerCosmos: "ledger-cosmos",
+	LedgerLegacy: "ledger-legacy"
+};
+
+//#endregion
+//#region ../../../node_modules/.pnpm/bignumber.js@9.1.2/node_modules/bignumber.js/bignumber.mjs
+var isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, mathceil = Math.ceil, mathfloor = Math.floor, bignumberError = "[BigNumber Error] ", tooManyDigits = bignumberError + "Number primitive has more than 15 significant digits: ", BASE = 0x5af3107a4000, LOG_BASE = 14, MAX_SAFE_INTEGER = 9007199254740991, POWS_TEN = [
+	1,
+	10,
+	100,
+	1e3,
+	1e4,
+	1e5,
+	1e6,
+	1e7,
+	1e8,
+	1e9,
+	1e10,
+	1e11,
+	0xe8d4a51000,
+	0x9184e72a000
+], SQRT_BASE = 1e7, MAX = 1e9;
+function clone(configObject) {
+	var div, convertBase, parseNumeric, P = BigNumber$1.prototype = {
+		constructor: BigNumber$1,
+		toString: null,
+		valueOf: null
+	}, ONE = new BigNumber$1(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
+		prefix: "",
+		groupSize: 3,
+		secondaryGroupSize: 0,
+		groupSeparator: ",",
+		decimalSeparator: ".",
+		fractionGroupSize: 0,
+		fractionGroupSeparator: "\xA0",
+		suffix: ""
+	}, ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz", alphabetHasNormalDecimalDigits = true;
+	function BigNumber$1(v, b) {
+		var alphabet, c, caseChanged, e, i, isNum, len, str, x = this;
+		if (!(x instanceof BigNumber$1)) return new BigNumber$1(v, b);
+		if (b == null) {
+			if (v && v._isBigNumber === true) {
+				x.s = v.s;
+				if (!v.c || v.e > MAX_EXP) x.c = x.e = null;
+				else if (v.e < MIN_EXP) x.c = [x.e = 0];
+				else {
+					x.e = v.e;
+					x.c = v.c.slice();
+				}
+				return;
+			}
+			if ((isNum = typeof v == "number") && v * 0 == 0) {
+				x.s = 1 / v < 0 ? (v = -v, -1) : 1;
+				if (v === ~~v) {
+					for (e = 0, i = v; i >= 10; i /= 10, e++);
+					if (e > MAX_EXP) x.c = x.e = null;
+					else {
+						x.e = e;
+						x.c = [v];
+					}
+					return;
+				}
+				str = String(v);
+			} else {
+				if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);
+				x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
+			}
+			if ((e = str.indexOf(".")) > -1) str = str.replace(".", "");
+			if ((i = str.search(/e/i)) > 0) {
+				if (e < 0) e = i;
+				e += +str.slice(i + 1);
+				str = str.substring(0, i);
+			} else if (e < 0) e = str.length;
+		} else {
+			intCheck(b, 2, ALPHABET.length, "Base");
+			if (b == 10 && alphabetHasNormalDecimalDigits) {
+				x = new BigNumber$1(v);
+				return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
+			}
+			str = String(v);
+			if (isNum = typeof v == "number") {
+				if (v * 0 != 0) return parseNumeric(x, str, isNum, b);
+				x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;
+				if (BigNumber$1.DEBUG && str.replace(/^0\.0*|\./, "").length > 15) throw Error(tooManyDigits + v);
+			} else x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
+			alphabet = ALPHABET.slice(0, b);
+			e = i = 0;
+			for (len = str.length; i < len; i++) if (alphabet.indexOf(c = str.charAt(i)) < 0) {
+				if (c == ".") {
+					if (i > e) {
+						e = len;
+						continue;
+					}
+				} else if (!caseChanged) {
+					if (str == str.toUpperCase() && (str = str.toLowerCase()) || str == str.toLowerCase() && (str = str.toUpperCase())) {
+						caseChanged = true;
+						i = -1;
+						e = 0;
+						continue;
+					}
+				}
+				return parseNumeric(x, String(v), isNum, b);
+			}
+			isNum = false;
+			str = convertBase(str, b, 10, x.s);
+			if ((e = str.indexOf(".")) > -1) str = str.replace(".", "");
+			else e = str.length;
+		}
+		for (i = 0; str.charCodeAt(i) === 48; i++);
+		for (len = str.length; str.charCodeAt(--len) === 48;);
+		if (str = str.slice(i, ++len)) {
+			len -= i;
+			if (isNum && BigNumber$1.DEBUG && len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) throw Error(tooManyDigits + x.s * v);
+			if ((e = e - i - 1) > MAX_EXP) x.c = x.e = null;
+			else if (e < MIN_EXP) x.c = [x.e = 0];
+			else {
+				x.e = e;
+				x.c = [];
+				i = (e + 1) % LOG_BASE;
+				if (e < 0) i += LOG_BASE;
+				if (i < len) {
+					if (i) x.c.push(+str.slice(0, i));
+					for (len -= LOG_BASE; i < len;) x.c.push(+str.slice(i, i += LOG_BASE));
+					i = LOG_BASE - (str = str.slice(i)).length;
+				} else i -= len;
+				for (; i--; str += "0");
+				x.c.push(+str);
+			}
+		} else x.c = [x.e = 0];
+	}
+	BigNumber$1.clone = clone;
+	BigNumber$1.ROUND_UP = 0;
+	BigNumber$1.ROUND_DOWN = 1;
+	BigNumber$1.ROUND_CEIL = 2;
+	BigNumber$1.ROUND_FLOOR = 3;
+	BigNumber$1.ROUND_HALF_UP = 4;
+	BigNumber$1.ROUND_HALF_DOWN = 5;
+	BigNumber$1.ROUND_HALF_EVEN = 6;
+	BigNumber$1.ROUND_HALF_CEIL = 7;
+	BigNumber$1.ROUND_HALF_FLOOR = 8;
+	BigNumber$1.EUCLID = 9;
+	BigNumber$1.config = BigNumber$1.set = function(obj) {
+		var p, v;
+		if (obj != null) if (typeof obj == "object") {
+			if (obj.hasOwnProperty(p = "DECIMAL_PLACES")) {
+				v = obj[p];
+				intCheck(v, 0, MAX, p);
+				DECIMAL_PLACES = v;
+			}
+			if (obj.hasOwnProperty(p = "ROUNDING_MODE")) {
+				v = obj[p];
+				intCheck(v, 0, 8, p);
+				ROUNDING_MODE = v;
+			}
+			if (obj.hasOwnProperty(p = "EXPONENTIAL_AT")) {
+				v = obj[p];
+				if (v && v.pop) {
+					intCheck(v[0], -MAX, 0, p);
+					intCheck(v[1], 0, MAX, p);
+					TO_EXP_NEG = v[0];
+					TO_EXP_POS = v[1];
+				} else {
+					intCheck(v, -MAX, MAX, p);
+					TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);
+				}
+			}
+			if (obj.hasOwnProperty(p = "RANGE")) {
+				v = obj[p];
+				if (v && v.pop) {
+					intCheck(v[0], -MAX, -1, p);
+					intCheck(v[1], 1, MAX, p);
+					MIN_EXP = v[0];
+					MAX_EXP = v[1];
+				} else {
+					intCheck(v, -MAX, MAX, p);
+					if (v) MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
+					else throw Error(bignumberError + p + " cannot be zero: " + v);
+				}
+			}
+			if (obj.hasOwnProperty(p = "CRYPTO")) {
+				v = obj[p];
+				if (v === !!v) if (v) if (typeof crypto != "undefined" && crypto && (crypto.getRandomValues || crypto.randomBytes)) CRYPTO = v;
+				else {
+					CRYPTO = !v;
+					throw Error(bignumberError + "crypto unavailable");
+				}
+				else CRYPTO = v;
+				else throw Error(bignumberError + p + " not true or false: " + v);
+			}
+			if (obj.hasOwnProperty(p = "MODULO_MODE")) {
+				v = obj[p];
+				intCheck(v, 0, 9, p);
+				MODULO_MODE = v;
+			}
+			if (obj.hasOwnProperty(p = "POW_PRECISION")) {
+				v = obj[p];
+				intCheck(v, 0, MAX, p);
+				POW_PRECISION = v;
+			}
+			if (obj.hasOwnProperty(p = "FORMAT")) {
+				v = obj[p];
+				if (typeof v == "object") FORMAT = v;
+				else throw Error(bignumberError + p + " not an object: " + v);
+			}
+			if (obj.hasOwnProperty(p = "ALPHABET")) {
+				v = obj[p];
+				if (typeof v == "string" && !/^.?$|[+\-.\s]|(.).*\1/.test(v)) {
+					alphabetHasNormalDecimalDigits = v.slice(0, 10) == "0123456789";
+					ALPHABET = v;
+				} else throw Error(bignumberError + p + " invalid: " + v);
+			}
+		} else throw Error(bignumberError + "Object expected: " + obj);
+		return {
+			DECIMAL_PLACES,
+			ROUNDING_MODE,
+			EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
+			RANGE: [MIN_EXP, MAX_EXP],
+			CRYPTO,
+			MODULO_MODE,
+			POW_PRECISION,
+			FORMAT,
+			ALPHABET
+		};
+	};
+	BigNumber$1.isBigNumber = function(v) {
+		if (!v || v._isBigNumber !== true) return false;
+		if (!BigNumber$1.DEBUG) return true;
+		var i, n, c = v.c, e = v.e, s = v.s;
+		out: if ({}.toString.call(c) == "[object Array]") {
+			if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {
+				if (c[0] === 0) {
+					if (e === 0 && c.length === 1) return true;
+					break out;
+				}
+				i = (e + 1) % LOG_BASE;
+				if (i < 1) i += LOG_BASE;
+				if (String(c[0]).length == i) {
+					for (i = 0; i < c.length; i++) {
+						n = c[i];
+						if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;
+					}
+					if (n !== 0) return true;
+				}
+			}
+		} else if (c === null && e === null && (s === null || s === 1 || s === -1)) return true;
+		throw Error(bignumberError + "Invalid BigNumber: " + v);
+	};
+	BigNumber$1.maximum = BigNumber$1.max = function() {
+		return maxOrMin(arguments, -1);
+	};
+	BigNumber$1.minimum = BigNumber$1.min = function() {
+		return maxOrMin(arguments, 1);
+	};
+	BigNumber$1.random = (function() {
+		var pow2_53 = 9007199254740992;
+		var random53bitInt = Math.random() * pow2_53 & 2097151 ? function() {
+			return mathfloor(Math.random() * pow2_53);
+		} : function() {
+			return (Math.random() * 1073741824 | 0) * 8388608 + (Math.random() * 8388608 | 0);
+		};
+		return function(dp) {
+			var a, b, e, k, v, i = 0, c = [], rand = new BigNumber$1(ONE);
+			if (dp == null) dp = DECIMAL_PLACES;
+			else intCheck(dp, 0, MAX);
+			k = mathceil(dp / LOG_BASE);
+			if (CRYPTO) if (crypto.getRandomValues) {
+				a = crypto.getRandomValues(new Uint32Array(k *= 2));
+				for (; i < k;) {
+					v = a[i] * 131072 + (a[i + 1] >>> 11);
+					if (v >= 9e15) {
+						b = crypto.getRandomValues(new Uint32Array(2));
+						a[i] = b[0];
+						a[i + 1] = b[1];
+					} else {
+						c.push(v % 0x5af3107a4000);
+						i += 2;
+					}
+				}
+				i = k / 2;
+			} else if (crypto.randomBytes) {
+				a = crypto.randomBytes(k *= 7);
+				for (; i < k;) {
+					v = (a[i] & 31) * 281474976710656 + a[i + 1] * 1099511627776 + a[i + 2] * 4294967296 + a[i + 3] * 16777216 + (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];
+					if (v >= 9e15) crypto.randomBytes(7).copy(a, i);
+					else {
+						c.push(v % 0x5af3107a4000);
+						i += 7;
+					}
+				}
+				i = k / 7;
+			} else {
+				CRYPTO = false;
+				throw Error(bignumberError + "crypto unavailable");
+			}
+			if (!CRYPTO) for (; i < k;) {
+				v = random53bitInt();
+				if (v < 9e15) c[i++] = v % 0x5af3107a4000;
+			}
+			k = c[--i];
+			dp %= LOG_BASE;
+			if (k && dp) {
+				v = POWS_TEN[LOG_BASE - dp];
+				c[i] = mathfloor(k / v) * v;
+			}
+			for (; c[i] === 0; c.pop(), i--);
+			if (i < 0) c = [e = 0];
+			else {
+				for (e = -1; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);
+				for (i = 1, v = c[0]; v >= 10; v /= 10, i++);
+				if (i < LOG_BASE) e -= LOG_BASE - i;
+			}
+			rand.e = e;
+			rand.c = c;
+			return rand;
+		};
+	})();
+	BigNumber$1.sum = function() {
+		var i = 1, args = arguments, sum = new BigNumber$1(args[0]);
+		for (; i < args.length;) sum = sum.plus(args[i++]);
+		return sum;
+	};
+	convertBase = (function() {
+		var decimal = "0123456789";
+		function toBaseOut(str, baseIn, baseOut, alphabet) {
+			var j, arr = [0], arrL, i = 0, len = str.length;
+			for (; i < len;) {
+				for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);
+				arr[0] += alphabet.indexOf(str.charAt(i++));
+				for (j = 0; j < arr.length; j++) if (arr[j] > baseOut - 1) {
+					if (arr[j + 1] == null) arr[j + 1] = 0;
+					arr[j + 1] += arr[j] / baseOut | 0;
+					arr[j] %= baseOut;
+				}
+			}
+			return arr.reverse();
+		}
+		return function(str, baseIn, baseOut, sign, callerIsToString) {
+			var alphabet, d, e, k, r, x, xc, y, i = str.indexOf("."), dp = DECIMAL_PLACES, rm = ROUNDING_MODE;
+			if (i >= 0) {
+				k = POW_PRECISION;
+				POW_PRECISION = 0;
+				str = str.replace(".", "");
+				y = new BigNumber$1(baseIn);
+				x = y.pow(str.length - i);
+				POW_PRECISION = k;
+				y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, "0"), 10, baseOut, decimal);
+				y.e = y.c.length;
+			}
+			xc = toBaseOut(str, baseIn, baseOut, callerIsToString ? (alphabet = ALPHABET, decimal) : (alphabet = decimal, ALPHABET));
+			e = k = xc.length;
+			for (; xc[--k] == 0; xc.pop());
+			if (!xc[0]) return alphabet.charAt(0);
+			if (i < 0) --e;
+			else {
+				x.c = xc;
+				x.e = e;
+				x.s = sign;
+				x = div(x, y, dp, rm, baseOut);
+				xc = x.c;
+				r = x.r;
+				e = x.e;
+			}
+			d = e + dp + 1;
+			i = xc[d];
+			k = baseOut / 2;
+			r = r || d < 0 || xc[d + 1] != null;
+			r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : i > k || i == k && (rm == 4 || r || rm == 6 && xc[d - 1] & 1 || rm == (x.s < 0 ? 8 : 7));
+			if (d < 1 || !xc[0]) str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);
+			else {
+				xc.length = d;
+				if (r) for (--baseOut; ++xc[--d] > baseOut;) {
+					xc[d] = 0;
+					if (!d) {
+						++e;
+						xc = [1].concat(xc);
+					}
+				}
+				for (k = xc.length; !xc[--k];);
+				for (i = 0, str = ""; i <= k; str += alphabet.charAt(xc[i++]));
+				str = toFixedPoint(str, e, alphabet.charAt(0));
+			}
+			return str;
+		};
+	})();
+	div = (function() {
+		function multiply(x, k, base) {
+			var m, temp, xlo, xhi, carry = 0, i = x.length, klo = k % SQRT_BASE, khi = k / SQRT_BASE | 0;
+			for (x = x.slice(); i--;) {
+				xlo = x[i] % SQRT_BASE;
+				xhi = x[i] / SQRT_BASE | 0;
+				m = khi * xlo + xhi * klo;
+				temp = klo * xlo + m % SQRT_BASE * SQRT_BASE + carry;
+				carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;
+				x[i] = temp % base;
+			}
+			if (carry) x = [carry].concat(x);
+			return x;
+		}
+		function compare$1(a, b, aL, bL) {
+			var i, cmp;
+			if (aL != bL) cmp = aL > bL ? 1 : -1;
+			else for (i = cmp = 0; i < aL; i++) if (a[i] != b[i]) {
+				cmp = a[i] > b[i] ? 1 : -1;
+				break;
+			}
+			return cmp;
+		}
+		function subtract(a, b, aL, base) {
+			var i = 0;
+			for (; aL--;) {
+				a[aL] -= i;
+				i = a[aL] < b[aL] ? 1 : 0;
+				a[aL] = i * base + a[aL] - b[aL];
+			}
+			for (; !a[0] && a.length > 1; a.splice(0, 1));
+		}
+		return function(x, y, dp, rm, base) {
+			var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0, yL, yz, s = x.s == y.s ? 1 : -1, xc = x.c, yc = y.c;
+			if (!xc || !xc[0] || !yc || !yc[0]) return new BigNumber$1(!x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN : xc && xc[0] == 0 || !yc ? s * 0 : s / 0);
+			q = new BigNumber$1(s);
+			qc = q.c = [];
+			e = x.e - y.e;
+			s = dp + e + 1;
+			if (!base) {
+				base = BASE;
+				e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);
+				s = s / LOG_BASE | 0;
+			}
+			for (i = 0; yc[i] == (xc[i] || 0); i++);
+			if (yc[i] > (xc[i] || 0)) e--;
+			if (s < 0) {
+				qc.push(1);
+				more = true;
+			} else {
+				xL = xc.length;
+				yL = yc.length;
+				i = 0;
+				s += 2;
+				n = mathfloor(base / (yc[0] + 1));
+				if (n > 1) {
+					yc = multiply(yc, n, base);
+					xc = multiply(xc, n, base);
+					yL = yc.length;
+					xL = xc.length;
+				}
+				xi = yL;
+				rem = xc.slice(0, yL);
+				remL = rem.length;
+				for (; remL < yL; rem[remL++] = 0);
+				yz = yc.slice();
+				yz = [0].concat(yz);
+				yc0 = yc[0];
+				if (yc[1] >= base / 2) yc0++;
+				do {
+					n = 0;
+					cmp = compare$1(yc, rem, yL, remL);
+					if (cmp < 0) {
+						rem0 = rem[0];
+						if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);
+						n = mathfloor(rem0 / yc0);
+						if (n > 1) {
+							if (n >= base) n = base - 1;
+							prod = multiply(yc, n, base);
+							prodL = prod.length;
+							remL = rem.length;
+							while (compare$1(prod, rem, prodL, remL) == 1) {
+								n--;
+								subtract(prod, yL < prodL ? yz : yc, prodL, base);
+								prodL = prod.length;
+								cmp = 1;
+							}
+						} else {
+							if (n == 0) cmp = n = 1;
+							prod = yc.slice();
+							prodL = prod.length;
+						}
+						if (prodL < remL) prod = [0].concat(prod);
+						subtract(rem, prod, remL, base);
+						remL = rem.length;
+						if (cmp == -1) while (compare$1(yc, rem, yL, remL) < 1) {
+							n++;
+							subtract(rem, yL < remL ? yz : yc, remL, base);
+							remL = rem.length;
+						}
+					} else if (cmp === 0) {
+						n++;
+						rem = [0];
+					}
+					qc[i++] = n;
+					if (rem[0]) rem[remL++] = xc[xi] || 0;
+					else {
+						rem = [xc[xi]];
+						remL = 1;
+					}
+				} while ((xi++ < xL || rem[0] != null) && s--);
+				more = rem[0] != null;
+				if (!qc[0]) qc.splice(0, 1);
+			}
+			if (base == BASE) {
+				for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);
+				round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);
+			} else {
+				q.e = e;
+				q.r = +more;
+			}
+			return q;
+		};
+	})();
+	function format(n, i, rm, id) {
+		var c0, e, ne, len, str;
+		if (rm == null) rm = ROUNDING_MODE;
+		else intCheck(rm, 0, 8);
+		if (!n.c) return n.toString();
+		c0 = n.c[0];
+		ne = n.e;
+		if (i == null) {
+			str = coeffToString(n.c);
+			str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS) ? toExponential(str, ne) : toFixedPoint(str, ne, "0");
+		} else {
+			n = round(new BigNumber$1(n), i, rm);
+			e = n.e;
+			str = coeffToString(n.c);
+			len = str.length;
+			if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {
+				for (; len < i; str += "0", len++);
+				str = toExponential(str, e);
+			} else {
+				i -= ne;
+				str = toFixedPoint(str, e, "0");
+				if (e + 1 > len) {
+					if (--i > 0) for (str += "."; i--; str += "0");
+				} else {
+					i += e - len;
+					if (i > 0) {
+						if (e + 1 == len) str += ".";
+						for (; i--; str += "0");
+					}
+				}
+			}
+		}
+		return n.s < 0 && c0 ? "-" + str : str;
+	}
+	function maxOrMin(args, n) {
+		var k, y, i = 1, x = new BigNumber$1(args[0]);
+		for (; i < args.length; i++) {
+			y = new BigNumber$1(args[i]);
+			if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) x = y;
+		}
+		return x;
+	}
+	function normalise(n, c, e) {
+		var i = 1, j = c.length;
+		for (; !c[--j]; c.pop());
+		for (j = c[0]; j >= 10; j /= 10, i++);
+		if ((e = i + e * LOG_BASE - 1) > MAX_EXP) n.c = n.e = null;
+		else if (e < MIN_EXP) n.c = [n.e = 0];
+		else {
+			n.e = e;
+			n.c = c;
+		}
+		return n;
+	}
+	parseNumeric = (function() {
+		var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, dotAfter = /^([^.]+)\.$/, dotBefore = /^\.([^.]+)$/, isInfinityOrNaN = /^-?(Infinity|NaN)$/, whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
+		return function(x, str, isNum, b) {
+			var base, s = isNum ? str : str.replace(whitespaceOrPlus, "");
+			if (isInfinityOrNaN.test(s)) x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
+			else {
+				if (!isNum) {
+					s = s.replace(basePrefix, function(m, p1, p2) {
+						base = (p2 = p2.toLowerCase()) == "x" ? 16 : p2 == "b" ? 2 : 8;
+						return !b || b == base ? p1 : m;
+					});
+					if (b) {
+						base = b;
+						s = s.replace(dotAfter, "$1").replace(dotBefore, "0.$1");
+					}
+					if (str != s) return new BigNumber$1(s, base);
+				}
+				if (BigNumber$1.DEBUG) throw Error(bignumberError + "Not a" + (b ? " base " + b : "") + " number: " + str);
+				x.s = null;
+			}
+			x.c = x.e = null;
+		};
+	})();
+	function round(x, sd, rm, r) {
+		var d, i, j, k, n, ni, rd, xc = x.c, pows10 = POWS_TEN;
+		if (xc) {
+			out: {
+				for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);
+				i = sd - d;
+				if (i < 0) {
+					i += LOG_BASE;
+					j = sd;
+					n = xc[ni = 0];
+					rd = mathfloor(n / pows10[d - j - 1] % 10);
+				} else {
+					ni = mathceil((i + 1) / LOG_BASE);
+					if (ni >= xc.length) if (r) {
+						for (; xc.length <= ni; xc.push(0));
+						n = rd = 0;
+						d = 1;
+						i %= LOG_BASE;
+						j = i - LOG_BASE + 1;
+					} else break out;
+					else {
+						n = k = xc[ni];
+						for (d = 1; k >= 10; k /= 10, d++);
+						i %= LOG_BASE;
+						j = i - LOG_BASE + d;
+						rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);
+					}
+				}
+				r = r || sd < 0 || xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);
+				r = rm < 4 ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 && (i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10 & 1 || rm == (x.s < 0 ? 8 : 7));
+				if (sd < 1 || !xc[0]) {
+					xc.length = 0;
+					if (r) {
+						sd -= x.e + 1;
+						xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];
+						x.e = -sd || 0;
+					} else xc[0] = x.e = 0;
+					return x;
+				}
+				if (i == 0) {
+					xc.length = ni;
+					k = 1;
+					ni--;
+				} else {
+					xc.length = ni + 1;
+					k = pows10[LOG_BASE - i];
+					xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;
+				}
+				if (r) for (;;) if (ni == 0) {
+					for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);
+					j = xc[0] += k;
+					for (k = 1; j >= 10; j /= 10, k++);
+					if (i != k) {
+						x.e++;
+						if (xc[0] == BASE) xc[0] = 1;
+					}
+					break;
+				} else {
+					xc[ni] += k;
+					if (xc[ni] != BASE) break;
+					xc[ni--] = 0;
+					k = 1;
+				}
+				for (i = xc.length; xc[--i] === 0; xc.pop());
+			}
+			if (x.e > MAX_EXP) x.c = x.e = null;
+			else if (x.e < MIN_EXP) x.c = [x.e = 0];
+		}
+		return x;
+	}
+	function valueOf(n) {
+		var str, e = n.e;
+		if (e === null) return n.toString();
+		str = coeffToString(n.c);
+		str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(str, e) : toFixedPoint(str, e, "0");
+		return n.s < 0 ? "-" + str : str;
+	}
+	P.absoluteValue = P.abs = function() {
+		var x = new BigNumber$1(this);
+		if (x.s < 0) x.s = 1;
+		return x;
+	};
+	P.comparedTo = function(y, b) {
+		return compare(this, new BigNumber$1(y, b));
+	};
+	P.decimalPlaces = P.dp = function(dp, rm) {
+		var c, n, v, x = this;
+		if (dp != null) {
+			intCheck(dp, 0, MAX);
+			if (rm == null) rm = ROUNDING_MODE;
+			else intCheck(rm, 0, 8);
+			return round(new BigNumber$1(x), dp + x.e + 1, rm);
+		}
+		if (!(c = x.c)) return null;
+		n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;
+		if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);
+		if (n < 0) n = 0;
+		return n;
+	};
+	P.dividedBy = P.div = function(y, b) {
+		return div(this, new BigNumber$1(y, b), DECIMAL_PLACES, ROUNDING_MODE);
+	};
+	P.dividedToIntegerBy = P.idiv = function(y, b) {
+		return div(this, new BigNumber$1(y, b), 0, 1);
+	};
+	P.exponentiatedBy = P.pow = function(n, m) {
+		var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y, x = this;
+		n = new BigNumber$1(n);
+		if (n.c && !n.isInteger()) throw Error(bignumberError + "Exponent not an integer: " + valueOf(n));
+		if (m != null) m = new BigNumber$1(m);
+		nIsBig = n.e > 14;
+		if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {
+			y = new BigNumber$1(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));
+			return m ? y.mod(m) : y;
+		}
+		nIsNeg = n.s < 0;
+		if (m) {
+			if (m.c ? !m.c[0] : !m.s) return new BigNumber$1(NaN);
+			isModExp = !nIsNeg && x.isInteger() && m.isInteger();
+			if (isModExp) x = x.mod(m);
+		} else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0 ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7 : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {
+			k = x.s < 0 && isOdd(n) ? -0 : 0;
+			if (x.e > -1) k = 1 / k;
+			return new BigNumber$1(nIsNeg ? 1 / k : k);
+		} else if (POW_PRECISION) k = mathceil(POW_PRECISION / LOG_BASE + 2);
+		if (nIsBig) {
+			half = new BigNumber$1(.5);
+			if (nIsNeg) n.s = 1;
+			nIsOdd = isOdd(n);
+		} else {
+			i = Math.abs(+valueOf(n));
+			nIsOdd = i % 2;
+		}
+		y = new BigNumber$1(ONE);
+		for (;;) {
+			if (nIsOdd) {
+				y = y.times(x);
+				if (!y.c) break;
+				if (k) {
+					if (y.c.length > k) y.c.length = k;
+				} else if (isModExp) y = y.mod(m);
+			}
+			if (i) {
+				i = mathfloor(i / 2);
+				if (i === 0) break;
+				nIsOdd = i % 2;
+			} else {
+				n = n.times(half);
+				round(n, n.e + 1, 1);
+				if (n.e > 14) nIsOdd = isOdd(n);
+				else {
+					i = +valueOf(n);
+					if (i === 0) break;
+					nIsOdd = i % 2;
+				}
+			}
+			x = x.times(x);
+			if (k) {
+				if (x.c && x.c.length > k) x.c.length = k;
+			} else if (isModExp) x = x.mod(m);
+		}
+		if (isModExp) return y;
+		if (nIsNeg) y = ONE.div(y);
+		return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;
+	};
+	P.integerValue = function(rm) {
+		var n = new BigNumber$1(this);
+		if (rm == null) rm = ROUNDING_MODE;
+		else intCheck(rm, 0, 8);
+		return round(n, n.e + 1, rm);
+	};
+	P.isEqualTo = P.eq = function(y, b) {
+		return compare(this, new BigNumber$1(y, b)) === 0;
+	};
+	P.isFinite = function() {
+		return !!this.c;
+	};
+	P.isGreaterThan = P.gt = function(y, b) {
+		return compare(this, new BigNumber$1(y, b)) > 0;
+	};
+	P.isGreaterThanOrEqualTo = P.gte = function(y, b) {
+		return (b = compare(this, new BigNumber$1(y, b))) === 1 || b === 0;
+	};
+	P.isInteger = function() {
+		return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
+	};
+	P.isLessThan = P.lt = function(y, b) {
+		return compare(this, new BigNumber$1(y, b)) < 0;
+	};
+	P.isLessThanOrEqualTo = P.lte = function(y, b) {
+		return (b = compare(this, new BigNumber$1(y, b))) === -1 || b === 0;
+	};
+	P.isNaN = function() {
+		return !this.s;
+	};
+	P.isNegative = function() {
+		return this.s < 0;
+	};
+	P.isPositive = function() {
+		return this.s > 0;
+	};
+	P.isZero = function() {
+		return !!this.c && this.c[0] == 0;
+	};
+	P.minus = function(y, b) {
+		var i, j, t, xLTy, x = this, a = x.s;
+		y = new BigNumber$1(y, b);
+		b = y.s;
+		if (!a || !b) return new BigNumber$1(NaN);
+		if (a != b) {
+			y.s = -b;
+			return x.plus(y);
+		}
+		var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
+		if (!xe || !ye) {
+			if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber$1(yc ? x : NaN);
+			if (!xc[0] || !yc[0]) return yc[0] ? (y.s = -b, y) : new BigNumber$1(xc[0] ? x : ROUNDING_MODE == 3 ? -0 : 0);
+		}
+		xe = bitFloor(xe);
+		ye = bitFloor(ye);
+		xc = xc.slice();
+		if (a = xe - ye) {
+			if (xLTy = a < 0) {
+				a = -a;
+				t = xc;
+			} else {
+				ye = xe;
+				t = yc;
+			}
+			t.reverse();
+			for (b = a; b--; t.push(0));
+			t.reverse();
+		} else {
+			j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;
+			for (a = b = 0; b < j; b++) if (xc[b] != yc[b]) {
+				xLTy = xc[b] < yc[b];
+				break;
+			}
+		}
+		if (xLTy) {
+			t = xc;
+			xc = yc;
+			yc = t;
+			y.s = -y.s;
+		}
+		b = (j = yc.length) - (i = xc.length);
+		if (b > 0) for (; b--; xc[i++] = 0);
+		b = BASE - 1;
+		for (; j > a;) {
+			if (xc[--j] < yc[j]) {
+				for (i = j; i && !xc[--i]; xc[i] = b);
+				--xc[i];
+				xc[j] += BASE;
+			}
+			xc[j] -= yc[j];
+		}
+		for (; xc[0] == 0; xc.splice(0, 1), --ye);
+		if (!xc[0]) {
+			y.s = ROUNDING_MODE == 3 ? -1 : 1;
+			y.c = [y.e = 0];
+			return y;
+		}
+		return normalise(y, xc, ye);
+	};
+	P.modulo = P.mod = function(y, b) {
+		var q, s, x = this;
+		y = new BigNumber$1(y, b);
+		if (!x.c || !y.s || y.c && !y.c[0]) return new BigNumber$1(NaN);
+		else if (!y.c || x.c && !x.c[0]) return new BigNumber$1(x);
+		if (MODULO_MODE == 9) {
+			s = y.s;
+			y.s = 1;
+			q = div(x, y, 0, 3);
+			y.s = s;
+			q.s *= s;
+		} else q = div(x, y, 0, MODULO_MODE);
+		y = x.minus(q.times(y));
+		if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;
+		return y;
+	};
+	P.multipliedBy = P.times = function(y, b) {
+		var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, base, sqrtBase, x = this, xc = x.c, yc = (y = new BigNumber$1(y, b)).c;
+		if (!xc || !yc || !xc[0] || !yc[0]) {
+			if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) y.c = y.e = y.s = null;
+			else {
+				y.s *= x.s;
+				if (!xc || !yc) y.c = y.e = null;
+				else {
+					y.c = [0];
+					y.e = 0;
+				}
+			}
+			return y;
+		}
+		e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);
+		y.s *= x.s;
+		xcL = xc.length;
+		ycL = yc.length;
+		if (xcL < ycL) {
+			zc = xc;
+			xc = yc;
+			yc = zc;
+			i = xcL;
+			xcL = ycL;
+			ycL = i;
+		}
+		for (i = xcL + ycL, zc = []; i--; zc.push(0));
+		base = BASE;
+		sqrtBase = SQRT_BASE;
+		for (i = ycL; --i >= 0;) {
+			c = 0;
+			ylo = yc[i] % sqrtBase;
+			yhi = yc[i] / sqrtBase | 0;
+			for (k = xcL, j = i + k; j > i;) {
+				xlo = xc[--k] % sqrtBase;
+				xhi = xc[k] / sqrtBase | 0;
+				m = yhi * xlo + xhi * ylo;
+				xlo = ylo * xlo + m % sqrtBase * sqrtBase + zc[j] + c;
+				c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;
+				zc[j--] = xlo % base;
+			}
+			zc[j] = c;
+		}
+		if (c) ++e;
+		else zc.splice(0, 1);
+		return normalise(y, zc, e);
+	};
+	P.negated = function() {
+		var x = new BigNumber$1(this);
+		x.s = -x.s || null;
+		return x;
+	};
+	P.plus = function(y, b) {
+		var t, x = this, a = x.s;
+		y = new BigNumber$1(y, b);
+		b = y.s;
+		if (!a || !b) return new BigNumber$1(NaN);
+		if (a != b) {
+			y.s = -b;
+			return x.minus(y);
+		}
+		var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
+		if (!xe || !ye) {
+			if (!xc || !yc) return new BigNumber$1(a / 0);
+			if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber$1(xc[0] ? x : a * 0);
+		}
+		xe = bitFloor(xe);
+		ye = bitFloor(ye);
+		xc = xc.slice();
+		if (a = xe - ye) {
+			if (a > 0) {
+				ye = xe;
+				t = yc;
+			} else {
+				a = -a;
+				t = xc;
+			}
+			t.reverse();
+			for (; a--; t.push(0));
+			t.reverse();
+		}
+		a = xc.length;
+		b = yc.length;
+		if (a - b < 0) {
+			t = yc;
+			yc = xc;
+			xc = t;
+			b = a;
+		}
+		for (a = 0; b;) {
+			a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;
+			xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;
+		}
+		if (a) {
+			xc = [a].concat(xc);
+			++ye;
+		}
+		return normalise(y, xc, ye);
+	};
+	P.precision = P.sd = function(sd, rm) {
+		var c, n, v, x = this;
+		if (sd != null && sd !== !!sd) {
+			intCheck(sd, 1, MAX);
+			if (rm == null) rm = ROUNDING_MODE;
+			else intCheck(rm, 0, 8);
+			return round(new BigNumber$1(x), sd, rm);
+		}
+		if (!(c = x.c)) return null;
+		v = c.length - 1;
+		n = v * LOG_BASE + 1;
+		if (v = c[v]) {
+			for (; v % 10 == 0; v /= 10, n--);
+			for (v = c[0]; v >= 10; v /= 10, n++);
+		}
+		if (sd && x.e + 1 > n) n = x.e + 1;
+		return n;
+	};
+	P.shiftedBy = function(k) {
+		intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+		return this.times("1e" + k);
+	};
+	P.squareRoot = P.sqrt = function() {
+		var m, n, r, rep, t, x = this, c = x.c, s = x.s, e = x.e, dp = DECIMAL_PLACES + 4, half = new BigNumber$1("0.5");
+		if (s !== 1 || !c || !c[0]) return new BigNumber$1(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : Infinity);
+		s = Math.sqrt(+valueOf(x));
+		if (s == 0 || s == Infinity) {
+			n = coeffToString(c);
+			if ((n.length + e) % 2 == 0) n += "0";
+			s = Math.sqrt(+n);
+			e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);
+			if (s == Infinity) n = "5e" + e;
+			else {
+				n = s.toExponential();
+				n = n.slice(0, n.indexOf("e") + 1) + e;
+			}
+			r = new BigNumber$1(n);
+		} else r = new BigNumber$1(s + "");
+		if (r.c[0]) {
+			e = r.e;
+			s = e + dp;
+			if (s < 3) s = 0;
+			for (;;) {
+				t = r;
+				r = half.times(t.plus(div(x, t, dp, 1)));
+				if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {
+					if (r.e < e) --s;
+					n = n.slice(s - 3, s + 1);
+					if (n == "9999" || !rep && n == "4999") {
+						if (!rep) {
+							round(t, t.e + DECIMAL_PLACES + 2, 0);
+							if (t.times(t).eq(x)) {
+								r = t;
+								break;
+							}
+						}
+						dp += 4;
+						s += 4;
+						rep = 1;
+					} else {
+						if (!+n || !+n.slice(1) && n.charAt(0) == "5") {
+							round(r, r.e + DECIMAL_PLACES + 2, 1);
+							m = !r.times(r).eq(x);
+						}
+						break;
+					}
+				}
+			}
+		}
+		return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
+	};
+	P.toExponential = function(dp, rm) {
+		if (dp != null) {
+			intCheck(dp, 0, MAX);
+			dp++;
+		}
+		return format(this, dp, rm, 1);
+	};
+	P.toFixed = function(dp, rm) {
+		if (dp != null) {
+			intCheck(dp, 0, MAX);
+			dp = dp + this.e + 1;
+		}
+		return format(this, dp, rm);
+	};
+	P.toFormat = function(dp, rm, format$1) {
+		var str, x = this;
+		if (format$1 == null) if (dp != null && rm && typeof rm == "object") {
+			format$1 = rm;
+			rm = null;
+		} else if (dp && typeof dp == "object") {
+			format$1 = dp;
+			dp = rm = null;
+		} else format$1 = FORMAT;
+		else if (typeof format$1 != "object") throw Error(bignumberError + "Argument not an object: " + format$1);
+		str = x.toFixed(dp, rm);
+		if (x.c) {
+			var i, arr = str.split("."), g1 = +format$1.groupSize, g2 = +format$1.secondaryGroupSize, groupSeparator = format$1.groupSeparator || "", intPart = arr[0], fractionPart = arr[1], isNeg = x.s < 0, intDigits = isNeg ? intPart.slice(1) : intPart, len = intDigits.length;
+			if (g2) {
+				i = g1;
+				g1 = g2;
+				g2 = i;
+				len -= i;
+			}
+			if (g1 > 0 && len > 0) {
+				i = len % g1 || g1;
+				intPart = intDigits.substr(0, i);
+				for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);
+				if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);
+				if (isNeg) intPart = "-" + intPart;
+			}
+			str = fractionPart ? intPart + (format$1.decimalSeparator || "") + ((g2 = +format$1.fractionGroupSize) ? fractionPart.replace(new RegExp("\\d{" + g2 + "}\\B", "g"), "$&" + (format$1.fractionGroupSeparator || "")) : fractionPart) : intPart;
+		}
+		return (format$1.prefix || "") + str + (format$1.suffix || "");
+	};
+	P.toFraction = function(md) {
+		var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s, x = this, xc = x.c;
+		if (md != null) {
+			n = new BigNumber$1(md);
+			if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) throw Error(bignumberError + "Argument " + (n.isInteger() ? "out of range: " : "not an integer: ") + valueOf(n));
+		}
+		if (!xc) return new BigNumber$1(x);
+		d = new BigNumber$1(ONE);
+		n1 = d0 = new BigNumber$1(ONE);
+		d1 = n0 = new BigNumber$1(ONE);
+		s = coeffToString(xc);
+		e = d.e = s.length - x.e - 1;
+		d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];
+		md = !md || n.comparedTo(d) > 0 ? e > 0 ? d : n1 : n;
+		exp = MAX_EXP;
+		MAX_EXP = Infinity;
+		n = new BigNumber$1(s);
+		n0.c[0] = 0;
+		for (;;) {
+			q = div(n, d, 0, 1);
+			d2 = d0.plus(q.times(d1));
+			if (d2.comparedTo(md) == 1) break;
+			d0 = d1;
+			d1 = d2;
+			n1 = n0.plus(q.times(d2 = n1));
+			n0 = d2;
+			d = n.minus(q.times(d2 = d));
+			n = d2;
+		}
+		d2 = div(md.minus(d0), d1, 0, 1);
+		n0 = n0.plus(d2.times(n1));
+		d0 = d0.plus(d2.times(d1));
+		n0.s = n1.s = x.s;
+		e = e * 2;
+		r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];
+		MAX_EXP = exp;
+		return r;
+	};
+	P.toNumber = function() {
+		return +valueOf(this);
+	};
+	P.toPrecision = function(sd, rm) {
+		if (sd != null) intCheck(sd, 1, MAX);
+		return format(this, sd, rm, 2);
+	};
+	P.toString = function(b) {
+		var str, n = this, s = n.s, e = n.e;
+		if (e === null) if (s) {
+			str = "Infinity";
+			if (s < 0) str = "-" + str;
+		} else str = "NaN";
+		else {
+			if (b == null) str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(coeffToString(n.c), e) : toFixedPoint(coeffToString(n.c), e, "0");
+			else if (b === 10 && alphabetHasNormalDecimalDigits) {
+				n = round(new BigNumber$1(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
+				str = toFixedPoint(coeffToString(n.c), n.e, "0");
+			} else {
+				intCheck(b, 2, ALPHABET.length, "Base");
+				str = convertBase(toFixedPoint(coeffToString(n.c), e, "0"), 10, b, s, true);
+			}
+			if (s < 0 && n.c[0]) str = "-" + str;
+		}
+		return str;
+	};
+	P.valueOf = P.toJSON = function() {
+		return valueOf(this);
+	};
+	P._isBigNumber = true;
+	P[Symbol.toStringTag] = "BigNumber";
+	P[Symbol.for("nodejs.util.inspect.custom")] = P.valueOf;
+	if (configObject != null) BigNumber$1.set(configObject);
+	return BigNumber$1;
+}
+function bitFloor(n) {
+	var i = n | 0;
+	return n > 0 || n === i ? i : i - 1;
+}
+function coeffToString(a) {
+	var s, z, i = 1, j = a.length, r = a[0] + "";
+	for (; i < j;) {
+		s = a[i++] + "";
+		z = LOG_BASE - s.length;
+		for (; z--; s = "0" + s);
+		r += s;
+	}
+	for (j = r.length; r.charCodeAt(--j) === 48;);
+	return r.slice(0, j + 1 || 1);
+}
+function compare(x, y) {
+	var a, b, xc = x.c, yc = y.c, i = x.s, j = y.s, k = x.e, l = y.e;
+	if (!i || !j) return null;
+	a = xc && !xc[0];
+	b = yc && !yc[0];
+	if (a || b) return a ? b ? 0 : -j : i;
+	if (i != j) return i;
+	a = i < 0;
+	b = k == l;
+	if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;
+	if (!b) return k > l ^ a ? 1 : -1;
+	j = (k = xc.length) < (l = yc.length) ? k : l;
+	for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;
+	return k == l ? 0 : k > l ^ a ? 1 : -1;
+}
+function intCheck(n, min, max, name) {
+	if (n < min || n > max || n !== mathfloor(n)) throw Error(bignumberError + (name || "Argument") + (typeof n == "number" ? n < min || n > max ? " out of range: " : " not an integer: " : " not a primitive number: ") + String(n));
+}
+function isOdd(n) {
+	var k = n.c.length - 1;
+	return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;
+}
+function toExponential(str, e) {
+	return (str.length > 1 ? str.charAt(0) + "." + str.slice(1) : str) + (e < 0 ? "e" : "e+") + e;
+}
+function toFixedPoint(str, e, z) {
+	var len, zs;
+	if (e < 0) {
+		for (zs = z + "."; ++e; zs += z);
+		str = zs + str;
+	} else {
+		len = str.length;
+		if (++e > len) {
+			for (zs = z, e -= len; --e; zs += z);
+			str += zs;
+		} else if (e < len) str = str.slice(0, e) + "." + str.slice(e);
+	}
+	return str;
+}
+var BigNumber = clone();
+
+//#endregion
+//#region ../../utils/dist/esm/constants-BxcSsKjm.js
+const DEFAULT_BLOCK_TIMEOUT_HEIGHT = 120;
+const DEFAULT_BLOCK_TIME_IN_SECONDS = .7;
+/**
+* Default timeout for transaction block inclusion polling.
+*
+* Calculation: 120 blocks × 0.7 seconds/block = 84 seconds = 84,000ms
+*/
+const DEFAULT_TX_BLOCK_INCLUSION_TIMEOUT_IN_MS = Math.floor(DEFAULT_BLOCK_TIMEOUT_HEIGHT * DEFAULT_BLOCK_TIME_IN_SECONDS * 1e3);
+const DEFAULT_TIMESTAMP_TIMEOUT_MS = 60 * 1e3 * 3;
+
+//#endregion
+//#region ../../../node_modules/.pnpm/@bangjelkoski+store2@2.14.3/node_modules/@bangjelkoski/store2/dist/store2.js
+var require_store2 = /* @__PURE__ */ __commonJS({ "../../../node_modules/.pnpm/@bangjelkoski+store2@2.14.3/node_modules/@bangjelkoski/store2/dist/store2.js": ((exports, module) => {
+	(function(window, define) {
+		var _ = {
+			version: "2.14.3",
+			areas: {},
+			apis: {},
+			nsdelim: ".",
+			inherit: function(api, o) {
+				for (var p in api) if (!o.hasOwnProperty(p)) Object.defineProperty(o, p, Object.getOwnPropertyDescriptor(api, p));
+				return o;
+			},
+			stringify: function(d, fn) {
+				return d === void 0 || typeof d === "function" ? d + "" : JSON.stringify(d, fn || _.replace);
+			},
+			parse: function(s, fn) {
+				try {
+					return JSON.parse(s, fn || _.revive);
+				} catch (e) {
+					return s;
+				}
+			},
+			fn: function(name, fn) {
+				_.storeAPI[name] = fn;
+				for (var api in _.apis) _.apis[api][name] = fn;
+			},
+			get: function(area, key) {
+				return area.getItem(key);
+			},
+			set: function(area, key, string) {
+				area.setItem(key, string);
+			},
+			remove: function(area, key) {
+				area.removeItem(key);
+			},
+			key: function(area, i) {
+				return area.key(i);
+			},
+			length: function(area) {
+				return area.length;
+			},
+			clear: function(area) {
+				area.clear();
+			},
+			Store: function(id, area, namespace) {
+				var store$2 = _.inherit(_.storeAPI, function(key, data, overwrite) {
+					if (arguments.length === 0) return store$2.getAll();
+					if (typeof data === "function") return store$2.transact(key, data, overwrite);
+					if (data !== void 0) return store$2.set(key, data, overwrite);
+					if (typeof key === "string" || typeof key === "number") return store$2.get(key);
+					if (typeof key === "function") return store$2.each(key);
+					if (!key) return store$2.clear();
+					return store$2.setAll(key, data);
+				});
+				store$2._id = id;
+				try {
+					var testKey = "__store2_test";
+					area.setItem(testKey, "ok");
+					store$2._area = area;
+					area.removeItem(testKey);
+				} catch (e) {
+					store$2._area = _.storage("fake");
+				}
+				store$2._ns = namespace || "";
+				if (!_.areas[id]) _.areas[id] = store$2._area;
+				if (!_.apis[store$2._ns + store$2._id]) _.apis[store$2._ns + store$2._id] = store$2;
+				return store$2;
+			},
+			storeAPI: {
+				area: function(id, area) {
+					var store$2 = this[id];
+					if (!store$2 || !store$2.area) {
+						store$2 = _.Store(id, area, this._ns);
+						if (!this[id]) this[id] = store$2;
+					}
+					return store$2;
+				},
+				namespace: function(namespace, singleArea, delim) {
+					delim = delim || this._delim || _.nsdelim;
+					if (!namespace) return this._ns ? this._ns.substring(0, this._ns.length - delim.length) : "";
+					var ns = namespace, store$2 = this[ns];
+					if (!store$2 || !store$2.namespace) {
+						store$2 = _.Store(this._id, this._area, this._ns + ns + delim);
+						store$2._delim = delim;
+						if (!this[ns]) this[ns] = store$2;
+						if (!singleArea) for (var name in _.areas) store$2.area(name, _.areas[name]);
+					}
+					return store$2;
+				},
+				isFake: function(force) {
+					if (force) {
+						this._real = this._area;
+						this._area = _.storage("fake");
+					} else if (force === false) this._area = this._real || this._area;
+					return this._area.name === "fake";
+				},
+				toString: function() {
+					return "store" + (this._ns ? "." + this.namespace() : "") + "[" + this._id + "]";
+				},
+				has: function(key) {
+					if (this._area.has) return this._area.has(this._in(key));
+					return !!(this._in(key) in this._area);
+				},
+				size: function() {
+					return this.keys().length;
+				},
+				each: function(fn, fill) {
+					for (var i = 0, m = _.length(this._area); i < m; i++) {
+						var key = this._out(_.key(this._area, i));
+						if (key !== void 0) {
+							if (fn.call(this, key, this.get(key), fill) === false) break;
+						}
+						if (m > _.length(this._area)) {
+							m--;
+							i--;
+						}
+					}
+					return fill || this;
+				},
+				keys: function(fillList) {
+					return this.each(function(k, v, list) {
+						list.push(k);
+					}, fillList || []);
+				},
+				get: function(key, alt) {
+					var s = _.get(this._area, this._in(key)), fn;
+					if (typeof alt === "function") {
+						fn = alt;
+						alt = null;
+					}
+					return s !== null ? _.parse(s, fn) : alt != null ? alt : s;
+				},
+				getAll: function(fillObj) {
+					return this.each(function(k, v, all) {
+						all[k] = v;
+					}, fillObj || {});
+				},
+				transact: function(key, fn, alt) {
+					var val = this.get(key, alt), ret = fn(val);
+					this.set(key, ret === void 0 ? val : ret);
+					return this;
+				},
+				set: function(key, data, overwrite) {
+					var d = this.get(key), replacer;
+					if (d != null && overwrite === false) return data;
+					if (typeof overwrite === "function") {
+						replacer = overwrite;
+						overwrite = void 0;
+					}
+					return _.set(this._area, this._in(key), _.stringify(data, replacer), overwrite) || d;
+				},
+				setAll: function(data, overwrite) {
+					var changed, val;
+					for (var key in data) {
+						val = data[key];
+						if (this.set(key, val, overwrite) !== val) changed = true;
+					}
+					return changed;
+				},
+				add: function(key, data, replacer) {
+					var d = this.get(key);
+					if (d instanceof Array) data = d.concat(data);
+					else if (d !== null) {
+						var type = typeof d;
+						if (type === typeof data && type === "object") {
+							for (var k in data) d[k] = data[k];
+							data = d;
+						} else data = d + data;
+					}
+					_.set(this._area, this._in(key), _.stringify(data, replacer));
+					return data;
+				},
+				remove: function(key, alt) {
+					var d = this.get(key, alt);
+					_.remove(this._area, this._in(key));
+					return d;
+				},
+				clear: function() {
+					if (!this._ns) _.clear(this._area);
+					else this.each(function(k) {
+						_.remove(this._area, this._in(k));
+					}, 1);
+					return this;
+				},
+				clearAll: function() {
+					var area = this._area;
+					for (var id in _.areas) if (_.areas.hasOwnProperty(id)) {
+						this._area = _.areas[id];
+						this.clear();
+					}
+					this._area = area;
+					return this;
+				},
+				_in: function(k) {
+					if (typeof k !== "string") k = _.stringify(k);
+					return this._ns ? this._ns + k : k;
+				},
+				_out: function(k) {
+					return this._ns ? k && k.indexOf(this._ns) === 0 ? k.substring(this._ns.length) : void 0 : k;
+				}
+			},
+			storage: function(name) {
+				return _.inherit(_.storageAPI, {
+					items: {},
+					name
+				});
+			},
+			storageAPI: {
+				length: 0,
+				has: function(k) {
+					return this.items.hasOwnProperty(k);
+				},
+				key: function(i) {
+					var c = 0;
+					for (var k in this.items) if (this.has(k) && i === c++) return k;
+				},
+				setItem: function(k, v) {
+					if (!this.has(k)) this.length++;
+					this.items[k] = v;
+				},
+				removeItem: function(k) {
+					if (this.has(k)) {
+						delete this.items[k];
+						this.length--;
+					}
+				},
+				getItem: function(k) {
+					return this.has(k) ? this.items[k] : null;
+				},
+				clear: function() {
+					for (var k in this.items) this.removeItem(k);
+				}
+			}
+		};
+		var store$1 = _.Store("local", (function() {
+			try {
+				return localStorage;
+			} catch (e) {}
+		})());
+		store$1.local = store$1;
+		store$1._ = _;
+		store$1.area("session", (function() {
+			try {
+				return sessionStorage;
+			} catch (e) {}
+		})());
+		store$1.area("page", _.storage("page"));
+		if (typeof define === "function" && define.amd !== void 0) define("store2", [], function() {
+			return store$1;
+		});
+		else if (typeof module !== "undefined" && module.exports) {
+			module.exports = store$1;
+			module.exports.store = store$1;
+		} else {
+			if (window.store) _.conflict = window.store;
+			window.store = store$1;
+		}
+	})(exports, exports && exports.define);
+}) });
+
+//#endregion
+//#region ../../utils/dist/esm/index.js
+var import_store2 = require_store2();
+const sleep = (timeout) => new Promise((resolve) => setTimeout(resolve, timeout));
+
+//#endregion
+//#region \0@oxc-project+runtime@0.96.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.96.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.96.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.96.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/strategy/Ledger/hw/AccountManager.ts
+const addressOfHDKey = (hdKey) => {
+	const shouldSanitizePublicKey = true;
+	const derivedPublicKey = hdKey.publicKey;
+	return (0, __injectivelabs_sdk_ts.addHexPrefix)((0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.publicKeyToAddress)(derivedPublicKey, shouldSanitizePublicKey)));
+};
+var AccountManager$1 = class {
+	constructor(ledger) {
+		_defineProperty(this, "wallets", []);
+		_defineProperty(this, "ledger", void 0);
+		_defineProperty(this, "getLedgerDerivationPathBasedOnType", ({ fullBaseDerivationPath, derivationPathType, index }) => {
+			if (derivationPathType === LedgerDerivationPathType.LedgerLive) return `${fullBaseDerivationPath}/${index}'/0/0`;
+			return `${fullBaseDerivationPath}/0'/${index}`;
+		});
+		this.ledger = ledger;
+		this.wallets = [];
+	}
+	async getWallets(baseDerivationPath, derivationPathType) {
+		const { start, end } = this.getOffset();
+		/**
+		* 1. Wallets are not yet fetched at all,
+		* 2. Wallets are not yet fetched for that offset
+		*/
+		if (!this.hasWallets() || !this.hasWalletsInOffset(start)) await this.getWalletsBasedOnIndex({
+			start,
+			end,
+			baseDerivationPath,
+			derivationPathType
+		});
+		return this.wallets.slice(start, end);
+	}
+	async getWalletsBasedOnIndex({ start, end, baseDerivationPath, derivationPathType }) {
+		for (let index = start; index < end; index += 1) {
+			const path = this.getLedgerDerivationPathBasedOnType({
+				fullBaseDerivationPath: baseDerivationPath,
+				derivationPathType,
+				index
+			});
+			const result = await this.ledger.getAddress(path);
+			const hdKey = {
+				publicKey: (0, __injectivelabs_sdk_ts.hexToUint8Array)(result.publicKey),
+				chainCode: (0, __injectivelabs_sdk_ts.hexToUint8Array)(result.chainCode || "")
+			};
+			const address = result.address || addressOfHDKey(hdKey);
+			this.wallets.push({
+				hdKey,
+				baseDerivationPath,
+				address: address.toLowerCase(),
+				derivationPath: path
+			});
+		}
+	}
+	hasWallets() {
+		return this.wallets.length > 0;
+	}
+	hasWalletsInOffset(offset) {
+		return this.wallets.length > offset;
+	}
+	getOffset() {
+		const totalWallets = this.wallets.length;
+		return {
+			start: totalWallets,
+			end: totalWallets + __injectivelabs_wallet_base.DEFAULT_NUM_ADDRESSES_TO_FETCH
+		};
+	}
+	hasWalletForAddress(address) {
+		return this.wallets.find((wallet) => wallet.address.toLowerCase() === address.toLowerCase()) !== void 0;
+	}
+	async getWalletForAddress(address) {
+		return this.wallets.find((wallet) => wallet.address.toLowerCase() === address.toLowerCase());
+	}
+	reset() {
+		this.wallets = [];
+	}
+};
+
+//#endregion
+//#region src/strategy/lib.ts
+let EthType;
+let CosmosType;
+let ledgerServiceType;
+let TransportWebUSB;
+let TransportWebHID;
+async function loadEthType() {
+	if (!EthType) {
+		const module$1 = await import("@bangjelkoski/ledgerhq-hw-app-eth");
+		EthType = module$1.Eth ? module$1.Eth : module$1.default.Eth;
+	}
+	return EthType;
+}
+async function loadCosmosType() {
+	if (!CosmosType) {
+		const module$1 = await import("@bangjelkoski/ledgerhq-hw-app-cosmos");
+		CosmosType = module$1.Cosmos ? module$1.Cosmos : module$1.default.Cosmos;
+	}
+	return CosmosType;
+}
+async function loadLedgerServiceType() {
+	if (!ledgerServiceType) {
+		const module$1 = await import("@bangjelkoski/ledgerhq-hw-app-eth");
+		ledgerServiceType = module$1.ledgerService || module$1.default.ledgerService;
+	}
+	return ledgerServiceType;
+}
+async function loadTransportWebUSB() {
+	if (!TransportWebUSB) {
+		const module$1 = await import("@bangjelkoski/ledgerhq-hw-transport-webusb");
+		TransportWebUSB = module$1.TransportWebUSB || module$1.default.TransportWebUSB;
+	}
+	return TransportWebUSB;
+}
+async function loadTransportWebHIDType() {
+	if (!TransportWebHID) {
+		const module$1 = await import("@bangjelkoski/ledgerhq-hw-transport-webhid");
+		TransportWebHID = module$1.TransportWebHID || module$1.default.TransportWebHID;
+	}
+	return TransportWebHID;
+}
+
+//#endregion
+//#region src/strategy/Ledger/hw/index.ts
+var LedgerTransport$1 = class LedgerTransport$1 {
+	constructor() {
+		_defineProperty(this, "ledger", null);
+		_defineProperty(this, "accountManager", null);
+	}
+	static async getTransport() {
+		const TransportWebUSB$1 = await loadTransportWebUSB();
+		const TransportWebHID$1 = await loadTransportWebHIDType();
+		try {
+			if (await TransportWebHID$1.isSupported()) {
+				const list = await TransportWebHID$1.list();
+				if (list.length > 0 && list[0].opened) return new TransportWebHID$1(list[0]);
+				const existing = await TransportWebHID$1.openConnected().catch(() => null);
+				if (existing) return existing;
+				return await TransportWebHID$1.request();
+			}
+			if (await TransportWebUSB$1.isSupported()) {
+				const existing = await TransportWebUSB$1.openConnected().catch(() => null);
+				if (existing) return existing;
+				return await TransportWebUSB$1.request();
+			}
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerException(new Error(e.message));
+		}
+		return TransportWebUSB$1.request();
+	}
+	async getInstance() {
+		const EthereumApp = await loadEthType();
+		if (!this.ledger) {
+			const transport = await LedgerTransport$1.getTransport();
+			this.ledger = new EthereumApp(transport);
+			transport.on("disconnect", () => {
+				this.ledger = null;
+				this.accountManager = null;
+			});
+		}
+		return this.ledger;
+	}
+	async getAccountManager() {
+		if (!this.accountManager) this.accountManager = new AccountManager$1(await this.getInstance());
+		return this.accountManager;
+	}
+	async refresh() {
+		if (!this.ledger) return new LedgerTransport$1();
+		this.ledger.transport.close();
+		return new LedgerTransport$1();
+	}
+};
+
+//#endregion
+//#region src/strategy/Ledger/utils.ts
+/**
+* Used mainly for Ledger Nano S
+*/
+const domainHash = (message) => {
+	return (0, viem.hashDomain)({
+		domain: message.domain,
+		types: message.types
+	});
+};
+const messageHash = (message) => {
+	return (0, viem.hashStruct)({
+		data: message.message,
+		types: message.types,
+		primaryType: message.primaryType
+	});
+};
+
+//#endregion
+//#region src/strategy/Ledger/Eip1193Provider.ts
+var LedgerEip1193Provider = class {
+	constructor(ledger, params) {
+		_defineProperty(this, "ledger", void 0);
+		_defineProperty(this, "derivationPath", void 0);
+		_defineProperty(this, "address", void 0);
+		_defineProperty(this, "chainId", void 0);
+		this.ledger = ledger;
+		this.derivationPath = "m/44'/60'/0'/0/0";
+		this.chainId = parseInt(params.chainId || "1");
+	}
+	async getClient() {
+		const chain = (0, viem.extractChain)({
+			id: this.chainId,
+			chains: Object.values(viem_chains)
+		});
+		return (0, viem.createWalletClient)({
+			transport: (0, viem.http)(),
+			chain,
+			account: await this.getAddress()
+		});
+	}
+	async setChainId(chainId) {
+		this.chainId = parseInt(chainId.replace("0x", ""), 16);
+	}
+	async getAddress() {
+		if (!this.address) {
+			const { address } = await (await this.ledger.getInstance()).getAddress(this.derivationPath);
+			this.address = address;
+		}
+		return this.address;
+	}
+	async signTypedData(data) {
+		const result = await (await this.ledger.getInstance()).signEIP712Message(this.derivationPath, JSON.parse(data));
+		const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+		return combined.startsWith("0x") ? combined : `0x${combined}`;
+	}
+	async signTransaction(txData) {
+		const ledgerInstance = await this.ledger.getInstance();
+		const serializedTransaction = (0, viem.serializeTransaction)(txData);
+		const resolution = await (await loadLedgerServiceType()).resolveTransaction(serializedTransaction.substring(2), {}, {});
+		const signature = await ledgerInstance.signTransaction(this.derivationPath, serializedTransaction.substring(2), resolution);
+		return (0, viem.serializeTransaction)(txData, {
+			r: signature.r,
+			s: signature.s,
+			v: BigInt(signature.v)
+		});
+	}
+	async signMessage(messageHex) {
+		const result = await (await this.ledger.getInstance()).signPersonalMessage(this.derivationPath, messageHex);
+		const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+		return combined.startsWith("0x") ? combined : `0x${combined}`;
+	}
+	getChain() {
+		return (0, viem.extractChain)({
+			id: this.chainId,
+			chains: Object.values(viem_chains)
+		});
+	}
+	async request(args) {
+		if (args.method === "eth_requestAccounts") return [await this.getAddress()];
+		if (args.method === "eth_sign") {
+			if (!args.params[0]) throw new Error("Missing parameter for eth_sign");
+			return this.signMessage(args.params[0]);
+		}
+		if (args.method === "eth_signTransaction") {
+			if (!args.params[0]) throw new Error("Missing parameter for eth_signTransaction");
+			return this.signTransaction(args.params[0]);
+		}
+		if (args.method === "eth_signTypedData") {
+			if (!args.params[0]) throw new Error("Missing parameter for eth_signTypedData");
+			return this.signTypedData(args.params[0]);
+		}
+		if (args.method === "eth_chainId") return `0x${this.chainId.toString(16)}`;
+		if (args.method === "wallet_switchEthereumChain") {
+			var _args$params$;
+			return this.setChainId(((_args$params$ = args.params[0]) === null || _args$params$ === void 0 ? void 0 : _args$params$.chainId) || "0x1");
+		}
+		if (args.method === "eth_estimateGas") {
+			const client = (0, viem.createPublicClient)({
+				chain: this.getChain(),
+				transport: (0, viem.http)()
+			});
+			const data = {
+				to: args.params[0].to,
+				value: args.params[0].value,
+				data: args.params[0].data,
+				account: await this.getAddress()
+			};
+			return `0x${(await client.estimateGas(data)).toString(16)}`;
+		}
+		if (args.method === "eth_getTransactionCount") {
+			if (!args.params) throw new Error("params is required");
+			return `0x${(await (0, viem.createPublicClient)({
+				chain: this.getChain(),
+				transport: (0, viem.http)()
+			}).getTransactionCount({
+				address: await this.getAddress(),
+				blockTag: "pending"
+			})).toString(16)}`;
+		}
+		if (args.method === "eth_sendTransaction") {
+			const address = await this.getAddress();
+			const walletClient = (0, viem.createWalletClient)({
+				transport: (0, viem.http)(),
+				chain: this.getChain(),
+				account: address
+			});
+			const preparedTransaction = await walletClient.prepareTransactionRequest({ ...args.params[0] });
+			const signedTransaction = await this.signTransaction(preparedTransaction);
+			return await walletClient.sendRawTransaction({ serializedTransaction: signedTransaction });
+		}
+		return (await this.getClient()).request({
+			method: args.method,
+			params: args.params
+		});
+	}
+	on(_event, _listener) {
+		throw new Error("Method not implemented.");
+	}
+	once(_event, _listener) {
+		throw new Error("Method not implemented.");
+	}
+	removeListener(_event, _listener) {
+		throw new Error("Method not implemented.");
+	}
+	off(_event, _listener) {
+		throw new Error("Method not implemented.");
+	}
+};
+
+//#endregion
+//#region src/strategy/Ledger/Base.ts
+var LedgerBase = class extends __injectivelabs_wallet_base.BaseConcreteStrategy {
+	constructor(args) {
+		super(args);
+		_defineProperty(this, "baseDerivationPath", void 0);
+		_defineProperty(this, "derivationPathType", void 0);
+		_defineProperty(this, "ledger", void 0);
+		_defineProperty(this, "evmOptions", void 0);
+		_defineProperty(this, "alchemy", void 0);
+		this.baseDerivationPath = __injectivelabs_wallet_base.DEFAULT_BASE_DERIVATION_PATH;
+		this.derivationPathType = args.derivationPathType;
+		this.ledger = new LedgerTransport$1();
+		this.evmOptions = args.evmOptions;
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(__injectivelabs_wallet_base.WalletDeviceType.Hardware);
+	}
+	async enable() {
+		return Promise.resolve(true);
+	}
+	async disconnect() {
+		this.ledger = await this.ledger.refresh();
+	}
+	async getAddresses() {
+		const { baseDerivationPath, derivationPathType } = this;
+		try {
+			return (await (await this.ledger.getAccountManager()).getWallets(baseDerivationPath, derivationPathType)).map((k) => k.address);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async getSessionOrConfirm(address) {
+		return Promise.resolve(`0x${(0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.stringToUint8Array)(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+	}
+	async sendEvmTransaction(txData, args) {
+		const signedTransaction = await this.signEvmTransaction(txData, args);
+		try {
+			return await (await (await this.getAlchemy(args.evmChainId)).config.getProvider()).send("eth_sendRawTransaction", [signedTransaction]);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SendEvmTransaction
+			});
+		}
+	}
+	async sendTransaction(transaction, options) {
+		const { endpoints, txTimeout } = options;
+		if (!endpoints) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You have to pass endpoints.grpc within the options for using Ethereum native wallets"));
+		const response = await new __injectivelabs_sdk_ts.TxGrpcApi(endpoints.grpc).broadcast(transaction, { txTimeout });
+		if (response.code !== 0) throw new __injectivelabs_exceptions.TransactionException(new Error(response.rawLog), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			contextCode: response.code,
+			contextModule: response.codespace
+		});
+		return response;
+	}
+	async signEip712TypedData(eip712json, address) {
+		const { derivationPath } = await this.getWalletForAddress(address);
+		const object = JSON.parse(eip712json);
+		try {
+			const result = await (await this.ledger.getInstance()).signEIP712Message(derivationPath, object);
+			const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+			return combined.startsWith("0x") ? combined : `0x${combined}`;
+		} catch (e) {
+			const errorMessage = e.message;
+			if (!(errorMessage.includes("instruction not supported") || errorMessage.includes("invalid status") || errorMessage.includes("not supported") || errorMessage.includes("INS_NOT_SUPPORTED"))) throw new __injectivelabs_exceptions.LedgerException(new Error(errorMessage), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+			});
+			try {
+				const result = await (await this.ledger.getInstance()).signEIP712HashedMessage(derivationPath, domainHash(object), messageHash(object));
+				const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+				return combined.startsWith("0x") ? combined : `0x${combined}`;
+			} catch (e$1) {
+				throw new __injectivelabs_exceptions.LedgerException(new Error(e$1.message), {
+					code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+					type: __injectivelabs_exceptions.ErrorType.WalletError,
+					contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+				});
+			}
+		}
+	}
+	async signAminoCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SendTransaction
+		});
+	}
+	async signCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("This wallet does not support signing Cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			type: __injectivelabs_exceptions.ErrorType.WalletError,
+			contextModule: __injectivelabs_wallet_base.WalletAction.SendTransaction
+		});
+	}
+	async signArbitrary(signer, data) {
+		try {
+			const { derivationPath } = await this.getWalletForAddress(signer);
+			const result = await (await this.ledger.getInstance()).signPersonalMessage(derivationPath, (0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.stringToUint8Array)((0, __injectivelabs_sdk_ts.toUtf8)(data))));
+			const combined = `${result.r}${result.s}${result.v.toString(16)}`;
+			return combined.startsWith("0x") ? combined : `0x${combined}`;
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+			});
+		}
+	}
+	async getEthereumChainId() {
+		return (await (await this.getAlchemy()).config.getProvider()).network.chainId.toString();
+	}
+	async getEvmTransactionReceipt(txHash, evmChainId) {
+		const provider = await (await this.getAlchemy(evmChainId)).config.getProvider();
+		const interval = 3e3;
+		const maxAttempts = 10;
+		let attempts = 0;
+		while (attempts < maxAttempts) {
+			attempts++;
+			await sleep(interval);
+			try {
+				if (await provider.send("eth_getTransactionReceipt", [txHash])) return txHash;
+			} catch (_unused) {}
+		}
+		throw new Error(`Failed to retrieve transaction receipt for txHash: ${txHash}`);
+	}
+	async getPubKey() {
+		throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You can only fetch PubKey from Cosmos native wallets"));
+	}
+	async signEvmTransaction(txData, args) {
+		const ledgerService = await loadLedgerServiceType();
+		const alchemy = await this.getAlchemy(args.evmChainId);
+		const chainId = parseInt(args.evmChainId.toString(), 10);
+		const nonce = await alchemy.core.getTransactionCount(args.address);
+		const parseHexValue = (value) => {
+			if (typeof value === "string") {
+				const hexValue = value.startsWith("0x") ? value : `0x${value}`;
+				return BigInt(hexValue);
+			}
+			return BigInt(value);
+		};
+		const eip1559TxData = {
+			type: "eip1559",
+			chainId,
+			nonce,
+			to: txData.to,
+			value: parseHexValue(txData.value || "0x0"),
+			data: txData.data,
+			gas: parseHexValue(txData.gas),
+			maxFeePerGas: parseHexValue(txData.maxFeePerGas),
+			maxPriorityFeePerGas: parseHexValue(txData.maxPriorityFeePerGas)
+		};
+		const serializedTxHex = (0, viem.serializeTransaction)(eip1559TxData).slice(2);
+		try {
+			const ledger = await this.ledger.getInstance();
+			const { derivationPath } = await this.getWalletForAddress(args.address);
+			const resolution = await ledgerService.resolveTransaction(serializedTxHex, {}, {});
+			const txSig = await ledger.signTransaction(derivationPath, serializedTxHex, resolution);
+			return (0, viem.serializeTransaction)({
+				...eip1559TxData,
+				v: BigInt(`0x${txSig.v}`),
+				r: `0x${txSig.r}`,
+				s: `0x${txSig.s}`
+			});
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignEvmTransaction
+			});
+		}
+	}
+	async getWalletForAddress(address) {
+		try {
+			const { baseDerivationPath, derivationPathType } = this;
+			const accountManager = await this.ledger.getAccountManager();
+			if (!accountManager.hasWalletForAddress(address)) for (let i = 0; i < __injectivelabs_wallet_base.DEFAULT_ADDRESS_SEARCH_LIMIT / __injectivelabs_wallet_base.DEFAULT_NUM_ADDRESSES_TO_FETCH; i += 1) {
+				await accountManager.getWallets(baseDerivationPath, derivationPathType);
+				if (accountManager.hasWalletForAddress(address)) return await accountManager.getWalletForAddress(address);
+			}
+			return await accountManager.getWalletForAddress(address);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async getEip1193Provider() {
+		return new LedgerEip1193Provider(this.ledger, {
+			chainId: this.evmOptions.evmChainId.toString(),
+			derivationPath: this.baseDerivationPath
+		});
+	}
+	async getAlchemy(evmChainId) {
+		var _options$rpcUrls;
+		if (this.alchemy) return this.alchemy;
+		const options = this.evmOptions;
+		const chainId = evmChainId || options.evmChainId;
+		const url = options.rpcUrl || ((_options$rpcUrls = options.rpcUrls) === null || _options$rpcUrls === void 0 ? void 0 : _options$rpcUrls[chainId]);
+		if (!url) throw new __injectivelabs_exceptions.GeneralException(/* @__PURE__ */ new Error("Please pass rpcUrl within the evmOptions"));
+		this.alchemy = new alchemy_sdk.Alchemy({
+			apiKey: (0, __injectivelabs_wallet_base.getKeyFromRpcUrl)(url),
+			network: chainId === __injectivelabs_ts_types.EvmChainId.Mainnet ? alchemy_sdk.Network.ETH_MAINNET : alchemy_sdk.Network.ETH_SEPOLIA
+		});
+		return this.alchemy;
+	}
+};
+
+//#endregion
+//#region src/strategy/Ledger/LedgerLive.ts
+var LedgerLive = class extends LedgerBase {
+	constructor(args) {
+		super({
+			...args,
+			derivationPathType: LedgerDerivationPathType.LedgerLive
+		});
+	}
+};
+
+//#endregion
+//#region src/strategy/LedgerCosmos/hw/AccountManager.ts
+var AccountManager = class {
+	constructor(ledger) {
+		_defineProperty(this, "wallets", []);
+		_defineProperty(this, "ledger", void 0);
+		_defineProperty(this, "getLedgerDerivationPathBasedOnType", ({ fullBaseDerivationPath, index }) => {
+			return `${fullBaseDerivationPath}/${index}'/0/0`;
+		});
+		this.ledger = ledger;
+		this.wallets = [];
+	}
+	async getWallets(baseDerivationPath) {
+		const { start, end } = this.getOffset();
+		/**
+		* 1. Wallets are not yet fetched at all,
+		* 2. Wallets are not yet fetched for that offset
+		*/
+		if (!this.hasWallets() || !this.hasWalletsInOffset(start)) await this.getWalletsBasedOnIndex({
+			start,
+			end,
+			baseDerivationPath
+		});
+		return this.wallets.slice(start, end);
+	}
+	async getWalletsBasedOnIndex({ start, end, baseDerivationPath }) {
+		for (let index = start; index < end; index += 1) {
+			const path = this.getLedgerDerivationPathBasedOnType({
+				fullBaseDerivationPath: baseDerivationPath,
+				index
+			});
+			const { address, publicKey } = await this.ledger.getAddress(path, "inj");
+			this.wallets.push({
+				publicKey,
+				baseDerivationPath,
+				address: address.toLowerCase(),
+				derivationPath: path
+			});
+		}
+	}
+	hasWallets() {
+		return this.wallets.length > 0;
+	}
+	hasWalletsInOffset(offset) {
+		return this.wallets.length > offset;
+	}
+	getOffset() {
+		const totalWallets = this.wallets.length;
+		return {
+			start: totalWallets,
+			end: totalWallets + __injectivelabs_wallet_base.DEFAULT_NUM_ADDRESSES_TO_FETCH
+		};
+	}
+	hasWalletForAddress(address) {
+		return this.wallets.find((wallet) => wallet.address.toLowerCase() === address.toLowerCase()) !== void 0;
+	}
+	async getWalletForAddress(address) {
+		return this.wallets.find((wallet) => wallet.address.toLowerCase() === address.toLowerCase());
+	}
+	reset() {
+		this.wallets = [];
+	}
+};
+
+//#endregion
+//#region src/strategy/LedgerCosmos/hw/index.ts
+var LedgerTransport = class LedgerTransport {
+	constructor() {
+		_defineProperty(this, "ledger", null);
+		_defineProperty(this, "accountManager", null);
+	}
+	static async getTransport() {
+		const TransportWebUSB$1 = await loadTransportWebUSB();
+		const TransportWebHID$1 = await loadTransportWebHIDType();
+		try {
+			if (await TransportWebHID$1.isSupported()) return await TransportWebHID$1.create();
+			if (await TransportWebUSB$1.isSupported()) return await TransportWebHID$1.create();
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerCosmosException(new Error(e.message));
+		}
+		return await TransportWebHID$1.create();
+	}
+	async getInstance() {
+		const CosmosApp = await loadCosmosType();
+		if (!this.ledger) this.ledger = new CosmosApp(await LedgerTransport.getTransport());
+		return this.ledger;
+	}
+	async getAccountManager() {
+		if (!this.accountManager) this.accountManager = new AccountManager(await this.getInstance());
+		return this.accountManager;
+	}
+	async refresh() {
+		if (!this.ledger) return new LedgerTransport();
+		this.ledger.transport.close();
+		return new LedgerTransport();
+	}
+};
+
+//#endregion
+//#region src/strategy/LedgerCosmos/index.ts
+var LedgerCosmos = class extends __injectivelabs_wallet_base.BaseConcreteStrategy {
+	constructor(args) {
+		super(args);
+		_defineProperty(this, "baseDerivationPath", void 0);
+		_defineProperty(this, "ledger", void 0);
+		this.baseDerivationPath = __injectivelabs_wallet_base.DEFAULT_BASE_DERIVATION_PATH;
+		this.ledger = new LedgerTransport();
+	}
+	async getWalletDeviceType() {
+		return Promise.resolve(__injectivelabs_wallet_base.WalletDeviceType.Hardware);
+	}
+	async enable() {
+		return Promise.resolve(true);
+	}
+	async disconnect() {
+		this.ledger = await this.ledger.refresh();
+	}
+	async getAddresses() {
+		const { baseDerivationPath } = this;
+		try {
+			return (await (await this.ledger.getAccountManager()).getWallets(baseDerivationPath)).map((k) => k.address);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerCosmosException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+	async getSessionOrConfirm(address) {
+		return Promise.resolve(`0x${(0, __injectivelabs_sdk_ts.uint8ArrayToHex)((0, __injectivelabs_sdk_ts.stringToUint8Array)(`Confirmation for ${address} at time: ${Date.now()}`))}`);
+	}
+	async sendEvmTransaction(_txData, _options) {
+		throw new __injectivelabs_exceptions.CosmosWalletException(/* @__PURE__ */ new Error("sendEvmTransaction is not supported. LedgerCosmos only supports sending cosmos transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			context: __injectivelabs_wallet_base.WalletAction.SendEvmTransaction
+		});
+	}
+	async sendTransaction(transaction, options) {
+		const { endpoints, txTimeout } = options;
+		if (!endpoints) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You have to pass endpoints.grpc within the options for using LedgerCosmos wallet"));
+		const response = await new __injectivelabs_sdk_ts.TxGrpcApi(endpoints.grpc).broadcast(transaction, { txTimeout });
+		if (response.code !== 0) throw new __injectivelabs_exceptions.TransactionException(new Error(response.rawLog), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			contextCode: response.code,
+			contextModule: response.codespace
+		});
+		return response;
+	}
+	async signAminoCosmosTransaction(transaction) {
+		try {
+			const { derivationPath } = await this.getWalletForAddress(transaction.address);
+			return {
+				signed: void 0,
+				signature: {
+					signature: (0, __injectivelabs_sdk_ts.uint8ArrayToBase64)((await (await this.ledger.getInstance()).sign(derivationPath, JSON.stringify((0, __injectivelabs_sdk_ts.sortObjectByKeys)(transaction.signDoc)))).signature),
+					pub_key: void 0
+				}
+			};
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerCosmosException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+			});
+		}
+	}
+	async signCosmosTransaction(_transaction) {
+		throw new __injectivelabs_exceptions.CosmosWalletException(/* @__PURE__ */ new Error("This wallet does not support signing using direct sign"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			context: __injectivelabs_wallet_base.WalletAction.SendTransaction
+		});
+	}
+	async signEip712TypedData(_eip712Json, _address) {
+		throw new __injectivelabs_exceptions.CosmosWalletException(/* @__PURE__ */ new Error("This wallet does not support signing Evm transactions"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			context: __injectivelabs_wallet_base.WalletAction.SendTransaction
+		});
+	}
+	async signArbitrary(signer, data) {
+		try {
+			const { derivationPath } = await this.getWalletForAddress(signer);
+			return (0, __injectivelabs_sdk_ts.uint8ArrayToBase64)((await (await this.ledger.getInstance()).sign(derivationPath, (0, __injectivelabs_sdk_ts.toUtf8)(data))).signature);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerCosmosException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.SignTransaction
+			});
+		}
+	}
+	async getEthereumChainId() {
+		throw new __injectivelabs_exceptions.CosmosWalletException(/* @__PURE__ */ new Error("getEthereumChainId is not supported on Keplr"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			context: __injectivelabs_wallet_base.WalletAction.GetChainId
+		});
+	}
+	async getEvmTransactionReceipt(_txHash) {
+		throw new __injectivelabs_exceptions.CosmosWalletException(/* @__PURE__ */ new Error("getEvmTransactionReceipt is not supported on Keplr"), {
+			code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+			context: __injectivelabs_wallet_base.WalletAction.GetEvmTransactionReceipt
+		});
+	}
+	async getPubKey(address) {
+		if (!address) throw new __injectivelabs_exceptions.WalletException(/* @__PURE__ */ new Error("You can only fetch PubKey corresponding to an address"));
+		return (0, __injectivelabs_sdk_ts.uint8ArrayToBase64)((0, __injectivelabs_sdk_ts.hexToUint8Array)((await this.getWalletForAddress(address)).publicKey || ""));
+	}
+	async getWalletForAddress(address) {
+		try {
+			const { baseDerivationPath } = this;
+			const accountManager = await this.ledger.getAccountManager();
+			if (!accountManager.hasWalletForAddress(address)) for (let i = 0; i < __injectivelabs_wallet_base.DEFAULT_ADDRESS_SEARCH_LIMIT / __injectivelabs_wallet_base.DEFAULT_NUM_ADDRESSES_TO_FETCH; i += 1) {
+				await accountManager.getWallets(baseDerivationPath);
+				if (accountManager.hasWalletForAddress(address)) return await accountManager.getWalletForAddress(address);
+			}
+			return await accountManager.getWalletForAddress(address);
+		} catch (e) {
+			throw new __injectivelabs_exceptions.LedgerCosmosException(new Error(e.message), {
+				code: __injectivelabs_exceptions.UnspecifiedErrorCode,
+				type: __injectivelabs_exceptions.ErrorType.WalletError,
+				contextModule: __injectivelabs_wallet_base.WalletAction.GetAccounts
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/strategy/Ledger/LedgerLegacy.ts
+var LedgerLegacy = class extends LedgerBase {
+	constructor(args) {
+		super({
+			...args,
+			derivationPathType: LedgerDerivationPathType.LedgerMew
+		});
+	}
+};
+
+//#endregion
+exports.LedgerCosmosStrategy = LedgerCosmos;
+exports.LedgerDerivationPathType = LedgerDerivationPathType;
+exports.LedgerLegacyStrategy = LedgerLegacy;
+exports.LedgerLiveStrategy = LedgerLive;
+exports.WalletLedger = WalletLedger;