@t2000/sdk 0.37.0 → 0.37.1

package/dist/adapters/index.cjs

@@ -1,7 +1,413 @@
 'use strict';
 
 var transactions = require('@mysten/sui/transactions');
-var lending = require('@naviprotocol/lending');
+var jsonRpc = require('@mysten/sui/jsonRpc');
+var utils = require('@mysten/sui/utils');
+var pythSuiJs = require('@pythnetwork/pyth-sui-js');
+var bcs$1 = require('@mysten/sui/bcs');
+
+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 __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
+  get: (a, b2) => (typeof require !== "undefined" ? require : a)[b2]
+}) : x2)(function(x2) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x2 + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  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 (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/lodash.camelcase@4.3.0/node_modules/lodash.camelcase/index.js
+var require_lodash = __commonJS({
+  "../../node_modules/.pnpm/lodash.camelcase@4.3.0/node_modules/lodash.camelcase/index.js"(exports$1, module) {
+    var symbolTag = "[object Symbol]";
+    var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+    var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+    var rsAstralRange = "\\ud800-\\udfff";
+    var rsComboMarksRange = "\\u0300-\\u036f\\ufe20-\\ufe23";
+    var rsComboSymbolsRange = "\\u20d0-\\u20f0";
+    var rsDingbatRange = "\\u2700-\\u27bf";
+    var rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff";
+    var rsMathOpRange = "\\xac\\xb1\\xd7\\xf7";
+    var rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf";
+    var rsPunctuationRange = "\\u2000-\\u206f";
+    var rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
+    var rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde";
+    var rsVarRange = "\\ufe0e\\ufe0f";
+    var rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+    var rsApos = "['\u2019]";
+    var rsAstral = "[" + rsAstralRange + "]";
+    var rsBreak = "[" + rsBreakRange + "]";
+    var rsCombo = "[" + rsComboMarksRange + rsComboSymbolsRange + "]";
+    var rsDigits = "\\d+";
+    var rsDingbat = "[" + rsDingbatRange + "]";
+    var rsLower = "[" + rsLowerRange + "]";
+    var rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]";
+    var rsFitz = "\\ud83c[\\udffb-\\udfff]";
+    var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
+    var rsNonAstral = "[^" + rsAstralRange + "]";
+    var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
+    var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
+    var rsUpper = "[" + rsUpperRange + "]";
+    var rsZWJ = "\\u200d";
+    var rsLowerMisc = "(?:" + rsLower + "|" + rsMisc + ")";
+    var rsUpperMisc = "(?:" + rsUpper + "|" + rsMisc + ")";
+    var rsOptLowerContr = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?";
+    var rsOptUpperContr = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?";
+    var reOptMod = rsModifier + "?";
+    var rsOptVar = "[" + rsVarRange + "]?";
+    var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
+    var rsSeq = rsOptVar + reOptMod + rsOptJoin;
+    var rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq;
+    var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
+    var reApos = RegExp(rsApos, "g");
+    var reComboMark = RegExp(rsCombo, "g");
+    var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+    var reUnicodeWord = RegExp([
+      rsUpper + "?" + rsLower + "+" + rsOptLowerContr + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
+      rsUpperMisc + "+" + rsOptUpperContr + "(?=" + [rsBreak, rsUpper + rsLowerMisc, "$"].join("|") + ")",
+      rsUpper + "?" + rsLowerMisc + "+" + rsOptLowerContr,
+      rsUpper + "+" + rsOptUpperContr,
+      rsDigits,
+      rsEmoji
+    ].join("|"), "g");
+    var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + "]");
+    var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+    var deburredLetters = {
+      // Latin-1 Supplement block.
+      "\xC0": "A",
+      "\xC1": "A",
+      "\xC2": "A",
+      "\xC3": "A",
+      "\xC4": "A",
+      "\xC5": "A",
+      "\xE0": "a",
+      "\xE1": "a",
+      "\xE2": "a",
+      "\xE3": "a",
+      "\xE4": "a",
+      "\xE5": "a",
+      "\xC7": "C",
+      "\xE7": "c",
+      "\xD0": "D",
+      "\xF0": "d",
+      "\xC8": "E",
+      "\xC9": "E",
+      "\xCA": "E",
+      "\xCB": "E",
+      "\xE8": "e",
+      "\xE9": "e",
+      "\xEA": "e",
+      "\xEB": "e",
+      "\xCC": "I",
+      "\xCD": "I",
+      "\xCE": "I",
+      "\xCF": "I",
+      "\xEC": "i",
+      "\xED": "i",
+      "\xEE": "i",
+      "\xEF": "i",
+      "\xD1": "N",
+      "\xF1": "n",
+      "\xD2": "O",
+      "\xD3": "O",
+      "\xD4": "O",
+      "\xD5": "O",
+      "\xD6": "O",
+      "\xD8": "O",
+      "\xF2": "o",
+      "\xF3": "o",
+      "\xF4": "o",
+      "\xF5": "o",
+      "\xF6": "o",
+      "\xF8": "o",
+      "\xD9": "U",
+      "\xDA": "U",
+      "\xDB": "U",
+      "\xDC": "U",
+      "\xF9": "u",
+      "\xFA": "u",
+      "\xFB": "u",
+      "\xFC": "u",
+      "\xDD": "Y",
+      "\xFD": "y",
+      "\xFF": "y",
+      "\xC6": "Ae",
+      "\xE6": "ae",
+      "\xDE": "Th",
+      "\xFE": "th",
+      "\xDF": "ss",
+      // Latin Extended-A block.
+      "\u0100": "A",
+      "\u0102": "A",
+      "\u0104": "A",
+      "\u0101": "a",
+      "\u0103": "a",
+      "\u0105": "a",
+      "\u0106": "C",
+      "\u0108": "C",
+      "\u010A": "C",
+      "\u010C": "C",
+      "\u0107": "c",
+      "\u0109": "c",
+      "\u010B": "c",
+      "\u010D": "c",
+      "\u010E": "D",
+      "\u0110": "D",
+      "\u010F": "d",
+      "\u0111": "d",
+      "\u0112": "E",
+      "\u0114": "E",
+      "\u0116": "E",
+      "\u0118": "E",
+      "\u011A": "E",
+      "\u0113": "e",
+      "\u0115": "e",
+      "\u0117": "e",
+      "\u0119": "e",
+      "\u011B": "e",
+      "\u011C": "G",
+      "\u011E": "G",
+      "\u0120": "G",
+      "\u0122": "G",
+      "\u011D": "g",
+      "\u011F": "g",
+      "\u0121": "g",
+      "\u0123": "g",
+      "\u0124": "H",
+      "\u0126": "H",
+      "\u0125": "h",
+      "\u0127": "h",
+      "\u0128": "I",
+      "\u012A": "I",
+      "\u012C": "I",
+      "\u012E": "I",
+      "\u0130": "I",
+      "\u0129": "i",
+      "\u012B": "i",
+      "\u012D": "i",
+      "\u012F": "i",
+      "\u0131": "i",
+      "\u0134": "J",
+      "\u0135": "j",
+      "\u0136": "K",
+      "\u0137": "k",
+      "\u0138": "k",
+      "\u0139": "L",
+      "\u013B": "L",
+      "\u013D": "L",
+      "\u013F": "L",
+      "\u0141": "L",
+      "\u013A": "l",
+      "\u013C": "l",
+      "\u013E": "l",
+      "\u0140": "l",
+      "\u0142": "l",
+      "\u0143": "N",
+      "\u0145": "N",
+      "\u0147": "N",
+      "\u014A": "N",
+      "\u0144": "n",
+      "\u0146": "n",
+      "\u0148": "n",
+      "\u014B": "n",
+      "\u014C": "O",
+      "\u014E": "O",
+      "\u0150": "O",
+      "\u014D": "o",
+      "\u014F": "o",
+      "\u0151": "o",
+      "\u0154": "R",
+      "\u0156": "R",
+      "\u0158": "R",
+      "\u0155": "r",
+      "\u0157": "r",
+      "\u0159": "r",
+      "\u015A": "S",
+      "\u015C": "S",
+      "\u015E": "S",
+      "\u0160": "S",
+      "\u015B": "s",
+      "\u015D": "s",
+      "\u015F": "s",
+      "\u0161": "s",
+      "\u0162": "T",
+      "\u0164": "T",
+      "\u0166": "T",
+      "\u0163": "t",
+      "\u0165": "t",
+      "\u0167": "t",
+      "\u0168": "U",
+      "\u016A": "U",
+      "\u016C": "U",
+      "\u016E": "U",
+      "\u0170": "U",
+      "\u0172": "U",
+      "\u0169": "u",
+      "\u016B": "u",
+      "\u016D": "u",
+      "\u016F": "u",
+      "\u0171": "u",
+      "\u0173": "u",
+      "\u0174": "W",
+      "\u0175": "w",
+      "\u0176": "Y",
+      "\u0177": "y",
+      "\u0178": "Y",
+      "\u0179": "Z",
+      "\u017B": "Z",
+      "\u017D": "Z",
+      "\u017A": "z",
+      "\u017C": "z",
+      "\u017E": "z",
+      "\u0132": "IJ",
+      "\u0133": "ij",
+      "\u0152": "Oe",
+      "\u0153": "oe",
+      "\u0149": "'n",
+      "\u017F": "ss"
+    };
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    function arrayReduce(array, iteratee, accumulator, initAccum) {
+      var index = -1, length = array ? array.length : 0;
+      while (++index < length) {
+        accumulator = iteratee(accumulator, array[index], index, array);
+      }
+      return accumulator;
+    }
+    function asciiToArray(string) {
+      return string.split("");
+    }
+    function asciiWords(string) {
+      return string.match(reAsciiWord) || [];
+    }
+    function basePropertyOf(object) {
+      return function(key) {
+        return object == null ? void 0 : object[key];
+      };
+    }
+    var deburrLetter = basePropertyOf(deburredLetters);
+    function hasUnicode(string) {
+      return reHasUnicode.test(string);
+    }
+    function hasUnicodeWord(string) {
+      return reHasUnicodeWord.test(string);
+    }
+    function stringToArray(string) {
+      return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
+    }
+    function unicodeToArray(string) {
+      return string.match(reUnicode) || [];
+    }
+    function unicodeWords(string) {
+      return string.match(reUnicodeWord) || [];
+    }
+    var objectProto = Object.prototype;
+    var objectToString = objectProto.toString;
+    var Symbol2 = root.Symbol;
+    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+    var symbolToString = symbolProto ? symbolProto.toString : void 0;
+    function baseSlice(array, start, end) {
+      var index = -1, length = array.length;
+      if (start < 0) {
+        start = -start > length ? 0 : length + start;
+      }
+      end = end > length ? length : end;
+      if (end < 0) {
+        end += length;
+      }
+      length = start > end ? 0 : end - start >>> 0;
+      start >>>= 0;
+      var result = Array(length);
+      while (++index < length) {
+        result[index] = array[index + start];
+      }
+      return result;
+    }
+    function baseToString(value) {
+      if (typeof value == "string") {
+        return value;
+      }
+      if (isSymbol(value)) {
+        return symbolToString ? symbolToString.call(value) : "";
+      }
+      var result = value + "";
+      return result == "0" && 1 / value == -Infinity ? "-0" : result;
+    }
+    function castSlice(array, start, end) {
+      var length = array.length;
+      end = end === void 0 ? length : end;
+      return !start && end >= length ? array : baseSlice(array, start, end);
+    }
+    function createCaseFirst(methodName) {
+      return function(string) {
+        string = toString(string);
+        var strSymbols = hasUnicode(string) ? stringToArray(string) : void 0;
+        var chr = strSymbols ? strSymbols[0] : string.charAt(0);
+        var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
+        return chr[methodName]() + trailing;
+      };
+    }
+    function createCompounder(callback) {
+      return function(string) {
+        return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
+      };
+    }
+    function isObjectLike(value) {
+      return !!value && typeof value == "object";
+    }
+    function isSymbol(value) {
+      return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+    }
+    function toString(value) {
+      return value == null ? "" : baseToString(value);
+    }
+    var camelCase = createCompounder(function(result, word, index) {
+      word = word.toLowerCase();
+      return result + (index ? capitalize(word) : word);
+    });
+    function capitalize(string) {
+      return upperFirst(toString(string).toLowerCase());
+    }
+    function deburr(string) {
+      string = toString(string);
+      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
+    }
+    var upperFirst = createCaseFirst("toUpperCase");
+    function words(string, pattern, guard) {
+      string = toString(string);
+      pattern = pattern;
+      if (pattern === void 0) {
+        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
+      }
+      return string.match(pattern) || [];
+    }
+    module.exports = camelCase;
+  }
+});
 
 // src/errors.ts
 var T2000Error = class extends Error {
@@ -83,144 +489,3746 @@ var SUPPORTED_ASSETS = {
     symbol: "GOLD",
     displayName: "XAUM"
   }
-};
-var STABLE_ASSETS = ["USDC"];
-var ALL_NAVI_ASSETS = Object.keys(SUPPORTED_ASSETS);
-var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xd775fcc66eae26797654d435d751dea56b82eeb999de51fd285348e573b968ad";
-var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x08ba26f0d260b5edf6a19c71492b3eb914906a7419baf2df1426765157e5862a";
-var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0xf420ec0dcad44433042fb56e1413fb88d3ff65be94fcf425ef9ff750164590e8";
-process.env.T2000_API_URL ?? "https://api.t2000.ai";
-
-// src/adapters/registry.ts
-var ProtocolRegistry = class {
-  lending = /* @__PURE__ */ new Map();
-  registerLending(adapter) {
-    this.lending.set(adapter.id, adapter);
+};
+var STABLE_ASSETS = ["USDC"];
+var ALL_NAVI_ASSETS = Object.keys(SUPPORTED_ASSETS);
+var T2000_PACKAGE_ID = process.env.T2000_PACKAGE_ID ?? "0xd775fcc66eae26797654d435d751dea56b82eeb999de51fd285348e573b968ad";
+var T2000_CONFIG_ID = process.env.T2000_CONFIG_ID ?? "0x08ba26f0d260b5edf6a19c71492b3eb914906a7419baf2df1426765157e5862a";
+var T2000_TREASURY_ID = process.env.T2000_TREASURY_ID ?? "0xf420ec0dcad44433042fb56e1413fb88d3ff65be94fcf425ef9ff750164590e8";
+process.env.T2000_API_URL ?? "https://api.t2000.ai";
+
+// src/adapters/registry.ts
+var ProtocolRegistry = class {
+  lending = /* @__PURE__ */ new Map();
+  registerLending(adapter) {
+    this.lending.set(adapter.id, adapter);
+  }
+  async bestSaveRate(asset) {
+    const candidates = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      if (!adapter.capabilities.includes("save")) continue;
+      try {
+        const rate = await adapter.getRates(asset);
+        candidates.push({ adapter, rate });
+      } catch {
+      }
+    }
+    if (candidates.length === 0) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `No lending adapter supports saving ${asset}`);
+    }
+    candidates.sort((a, b2) => b2.rate.saveApy - a.rate.saveApy);
+    return candidates[0];
+  }
+  async bestBorrowRate(asset, opts) {
+    const candidates = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      if (!adapter.capabilities.includes("borrow")) continue;
+      if (opts?.requireSameAssetBorrow && !adapter.supportsSameAssetBorrow) continue;
+      try {
+        const rate = await adapter.getRates(asset);
+        candidates.push({ adapter, rate });
+      } catch {
+      }
+    }
+    if (candidates.length === 0) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `No lending adapter supports borrowing ${asset}`);
+    }
+    candidates.sort((a, b2) => a.rate.borrowApy - b2.rate.borrowApy);
+    return candidates[0];
+  }
+  async bestSaveRateAcrossAssets() {
+    const candidates = [];
+    for (const asset of STABLE_ASSETS) {
+      for (const adapter of this.lending.values()) {
+        if (!adapter.supportedAssets.includes(asset)) continue;
+        if (!adapter.capabilities.includes("save")) continue;
+        try {
+          const rate = await adapter.getRates(asset);
+          candidates.push({ adapter, rate, asset });
+        } catch {
+        }
+      }
+    }
+    if (candidates.length === 0) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", "No lending adapter found for any stablecoin");
+    }
+    candidates.sort((a, b2) => b2.rate.saveApy - a.rate.saveApy);
+    return candidates[0];
+  }
+  async allRatesAcrossAssets() {
+    const results = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const asset of STABLE_ASSETS) {
+      if (seen.has(asset)) continue;
+      seen.add(asset);
+      for (const adapter of this.lending.values()) {
+        if (!adapter.supportedAssets.includes(asset)) continue;
+        try {
+          const rates = await adapter.getRates(asset);
+          if (rates.saveApy > 0 || rates.borrowApy > 0) {
+            results.push({ protocol: adapter.name, protocolId: adapter.id, asset, rates });
+          }
+        } catch {
+        }
+      }
+    }
+    return results;
+  }
+  async allRates(asset) {
+    const results = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      try {
+        const rates = await adapter.getRates(asset);
+        results.push({ protocol: adapter.name, protocolId: adapter.id, rates });
+      } catch {
+      }
+    }
+    return results;
+  }
+  async allPositions(address) {
+    const results = [];
+    const errors = [];
+    for (const adapter of this.lending.values()) {
+      try {
+        const positions = await adapter.getPositions(address);
+        if (positions.supplies.length > 0 || positions.borrows.length > 0) {
+          results.push({ protocol: adapter.name, protocolId: adapter.id, positions });
+        }
+      } catch (err) {
+        errors.push(`${adapter.name}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (results.length === 0 && errors.length > 0) {
+      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol queries failed (${errors.length}/${this.lending.size}): ${errors.join("; ")}`);
+    }
+    return results;
+  }
+  getLending(id) {
+    return this.lending.get(id);
+  }
+  listLending() {
+    return [...this.lending.values()];
+  }
+};
+
+// src/utils/format.ts
+function stableToRaw(amount, decimals) {
+  return BigInt(Math.round(amount * 10 ** decimals));
+}
+var ASSET_LOOKUP = /* @__PURE__ */ new Map();
+for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
+  ASSET_LOOKUP.set(key.toUpperCase(), key);
+  if (info.displayName && info.displayName.toUpperCase() !== key.toUpperCase()) {
+    ASSET_LOOKUP.set(info.displayName.toUpperCase(), key);
+  }
+}
+function normalizeAsset(input) {
+  return ASSET_LOOKUP.get(input.toUpperCase()) ?? input;
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.2/node_modules/@mysten/bcs/dist/uleb.mjs
+function ulebEncode(num) {
+  let bigNum = BigInt(num);
+  const arr = [];
+  let len = 0;
+  if (bigNum === 0n) return [0];
+  while (bigNum > 0) {
+    arr[len] = Number(bigNum & 127n);
+    bigNum >>= 7n;
+    if (bigNum > 0n) arr[len] |= 128;
+    len += 1;
+  }
+  return arr;
+}
+function ulebDecode(arr) {
+  let total = 0n;
+  let shift = 0n;
+  let len = 0;
+  while (true) {
+    if (len >= arr.length) throw new Error("ULEB decode error: buffer overflow");
+    const byte = arr[len];
+    len += 1;
+    total += BigInt(byte & 127) << shift;
+    if ((byte & 128) === 0) break;
+    shift += 7n;
+  }
+  if (total > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("ULEB decode error: value exceeds MAX_SAFE_INTEGER");
+  return {
+    value: Number(total),
+    length: len
+  };
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.2/node_modules/@mysten/bcs/dist/reader.mjs
+var BcsReader = class {
+  /**
+  * @param {Uint8Array} data Data to use as a buffer.
+  */
+  constructor(data) {
+    this.bytePosition = 0;
+    this.dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  /**
+  * Shift current cursor position by `bytes`.
+  *
+  * @param {Number} bytes Number of bytes to
+  * @returns {this} Self for possible chaining.
+  */
+  shift(bytes) {
+    this.bytePosition += bytes;
+    return this;
+  }
+  /**
+  * Read U8 value from the buffer and shift cursor by 1.
+  * @returns
+  */
+  read8() {
+    const value = this.dataView.getUint8(this.bytePosition);
+    this.shift(1);
+    return value;
+  }
+  /**
+  * Read U16 value from the buffer and shift cursor by 2.
+  * @returns
+  */
+  read16() {
+    const value = this.dataView.getUint16(this.bytePosition, true);
+    this.shift(2);
+    return value;
+  }
+  /**
+  * Read U32 value from the buffer and shift cursor by 4.
+  * @returns
+  */
+  read32() {
+    const value = this.dataView.getUint32(this.bytePosition, true);
+    this.shift(4);
+    return value;
+  }
+  /**
+  * Read U64 value from the buffer and shift cursor by 8.
+  * @returns
+  */
+  read64() {
+    const value1 = this.read32();
+    const result = this.read32().toString(16) + value1.toString(16).padStart(8, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+  * Read U128 value from the buffer and shift cursor by 16.
+  */
+  read128() {
+    const value1 = BigInt(this.read64());
+    const result = BigInt(this.read64()).toString(16) + value1.toString(16).padStart(16, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+  * Read U128 value from the buffer and shift cursor by 32.
+  * @returns
+  */
+  read256() {
+    const value1 = BigInt(this.read128());
+    const result = BigInt(this.read128()).toString(16) + value1.toString(16).padStart(32, "0");
+    return BigInt("0x" + result).toString(10);
+  }
+  /**
+  * Read `num` number of bytes from the buffer and shift cursor by `num`.
+  * @param num Number of bytes to read.
+  */
+  readBytes(num) {
+    const start = this.bytePosition + this.dataView.byteOffset;
+    const value = new Uint8Array(this.dataView.buffer, start, num);
+    this.shift(num);
+    return value;
+  }
+  /**
+  * Read ULEB value - an integer of varying size. Used for enum indexes and
+  * vector lengths.
+  * @returns {Number} The ULEB value.
+  */
+  readULEB() {
+    const start = this.bytePosition + this.dataView.byteOffset;
+    const { value, length } = ulebDecode(new Uint8Array(this.dataView.buffer, start));
+    this.shift(length);
+    return value;
+  }
+  /**
+  * Read a BCS vector: read a length and then apply function `cb` X times
+  * where X is the length of the vector, defined as ULEB in BCS bytes.
+  * @param cb Callback to process elements of vector.
+  * @returns {Array<Any>} Array of the resulting values, returned by callback.
+  */
+  readVec(cb) {
+    const length = this.readULEB();
+    const result = [];
+    for (let i = 0; i < length; i++) result.push(cb(this, i, length));
+    return result;
+  }
+};
+
+// ../../node_modules/.pnpm/@scure+base@2.0.0/node_modules/@scure/base/index.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b2) => (c) => a(b2(c));
+  const encode = args.map((x2) => x2.encode).reduceRight(wrap, id);
+  const decode = args.map((x2) => x2.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+// @__NO_SIDE_EFFECTS__
+function alphabet(letters) {
+  const lettersA = letters.split("") ;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber(d);
+    if (d < 0 || d >= from)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos; i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+    res.push(0);
+  return res.reverse();
+}
+// @__NO_SIDE_EFFECTS__
+function radix(num) {
+  anumber(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join(""));
+var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+
+// ../../node_modules/.pnpm/@mysten+utils@0.3.1/node_modules/@mysten/utils/dist/b58.mjs
+var toBase58 = (buffer) => base58.encode(buffer);
+var fromBase58 = (str) => base58.decode(str);
+
+// ../../node_modules/.pnpm/@mysten+utils@0.3.1/node_modules/@mysten/utils/dist/b64.mjs
+function fromBase64(base64String) {
+  return Uint8Array.from(atob(base64String), (char) => char.charCodeAt(0));
+}
+var CHUNK_SIZE = 8192;
+function toBase64(bytes) {
+  if (bytes.length < CHUNK_SIZE) return btoa(String.fromCharCode(...bytes));
+  let output = "";
+  for (var i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.slice(i, i + CHUNK_SIZE);
+    output += String.fromCharCode(...chunk);
+  }
+  return btoa(output);
+}
+
+// ../../node_modules/.pnpm/@mysten+utils@0.3.1/node_modules/@mysten/utils/dist/hex.mjs
+function fromHex(hexStr) {
+  const normalized = hexStr.startsWith("0x") ? hexStr.slice(2) : hexStr;
+  const padded = normalized.length % 2 === 0 ? normalized : `0${normalized}`;
+  const intArr = padded.match(/[0-9a-fA-F]{2}/g)?.map((byte) => parseInt(byte, 16)) ?? [];
+  if (intArr.length !== padded.length / 2) throw new Error(`Invalid hex string ${hexStr}`);
+  return Uint8Array.from(intArr);
+}
+function toHex(bytes) {
+  return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.2/node_modules/@mysten/bcs/dist/utils.mjs
+function encodeStr(data, encoding) {
+  switch (encoding) {
+    case "base58":
+      return toBase58(data);
+    case "base64":
+      return toBase64(data);
+    case "hex":
+      return toHex(data);
+    default:
+      throw new Error("Unsupported encoding, supported values are: base64, hex");
+  }
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.2/node_modules/@mysten/bcs/dist/writer.mjs
+var BcsWriter = class {
+  constructor({ initialSize = 1024, maxSize = Infinity, allocateSize = 1024 } = {}) {
+    this.bytePosition = 0;
+    this.size = initialSize;
+    this.maxSize = maxSize;
+    this.allocateSize = allocateSize;
+    this.dataView = new DataView(new ArrayBuffer(initialSize));
+  }
+  ensureSizeOrGrow(bytes) {
+    const requiredSize = this.bytePosition + bytes;
+    if (requiredSize > this.size) {
+      const nextSize = Math.min(this.maxSize, Math.max(this.size + requiredSize, this.size + this.allocateSize));
+      if (requiredSize > nextSize) throw new Error(`Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${requiredSize}`);
+      this.size = nextSize;
+      const nextBuffer = new ArrayBuffer(this.size);
+      new Uint8Array(nextBuffer).set(new Uint8Array(this.dataView.buffer));
+      this.dataView = new DataView(nextBuffer);
+    }
+  }
+  /**
+  * Shift current cursor position by `bytes`.
+  *
+  * @param {Number} bytes Number of bytes to
+  * @returns {this} Self for possible chaining.
+  */
+  shift(bytes) {
+    this.bytePosition += bytes;
+    return this;
+  }
+  /**
+  * Write a U8 value into a buffer and shift cursor position by 1.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  write8(value) {
+    this.ensureSizeOrGrow(1);
+    this.dataView.setUint8(this.bytePosition, Number(value));
+    return this.shift(1);
+  }
+  /**
+  * Write a U8 value into a buffer and shift cursor position by 1.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  writeBytes(bytes) {
+    this.ensureSizeOrGrow(bytes.length);
+    for (let i = 0; i < bytes.length; i++) this.dataView.setUint8(this.bytePosition + i, bytes[i]);
+    return this.shift(bytes.length);
+  }
+  /**
+  * Write a U16 value into a buffer and shift cursor position by 2.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  write16(value) {
+    this.ensureSizeOrGrow(2);
+    this.dataView.setUint16(this.bytePosition, Number(value), true);
+    return this.shift(2);
+  }
+  /**
+  * Write a U32 value into a buffer and shift cursor position by 4.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  write32(value) {
+    this.ensureSizeOrGrow(4);
+    this.dataView.setUint32(this.bytePosition, Number(value), true);
+    return this.shift(4);
+  }
+  /**
+  * Write a U64 value into a buffer and shift cursor position by 8.
+  * @param {bigint} value Value to write.
+  * @returns {this}
+  */
+  write64(value) {
+    toLittleEndian(BigInt(value), 8).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+  * Write a U128 value into a buffer and shift cursor position by 16.
+  *
+  * @param {bigint} value Value to write.
+  * @returns {this}
+  */
+  write128(value) {
+    toLittleEndian(BigInt(value), 16).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+  * Write a U256 value into a buffer and shift cursor position by 16.
+  *
+  * @param {bigint} value Value to write.
+  * @returns {this}
+  */
+  write256(value) {
+    toLittleEndian(BigInt(value), 32).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+  * Write a ULEB value into a buffer and shift cursor position by number of bytes
+  * written.
+  * @param {Number} value Value to write.
+  * @returns {this}
+  */
+  writeULEB(value) {
+    ulebEncode(value).forEach((el) => this.write8(el));
+    return this;
+  }
+  /**
+  * Write a vector into a buffer by first writing the vector length and then calling
+  * a callback on each passed value.
+  *
+  * @param {Array<Any>} vector Array of elements to write.
+  * @param {WriteVecCb} cb Callback to call on each element of the vector.
+  * @returns {this}
+  */
+  writeVec(vector2, cb) {
+    this.writeULEB(vector2.length);
+    Array.from(vector2).forEach((el, i) => cb(this, el, i, vector2.length));
+    return this;
+  }
+  /**
+  * Adds support for iterations over the object.
+  * @returns {Uint8Array}
+  */
+  *[Symbol.iterator]() {
+    for (let i = 0; i < this.bytePosition; i++) yield this.dataView.getUint8(i);
+    return this.toBytes();
+  }
+  /**
+  * Get underlying buffer taking only value bytes (in case initial buffer size was bigger).
+  * @returns {Uint8Array} Resulting bcs.
+  */
+  toBytes() {
+    return new Uint8Array(this.dataView.buffer.slice(0, this.bytePosition));
+  }
+  /**
+  * Represent data as 'hex' or 'base64'
+  * @param encoding Encoding to use: 'base64' or 'hex'
+  */
+  toString(encoding) {
+    return encodeStr(this.toBytes(), encoding);
+  }
+};
+function toLittleEndian(bigint, size) {
+  const result = new Uint8Array(size);
+  let i = 0;
+  while (bigint > 0) {
+    result[i] = Number(bigint % BigInt(256));
+    bigint = bigint / BigInt(256);
+    i += 1;
+  }
+  return result;
+}
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.2/node_modules/@mysten/bcs/dist/bcs-type.mjs
+var BcsType = class BcsType2 {
+  #write;
+  #serialize;
+  constructor(options) {
+    this.name = options.name;
+    this.read = options.read;
+    this.serializedSize = options.serializedSize ?? (() => null);
+    this.#write = options.write;
+    this.#serialize = options.serialize ?? ((value, options$1) => {
+      const writer = new BcsWriter({
+        initialSize: this.serializedSize(value) ?? void 0,
+        ...options$1
+      });
+      this.#write(value, writer);
+      return writer.toBytes();
+    });
+    this.validate = options.validate ?? (() => {
+    });
+  }
+  write(value, writer) {
+    this.validate(value);
+    this.#write(value, writer);
+  }
+  serialize(value, options) {
+    this.validate(value);
+    return new SerializedBcs(this, this.#serialize(value, options));
+  }
+  parse(bytes) {
+    const reader = new BcsReader(bytes);
+    return this.read(reader);
+  }
+  fromHex(hex) {
+    return this.parse(fromHex(hex));
+  }
+  fromBase58(b64) {
+    return this.parse(fromBase58(b64));
+  }
+  fromBase64(b64) {
+    return this.parse(fromBase64(b64));
+  }
+  transform({ name, input, output, validate }) {
+    return new BcsType2({
+      name: name ?? this.name,
+      read: (reader) => output ? output(this.read(reader)) : this.read(reader),
+      write: (value, writer) => this.#write(input ? input(value) : value, writer),
+      serializedSize: (value) => this.serializedSize(input ? input(value) : value),
+      serialize: (value, options) => this.#serialize(input ? input(value) : value, options),
+      validate: (value) => {
+        validate?.(value);
+        this.validate(input ? input(value) : value);
+      }
+    });
+  }
+};
+var SERIALIZED_BCS_BRAND = /* @__PURE__ */ Symbol.for("@mysten/serialized-bcs");
+var SerializedBcs = class {
+  #schema;
+  #bytes;
+  get [SERIALIZED_BCS_BRAND]() {
+    return true;
+  }
+  constructor(schema, bytes) {
+    this.#schema = schema;
+    this.#bytes = bytes;
+  }
+  toBytes() {
+    return this.#bytes;
+  }
+  toHex() {
+    return toHex(this.#bytes);
+  }
+  toBase64() {
+    return toBase64(this.#bytes);
+  }
+  toBase58() {
+    return toBase58(this.#bytes);
+  }
+  parse() {
+    return this.#schema.parse(this.#bytes);
+  }
+};
+function fixedSizeBcsType({ size, ...options }) {
+  return new BcsType({
+    ...options,
+    serializedSize: () => size
+  });
+}
+function uIntBcsType({ readMethod, writeMethod, ...options }) {
+  return fixedSizeBcsType({
+    ...options,
+    read: (reader) => reader[readMethod](),
+    write: (value, writer) => writer[writeMethod](value),
+    validate: (value) => {
+      if (value < 0 || value > options.maxValue) throw new TypeError(`Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`);
+      options.validate?.(value);
+    }
+  });
+}
+function bigUIntBcsType({ readMethod, writeMethod, ...options }) {
+  return fixedSizeBcsType({
+    ...options,
+    read: (reader) => reader[readMethod](),
+    write: (value, writer) => writer[writeMethod](BigInt(value)),
+    validate: (val) => {
+      const value = BigInt(val);
+      if (value < 0 || value > options.maxValue) throw new TypeError(`Invalid ${options.name} value: ${value}. Expected value in range 0-${options.maxValue}`);
+      options.validate?.(value);
+    }
+  });
+}
+function dynamicSizeBcsType({ serialize, ...options }) {
+  const type = new BcsType({
+    ...options,
+    serialize,
+    write: (value, writer) => {
+      for (const byte of type.serialize(value).toBytes()) writer.write8(byte);
+    }
+  });
+  return type;
+}
+function stringLikeBcsType({ toBytes, fromBytes, ...options }) {
+  return new BcsType({
+    ...options,
+    read: (reader) => {
+      const length = reader.readULEB();
+      return fromBytes(reader.readBytes(length));
+    },
+    write: (hex, writer) => {
+      const bytes = toBytes(hex);
+      writer.writeULEB(bytes.length);
+      for (let i = 0; i < bytes.length; i++) writer.write8(bytes[i]);
+    },
+    serialize: (value) => {
+      const bytes = toBytes(value);
+      const size = ulebEncode(bytes.length);
+      const result = new Uint8Array(size.length + bytes.length);
+      result.set(size, 0);
+      result.set(bytes, size.length);
+      return result;
+    },
+    validate: (value) => {
+      if (typeof value !== "string") throw new TypeError(`Invalid ${options.name} value: ${value}. Expected string`);
+      options.validate?.(value);
+    }
+  });
+}
+function lazyBcsType(cb) {
+  let lazyType = null;
+  function getType() {
+    if (!lazyType) lazyType = cb();
+    return lazyType;
+  }
+  return new BcsType({
+    name: "lazy",
+    read: (data) => getType().read(data),
+    serializedSize: (value) => getType().serializedSize(value),
+    write: (value, writer) => getType().write(value, writer),
+    serialize: (value, options) => getType().serialize(value, options).toBytes()
+  });
+}
+var BcsStruct = class extends BcsType {
+  constructor({ name, fields, ...options }) {
+    const canonicalOrder = Object.entries(fields);
+    super({
+      name,
+      serializedSize: (values) => {
+        let total = 0;
+        for (const [field, type] of canonicalOrder) {
+          const size = type.serializedSize(values[field]);
+          if (size == null) return null;
+          total += size;
+        }
+        return total;
+      },
+      read: (reader) => {
+        const result = {};
+        for (const [field, type] of canonicalOrder) result[field] = type.read(reader);
+        return result;
+      },
+      write: (value, writer) => {
+        for (const [field, type] of canonicalOrder) type.write(value[field], writer);
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "object" || value == null) throw new TypeError(`Expected object, found ${typeof value}`);
+      }
+    });
+  }
+};
+var BcsEnum = class extends BcsType {
+  constructor({ fields, ...options }) {
+    const canonicalOrder = Object.entries(fields);
+    super({
+      read: (reader) => {
+        const index = reader.readULEB();
+        const enumEntry = canonicalOrder[index];
+        if (!enumEntry) throw new TypeError(`Unknown value ${index} for enum ${options.name}`);
+        const [kind, type] = enumEntry;
+        return {
+          [kind]: type?.read(reader) ?? true,
+          $kind: kind
+        };
+      },
+      write: (value, writer) => {
+        const [name, val] = Object.entries(value).filter(([name$1]) => Object.hasOwn(fields, name$1))[0];
+        for (let i = 0; i < canonicalOrder.length; i++) {
+          const [optionName, optionType] = canonicalOrder[i];
+          if (optionName === name) {
+            writer.writeULEB(i);
+            optionType?.write(val, writer);
+            return;
+          }
+        }
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "object" || value == null) throw new TypeError(`Expected object, found ${typeof value}`);
+        const keys = Object.keys(value).filter((k2) => value[k2] !== void 0 && Object.hasOwn(fields, k2));
+        if (keys.length !== 1) throw new TypeError(`Expected object with one key, but found ${keys.length} for type ${options.name}}`);
+        const [variant] = keys;
+        if (!Object.hasOwn(fields, variant)) throw new TypeError(`Invalid enum variant ${variant}`);
+      }
+    });
+  }
+};
+var BcsTuple = class extends BcsType {
+  constructor({ fields, name, ...options }) {
+    super({
+      name: name ?? `(${fields.map((t) => t.name).join(", ")})`,
+      serializedSize: (values) => {
+        let total = 0;
+        for (let i = 0; i < fields.length; i++) {
+          const size = fields[i].serializedSize(values[i]);
+          if (size == null) return null;
+          total += size;
+        }
+        return total;
+      },
+      read: (reader) => {
+        const result = [];
+        for (const field of fields) result.push(field.read(reader));
+        return result;
+      },
+      write: (value, writer) => {
+        for (let i = 0; i < fields.length; i++) fields[i].write(value[i], writer);
+      },
+      ...options,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (!Array.isArray(value)) throw new TypeError(`Expected array, found ${typeof value}`);
+        if (value.length !== fields.length) throw new TypeError(`Expected array of length ${fields.length}, found ${value.length}`);
+      }
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/@mysten+bcs@2.0.2/node_modules/@mysten/bcs/dist/bcs.mjs
+function fixedArray(size, type, options) {
+  return new BcsType({
+    read: (reader) => {
+      const result = new Array(size);
+      for (let i = 0; i < size; i++) result[i] = type.read(reader);
+      return result;
+    },
+    write: (value, writer) => {
+      for (const item of value) type.write(item, writer);
+    },
+    ...options,
+    name: options?.name ?? `${type.name}[${size}]`,
+    validate: (value) => {
+      options?.validate?.(value);
+      if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+      if (value.length !== size) throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+    }
+  });
+}
+function option(type) {
+  return bcs.enum(`Option<${type.name}>`, {
+    None: null,
+    Some: type
+  }).transform({
+    input: (value) => {
+      if (value == null) return { None: true };
+      return { Some: value };
+    },
+    output: (value) => {
+      if (value.$kind === "Some") return value.Some;
+      return null;
+    }
+  });
+}
+function vector(type, options) {
+  return new BcsType({
+    read: (reader) => {
+      const length = reader.readULEB();
+      const result = new Array(length);
+      for (let i = 0; i < length; i++) result[i] = type.read(reader);
+      return result;
+    },
+    write: (value, writer) => {
+      writer.writeULEB(value.length);
+      for (const item of value) type.write(item, writer);
+    },
+    ...options,
+    name: options?.name ?? `vector<${type.name}>`,
+    validate: (value) => {
+      options?.validate?.(value);
+      if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+    }
+  });
+}
+function compareBcsBytes(a, b2) {
+  for (let i = 0; i < Math.min(a.length, b2.length); i++) if (a[i] !== b2[i]) return a[i] - b2[i];
+  return a.length - b2.length;
+}
+function map(keyType, valueType) {
+  return new BcsType({
+    name: `Map<${keyType.name}, ${valueType.name}>`,
+    read: (reader) => {
+      const length = reader.readULEB();
+      const result = /* @__PURE__ */ new Map();
+      for (let i = 0; i < length; i++) result.set(keyType.read(reader), valueType.read(reader));
+      return result;
+    },
+    write: (value, writer) => {
+      const entries = [...value.entries()].map(([key, val]) => [keyType.serialize(key).toBytes(), val]);
+      entries.sort(([a], [b2]) => compareBcsBytes(a, b2));
+      writer.writeULEB(entries.length);
+      for (const [keyBytes, val] of entries) {
+        writer.writeBytes(keyBytes);
+        valueType.write(val, writer);
+      }
+    }
+  });
+}
+var bcs = {
+  u8(options) {
+    return uIntBcsType({
+      readMethod: "read8",
+      writeMethod: "write8",
+      size: 1,
+      maxValue: 2 ** 8 - 1,
+      ...options,
+      name: options?.name ?? "u8"
+    });
+  },
+  u16(options) {
+    return uIntBcsType({
+      readMethod: "read16",
+      writeMethod: "write16",
+      size: 2,
+      maxValue: 2 ** 16 - 1,
+      ...options,
+      name: options?.name ?? "u16"
+    });
+  },
+  u32(options) {
+    return uIntBcsType({
+      readMethod: "read32",
+      writeMethod: "write32",
+      size: 4,
+      maxValue: 2 ** 32 - 1,
+      ...options,
+      name: options?.name ?? "u32"
+    });
+  },
+  u64(options) {
+    return bigUIntBcsType({
+      readMethod: "read64",
+      writeMethod: "write64",
+      size: 8,
+      maxValue: 2n ** 64n - 1n,
+      ...options,
+      name: options?.name ?? "u64"
+    });
+  },
+  u128(options) {
+    return bigUIntBcsType({
+      readMethod: "read128",
+      writeMethod: "write128",
+      size: 16,
+      maxValue: 2n ** 128n - 1n,
+      ...options,
+      name: options?.name ?? "u128"
+    });
+  },
+  u256(options) {
+    return bigUIntBcsType({
+      readMethod: "read256",
+      writeMethod: "write256",
+      size: 32,
+      maxValue: 2n ** 256n - 1n,
+      ...options,
+      name: options?.name ?? "u256"
+    });
+  },
+  bool(options) {
+    return fixedSizeBcsType({
+      size: 1,
+      read: (reader) => reader.read8() === 1,
+      write: (value, writer) => writer.write8(value ? 1 : 0),
+      ...options,
+      name: options?.name ?? "bool",
+      validate: (value) => {
+        options?.validate?.(value);
+        if (typeof value !== "boolean") throw new TypeError(`Expected boolean, found ${typeof value}`);
+      }
+    });
+  },
+  uleb128(options) {
+    return dynamicSizeBcsType({
+      read: (reader) => reader.readULEB(),
+      serialize: (value) => {
+        return Uint8Array.from(ulebEncode(value));
+      },
+      ...options,
+      name: options?.name ?? "uleb128"
+    });
+  },
+  bytes(size, options) {
+    return fixedSizeBcsType({
+      size,
+      read: (reader) => reader.readBytes(size),
+      write: (value, writer) => {
+        writer.writeBytes(new Uint8Array(value));
+      },
+      ...options,
+      name: options?.name ?? `bytes[${size}]`,
+      validate: (value) => {
+        options?.validate?.(value);
+        if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+        if (value.length !== size) throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+      }
+    });
+  },
+  byteVector(options) {
+    return new BcsType({
+      read: (reader) => {
+        const length = reader.readULEB();
+        return reader.readBytes(length);
+      },
+      write: (value, writer) => {
+        const array = new Uint8Array(value);
+        writer.writeULEB(array.length);
+        writer.writeBytes(array);
+      },
+      ...options,
+      name: options?.name ?? "vector<u8>",
+      serializedSize: (value) => {
+        const length = "length" in value ? value.length : null;
+        return length == null ? null : ulebEncode(length).length + length;
+      },
+      validate: (value) => {
+        options?.validate?.(value);
+        if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+      }
+    });
+  },
+  string(options) {
+    return stringLikeBcsType({
+      toBytes: (value) => new TextEncoder().encode(value),
+      fromBytes: (bytes) => new TextDecoder().decode(bytes),
+      ...options,
+      name: options?.name ?? "string"
+    });
+  },
+  fixedArray,
+  option,
+  vector,
+  tuple(fields, options) {
+    return new BcsTuple({
+      fields,
+      ...options
+    });
+  },
+  struct(name, fields, options) {
+    return new BcsStruct({
+      name,
+      fields,
+      ...options
+    });
+  },
+  enum(name, fields, options) {
+    return new BcsEnum({
+      name,
+      fields,
+      ...options
+    });
+  },
+  map,
+  lazy(cb) {
+    return lazyBcsType(cb);
+  }
+};
+
+// ../../node_modules/.pnpm/@naviprotocol+lending@1.4.0_patch_hash=f5361914099eac610a549dc571b1248d29f6a1f4195ed017_05ba4b180e35cb4ccd9db84691f20fcb/node_modules/@naviprotocol/lending/dist/index.esm.js
+__toESM(require_lodash());
+
+// ../../node_modules/.pnpm/bignumber.js@9.1.2/node_modules/bignumber.js/bignumber.mjs
+var isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+var mathceil = Math.ceil;
+var mathfloor = Math.floor;
+var bignumberError = "[BigNumber Error] ";
+var tooManyDigits = bignumberError + "Number primitive has more than 15 significant digits: ";
+var BASE = 1e14;
+var LOG_BASE = 14;
+var MAX_SAFE_INTEGER = 9007199254740991;
+var POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13];
+var SQRT_BASE = 1e7;
+var MAX = 1e9;
+function clone(configObject) {
+  var div, convertBase, parseNumeric, P2 = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(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",
+    // non-breaking space
+    suffix: ""
+  }, ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz", alphabetHasNormalDecimalDigits = true;
+  function BigNumber2(v, b2) {
+    var alphabet2, c, caseChanged, e, i, isNum, len, str, x2 = this;
+    if (!(x2 instanceof BigNumber2)) return new BigNumber2(v, b2);
+    if (b2 == null) {
+      if (v && v._isBigNumber === true) {
+        x2.s = v.s;
+        if (!v.c || v.e > MAX_EXP) {
+          x2.c = x2.e = null;
+        } else if (v.e < MIN_EXP) {
+          x2.c = [x2.e = 0];
+        } else {
+          x2.e = v.e;
+          x2.c = v.c.slice();
+        }
+        return;
+      }
+      if ((isNum = typeof v == "number") && v * 0 == 0) {
+        x2.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) {
+            x2.c = x2.e = null;
+          } else {
+            x2.e = e;
+            x2.c = [v];
+          }
+          return;
+        }
+        str = String(v);
+      } else {
+        if (!isNumeric.test(str = String(v))) return parseNumeric(x2, str, isNum);
+        x2.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(b2, 2, ALPHABET.length, "Base");
+      if (b2 == 10 && alphabetHasNormalDecimalDigits) {
+        x2 = new BigNumber2(v);
+        return round(x2, DECIMAL_PLACES + x2.e + 1, ROUNDING_MODE);
+      }
+      str = String(v);
+      if (isNum = typeof v == "number") {
+        if (v * 0 != 0) return parseNumeric(x2, str, isNum, b2);
+        x2.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;
+        if (BigNumber2.DEBUG && str.replace(/^0\.0*|\./, "").length > 15) {
+          throw Error(tooManyDigits + v);
+        }
+      } else {
+        x2.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
+      }
+      alphabet2 = ALPHABET.slice(0, b2);
+      e = i = 0;
+      for (len = str.length; i < len; i++) {
+        if (alphabet2.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(x2, String(v), isNum, b2);
+        }
+      }
+      isNum = false;
+      str = convertBase(str, b2, 10, x2.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 && BigNumber2.DEBUG && len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {
+        throw Error(tooManyDigits + x2.s * v);
+      }
+      if ((e = e - i - 1) > MAX_EXP) {
+        x2.c = x2.e = null;
+      } else if (e < MIN_EXP) {
+        x2.c = [x2.e = 0];
+      } else {
+        x2.e = e;
+        x2.c = [];
+        i = (e + 1) % LOG_BASE;
+        if (e < 0) i += LOG_BASE;
+        if (i < len) {
+          if (i) x2.c.push(+str.slice(0, i));
+          for (len -= LOG_BASE; i < len; ) {
+            x2.c.push(+str.slice(i, i += LOG_BASE));
+          }
+          i = LOG_BASE - (str = str.slice(i)).length;
+        } else {
+          i -= len;
+        }
+        for (; i--; str += "0") ;
+        x2.c.push(+str);
+      }
+    } else {
+      x2.c = [x2.e = 0];
+    }
+  }
+  BigNumber2.clone = clone;
+  BigNumber2.ROUND_UP = 0;
+  BigNumber2.ROUND_DOWN = 1;
+  BigNumber2.ROUND_CEIL = 2;
+  BigNumber2.ROUND_FLOOR = 3;
+  BigNumber2.ROUND_HALF_UP = 4;
+  BigNumber2.ROUND_HALF_DOWN = 5;
+  BigNumber2.ROUND_HALF_EVEN = 6;
+  BigNumber2.ROUND_HALF_CEIL = 7;
+  BigNumber2.ROUND_HALF_FLOOR = 8;
+  BigNumber2.EUCLID = 9;
+  BigNumber2.config = BigNumber2.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
+    };
+  };
+  BigNumber2.isBigNumber = function(v) {
+    if (!v || v._isBigNumber !== true) return false;
+    if (!BigNumber2.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);
+  };
+  BigNumber2.maximum = BigNumber2.max = function() {
+    return maxOrMin(arguments, -1);
+  };
+  BigNumber2.minimum = BigNumber2.min = function() {
+    return maxOrMin(arguments, 1);
+  };
+  BigNumber2.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, b2, e, k2, v, i = 0, c = [], rand = new BigNumber2(ONE);
+      if (dp == null) dp = DECIMAL_PLACES;
+      else intCheck(dp, 0, MAX);
+      k2 = mathceil(dp / LOG_BASE);
+      if (CRYPTO) {
+        if (crypto.getRandomValues) {
+          a = crypto.getRandomValues(new Uint32Array(k2 *= 2));
+          for (; i < k2; ) {
+            v = a[i] * 131072 + (a[i + 1] >>> 11);
+            if (v >= 9e15) {
+              b2 = crypto.getRandomValues(new Uint32Array(2));
+              a[i] = b2[0];
+              a[i + 1] = b2[1];
+            } else {
+              c.push(v % 1e14);
+              i += 2;
+            }
+          }
+          i = k2 / 2;
+        } else if (crypto.randomBytes) {
+          a = crypto.randomBytes(k2 *= 7);
+          for (; i < k2; ) {
+            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 % 1e14);
+              i += 7;
+            }
+          }
+          i = k2 / 7;
+        } else {
+          CRYPTO = false;
+          throw Error(bignumberError + "crypto unavailable");
+        }
+      }
+      if (!CRYPTO) {
+        for (; i < k2; ) {
+          v = random53bitInt();
+          if (v < 9e15) c[i++] = v % 1e14;
+        }
+      }
+      k2 = c[--i];
+      dp %= LOG_BASE;
+      if (k2 && dp) {
+        v = POWS_TEN[LOG_BASE - dp];
+        c[i] = mathfloor(k2 / 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;
+    };
+  })();
+  BigNumber2.sum = function() {
+    var i = 1, args = arguments, sum = new BigNumber2(args[0]);
+    for (; i < args.length; ) sum = sum.plus(args[i++]);
+    return sum;
+  };
+  convertBase = /* @__PURE__ */ (function() {
+    var decimal = "0123456789";
+    function toBaseOut(str, baseIn, baseOut, alphabet2) {
+      var j, arr = [0], arrL, i = 0, len = str.length;
+      for (; i < len; ) {
+        for (arrL = arr.length; arrL--; arr[arrL] *= baseIn) ;
+        arr[0] += alphabet2.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 alphabet2, d, e, k2, r, x2, xc, y, i = str.indexOf("."), dp = DECIMAL_PLACES, rm = ROUNDING_MODE;
+      if (i >= 0) {
+        k2 = POW_PRECISION;
+        POW_PRECISION = 0;
+        str = str.replace(".", "");
+        y = new BigNumber2(baseIn);
+        x2 = y.pow(str.length - i);
+        POW_PRECISION = k2;
+        y.c = toBaseOut(
+          toFixedPoint(coeffToString(x2.c), x2.e, "0"),
+          10,
+          baseOut,
+          decimal
+        );
+        y.e = y.c.length;
+      }
+      xc = toBaseOut(str, baseIn, baseOut, callerIsToString ? (alphabet2 = ALPHABET, decimal) : (alphabet2 = decimal, ALPHABET));
+      e = k2 = xc.length;
+      for (; xc[--k2] == 0; xc.pop()) ;
+      if (!xc[0]) return alphabet2.charAt(0);
+      if (i < 0) {
+        --e;
+      } else {
+        x2.c = xc;
+        x2.e = e;
+        x2.s = sign;
+        x2 = div(x2, y, dp, rm, baseOut);
+        xc = x2.c;
+        r = x2.r;
+        e = x2.e;
+      }
+      d = e + dp + 1;
+      i = xc[d];
+      k2 = baseOut / 2;
+      r = r || d < 0 || xc[d + 1] != null;
+      r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x2.s < 0 ? 3 : 2)) : i > k2 || i == k2 && (rm == 4 || r || rm == 6 && xc[d - 1] & 1 || rm == (x2.s < 0 ? 8 : 7));
+      if (d < 1 || !xc[0]) {
+        str = r ? toFixedPoint(alphabet2.charAt(1), -dp, alphabet2.charAt(0)) : alphabet2.charAt(0);
+      } else {
+        xc.length = d;
+        if (r) {
+          for (--baseOut; ++xc[--d] > baseOut; ) {
+            xc[d] = 0;
+            if (!d) {
+              ++e;
+              xc = [1].concat(xc);
+            }
+          }
+        }
+        for (k2 = xc.length; !xc[--k2]; ) ;
+        for (i = 0, str = ""; i <= k2; str += alphabet2.charAt(xc[i++])) ;
+        str = toFixedPoint(str, e, alphabet2.charAt(0));
+      }
+      return str;
+    };
+  })();
+  div = /* @__PURE__ */ (function() {
+    function multiply(x2, k2, base) {
+      var m, temp, xlo, xhi, carry = 0, i = x2.length, klo = k2 % SQRT_BASE, khi = k2 / SQRT_BASE | 0;
+      for (x2 = x2.slice(); i--; ) {
+        xlo = x2[i] % SQRT_BASE;
+        xhi = x2[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;
+        x2[i] = temp % base;
+      }
+      if (carry) x2 = [carry].concat(x2);
+      return x2;
+    }
+    function compare2(a, b2, aL, bL) {
+      var i, cmp;
+      if (aL != bL) {
+        cmp = aL > bL ? 1 : -1;
+      } else {
+        for (i = cmp = 0; i < aL; i++) {
+          if (a[i] != b2[i]) {
+            cmp = a[i] > b2[i] ? 1 : -1;
+            break;
+          }
+        }
+      }
+      return cmp;
+    }
+    function subtract(a, b2, aL, base) {
+      var i = 0;
+      for (; aL--; ) {
+        a[aL] -= i;
+        i = a[aL] < b2[aL] ? 1 : 0;
+        a[aL] = i * base + a[aL] - b2[aL];
+      }
+      for (; !a[0] && a.length > 1; a.splice(0, 1)) ;
+    }
+    return function(x2, y, dp, rm, base) {
+      var cmp, e, i, more, n, prod, prodL, q2, qc, rem, remL, rem0, xi, xL, yc0, yL, yz, s = x2.s == y.s ? 1 : -1, xc = x2.c, yc = y.c;
+      if (!xc || !xc[0] || !yc || !yc[0]) {
+        return new BigNumber2(
+          // Return NaN if either NaN, or both Infinity or 0.
+          !x2.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN : (
+            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.
+            xc && xc[0] == 0 || !yc ? s * 0 : s / 0
+          )
+        );
+      }
+      q2 = new BigNumber2(s);
+      qc = q2.c = [];
+      e = x2.e - y.e;
+      s = dp + e + 1;
+      if (!base) {
+        base = BASE;
+        e = bitFloor(x2.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 = compare2(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 (compare2(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 (compare2(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(q2, dp + (q2.e = i + e * LOG_BASE - 1) + 1, rm, more);
+      } else {
+        q2.e = e;
+        q2.r = +more;
+      }
+      return q2;
+    };
+  })();
+  function format(n, i, rm, id) {
+    var c0, e, ne2, len, str;
+    if (rm == null) rm = ROUNDING_MODE;
+    else intCheck(rm, 0, 8);
+    if (!n.c) return n.toString();
+    c0 = n.c[0];
+    ne2 = n.e;
+    if (i == null) {
+      str = coeffToString(n.c);
+      str = id == 1 || id == 2 && (ne2 <= TO_EXP_NEG || ne2 >= TO_EXP_POS) ? toExponential(str, ne2) : toFixedPoint(str, ne2, "0");
+    } else {
+      n = round(new BigNumber2(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 -= ne2;
+        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 k2, y, i = 1, x2 = new BigNumber2(args[0]);
+    for (; i < args.length; i++) {
+      y = new BigNumber2(args[i]);
+      if (!y.s || (k2 = compare(x2, y)) === n || k2 === 0 && x2.s === n) {
+        x2 = y;
+      }
+    }
+    return x2;
+  }
+  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 = /* @__PURE__ */ (function() {
+    var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, dotAfter = /^([^.]+)\.$/, dotBefore = /^\.([^.]+)$/, isInfinityOrNaN = /^-?(Infinity|NaN)$/, whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
+    return function(x2, str, isNum, b2) {
+      var base, s = isNum ? str : str.replace(whitespaceOrPlus, "");
+      if (isInfinityOrNaN.test(s)) {
+        x2.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 !b2 || b2 == base ? p1 : m;
+          });
+          if (b2) {
+            base = b2;
+            s = s.replace(dotAfter, "$1").replace(dotBefore, "0.$1");
+          }
+          if (str != s) return new BigNumber2(s, base);
+        }
+        if (BigNumber2.DEBUG) {
+          throw Error(bignumberError + "Not a" + (b2 ? " base " + b2 : "") + " number: " + str);
+        }
+        x2.s = null;
+      }
+      x2.c = x2.e = null;
+    };
+  })();
+  function round(x2, sd, rm, r) {
+    var d, i, j, k2, n, ni, rd, xc = x2.c, pows10 = POWS_TEN;
+    if (xc) {
+      out: {
+        for (d = 1, k2 = xc[0]; k2 >= 10; k2 /= 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 = k2 = xc[ni];
+            for (d = 1; k2 >= 10; k2 /= 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 || // Are there any non-zero digits after the rounding digit?
+        // The expression  n % pows10[d - j - 1]  returns all digits of n to the right
+        // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.
+        xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);
+        r = rm < 4 ? (rd || r) && (rm == 0 || rm == (x2.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 && // Check whether the digit to the left of the rounding digit is odd.
+        (i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10 & 1 || rm == (x2.s < 0 ? 8 : 7));
+        if (sd < 1 || !xc[0]) {
+          xc.length = 0;
+          if (r) {
+            sd -= x2.e + 1;
+            xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];
+            x2.e = -sd || 0;
+          } else {
+            xc[0] = x2.e = 0;
+          }
+          return x2;
+        }
+        if (i == 0) {
+          xc.length = ni;
+          k2 = 1;
+          ni--;
+        } else {
+          xc.length = ni + 1;
+          k2 = pows10[LOG_BASE - i];
+          xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k2 : 0;
+        }
+        if (r) {
+          for (; ; ) {
+            if (ni == 0) {
+              for (i = 1, j = xc[0]; j >= 10; j /= 10, i++) ;
+              j = xc[0] += k2;
+              for (k2 = 1; j >= 10; j /= 10, k2++) ;
+              if (i != k2) {
+                x2.e++;
+                if (xc[0] == BASE) xc[0] = 1;
+              }
+              break;
+            } else {
+              xc[ni] += k2;
+              if (xc[ni] != BASE) break;
+              xc[ni--] = 0;
+              k2 = 1;
+            }
+          }
+        }
+        for (i = xc.length; xc[--i] === 0; xc.pop()) ;
+      }
+      if (x2.e > MAX_EXP) {
+        x2.c = x2.e = null;
+      } else if (x2.e < MIN_EXP) {
+        x2.c = [x2.e = 0];
+      }
+    }
+    return x2;
+  }
+  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;
+  }
+  P2.absoluteValue = P2.abs = function() {
+    var x2 = new BigNumber2(this);
+    if (x2.s < 0) x2.s = 1;
+    return x2;
+  };
+  P2.comparedTo = function(y, b2) {
+    return compare(this, new BigNumber2(y, b2));
+  };
+  P2.decimalPlaces = P2.dp = function(dp, rm) {
+    var c, n, v, x2 = this;
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      if (rm == null) rm = ROUNDING_MODE;
+      else intCheck(rm, 0, 8);
+      return round(new BigNumber2(x2), dp + x2.e + 1, rm);
+    }
+    if (!(c = x2.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;
+  };
+  P2.dividedBy = P2.div = function(y, b2) {
+    return div(this, new BigNumber2(y, b2), DECIMAL_PLACES, ROUNDING_MODE);
+  };
+  P2.dividedToIntegerBy = P2.idiv = function(y, b2) {
+    return div(this, new BigNumber2(y, b2), 0, 1);
+  };
+  P2.exponentiatedBy = P2.pow = function(n, m) {
+    var half, isModExp, i, k2, more, nIsBig, nIsNeg, nIsOdd, y, x2 = this;
+    n = new BigNumber2(n);
+    if (n.c && !n.isInteger()) {
+      throw Error(bignumberError + "Exponent not an integer: " + valueOf(n));
+    }
+    if (m != null) m = new BigNumber2(m);
+    nIsBig = n.e > 14;
+    if (!x2.c || !x2.c[0] || x2.c[0] == 1 && !x2.e && x2.c.length == 1 || !n.c || !n.c[0]) {
+      y = new BigNumber2(Math.pow(+valueOf(x2), 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 BigNumber2(NaN);
+      isModExp = !nIsNeg && x2.isInteger() && m.isInteger();
+      if (isModExp) x2 = x2.mod(m);
+    } else if (n.e > 9 && (x2.e > 0 || x2.e < -1 || (x2.e == 0 ? x2.c[0] > 1 || nIsBig && x2.c[1] >= 24e7 : x2.c[0] < 8e13 || nIsBig && x2.c[0] <= 9999975e7))) {
+      k2 = x2.s < 0 && isOdd(n) ? -0 : 0;
+      if (x2.e > -1) k2 = 1 / k2;
+      return new BigNumber2(nIsNeg ? 1 / k2 : k2);
+    } else if (POW_PRECISION) {
+      k2 = mathceil(POW_PRECISION / LOG_BASE + 2);
+    }
+    if (nIsBig) {
+      half = new BigNumber2(0.5);
+      if (nIsNeg) n.s = 1;
+      nIsOdd = isOdd(n);
+    } else {
+      i = Math.abs(+valueOf(n));
+      nIsOdd = i % 2;
+    }
+    y = new BigNumber2(ONE);
+    for (; ; ) {
+      if (nIsOdd) {
+        y = y.times(x2);
+        if (!y.c) break;
+        if (k2) {
+          if (y.c.length > k2) y.c.length = k2;
+        } 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;
+        }
+      }
+      x2 = x2.times(x2);
+      if (k2) {
+        if (x2.c && x2.c.length > k2) x2.c.length = k2;
+      } else if (isModExp) {
+        x2 = x2.mod(m);
+      }
+    }
+    if (isModExp) return y;
+    if (nIsNeg) y = ONE.div(y);
+    return m ? y.mod(m) : k2 ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;
+  };
+  P2.integerValue = function(rm) {
+    var n = new BigNumber2(this);
+    if (rm == null) rm = ROUNDING_MODE;
+    else intCheck(rm, 0, 8);
+    return round(n, n.e + 1, rm);
+  };
+  P2.isEqualTo = P2.eq = function(y, b2) {
+    return compare(this, new BigNumber2(y, b2)) === 0;
+  };
+  P2.isFinite = function() {
+    return !!this.c;
+  };
+  P2.isGreaterThan = P2.gt = function(y, b2) {
+    return compare(this, new BigNumber2(y, b2)) > 0;
+  };
+  P2.isGreaterThanOrEqualTo = P2.gte = function(y, b2) {
+    return (b2 = compare(this, new BigNumber2(y, b2))) === 1 || b2 === 0;
+  };
+  P2.isInteger = function() {
+    return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
+  };
+  P2.isLessThan = P2.lt = function(y, b2) {
+    return compare(this, new BigNumber2(y, b2)) < 0;
+  };
+  P2.isLessThanOrEqualTo = P2.lte = function(y, b2) {
+    return (b2 = compare(this, new BigNumber2(y, b2))) === -1 || b2 === 0;
+  };
+  P2.isNaN = function() {
+    return !this.s;
+  };
+  P2.isNegative = function() {
+    return this.s < 0;
+  };
+  P2.isPositive = function() {
+    return this.s > 0;
+  };
+  P2.isZero = function() {
+    return !!this.c && this.c[0] == 0;
+  };
+  P2.minus = function(y, b2) {
+    var i, j, t, xLTy, x2 = this, a = x2.s;
+    y = new BigNumber2(y, b2);
+    b2 = y.s;
+    if (!a || !b2) return new BigNumber2(NaN);
+    if (a != b2) {
+      y.s = -b2;
+      return x2.plus(y);
+    }
+    var xe2 = x2.e / LOG_BASE, ye2 = y.e / LOG_BASE, xc = x2.c, yc = y.c;
+    if (!xe2 || !ye2) {
+      if (!xc || !yc) return xc ? (y.s = -b2, y) : new BigNumber2(yc ? x2 : NaN);
+      if (!xc[0] || !yc[0]) {
+        return yc[0] ? (y.s = -b2, y) : new BigNumber2(xc[0] ? x2 : (
+          // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity
+          ROUNDING_MODE == 3 ? -0 : 0
+        ));
+      }
+    }
+    xe2 = bitFloor(xe2);
+    ye2 = bitFloor(ye2);
+    xc = xc.slice();
+    if (a = xe2 - ye2) {
+      if (xLTy = a < 0) {
+        a = -a;
+        t = xc;
+      } else {
+        ye2 = xe2;
+        t = yc;
+      }
+      t.reverse();
+      for (b2 = a; b2--; t.push(0)) ;
+      t.reverse();
+    } else {
+      j = (xLTy = (a = xc.length) < (b2 = yc.length)) ? a : b2;
+      for (a = b2 = 0; b2 < j; b2++) {
+        if (xc[b2] != yc[b2]) {
+          xLTy = xc[b2] < yc[b2];
+          break;
+        }
+      }
+    }
+    if (xLTy) {
+      t = xc;
+      xc = yc;
+      yc = t;
+      y.s = -y.s;
+    }
+    b2 = (j = yc.length) - (i = xc.length);
+    if (b2 > 0) for (; b2--; xc[i++] = 0) ;
+    b2 = BASE - 1;
+    for (; j > a; ) {
+      if (xc[--j] < yc[j]) {
+        for (i = j; i && !xc[--i]; xc[i] = b2) ;
+        --xc[i];
+        xc[j] += BASE;
+      }
+      xc[j] -= yc[j];
+    }
+    for (; xc[0] == 0; xc.splice(0, 1), --ye2) ;
+    if (!xc[0]) {
+      y.s = ROUNDING_MODE == 3 ? -1 : 1;
+      y.c = [y.e = 0];
+      return y;
+    }
+    return normalise(y, xc, ye2);
+  };
+  P2.modulo = P2.mod = function(y, b2) {
+    var q2, s, x2 = this;
+    y = new BigNumber2(y, b2);
+    if (!x2.c || !y.s || y.c && !y.c[0]) {
+      return new BigNumber2(NaN);
+    } else if (!y.c || x2.c && !x2.c[0]) {
+      return new BigNumber2(x2);
+    }
+    if (MODULO_MODE == 9) {
+      s = y.s;
+      y.s = 1;
+      q2 = div(x2, y, 0, 3);
+      y.s = s;
+      q2.s *= s;
+    } else {
+      q2 = div(x2, y, 0, MODULO_MODE);
+    }
+    y = x2.minus(q2.times(y));
+    if (!y.c[0] && MODULO_MODE == 1) y.s = x2.s;
+    return y;
+  };
+  P2.multipliedBy = P2.times = function(y, b2) {
+    var c, e, i, j, k2, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, base, sqrtBase, x2 = this, xc = x2.c, yc = (y = new BigNumber2(y, b2)).c;
+    if (!xc || !yc || !xc[0] || !yc[0]) {
+      if (!x2.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {
+        y.c = y.e = y.s = null;
+      } else {
+        y.s *= x2.s;
+        if (!xc || !yc) {
+          y.c = y.e = null;
+        } else {
+          y.c = [0];
+          y.e = 0;
+        }
+      }
+      return y;
+    }
+    e = bitFloor(x2.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);
+    y.s *= x2.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 (k2 = xcL, j = i + k2; j > i; ) {
+        xlo = xc[--k2] % sqrtBase;
+        xhi = xc[k2] / 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);
+  };
+  P2.negated = function() {
+    var x2 = new BigNumber2(this);
+    x2.s = -x2.s || null;
+    return x2;
+  };
+  P2.plus = function(y, b2) {
+    var t, x2 = this, a = x2.s;
+    y = new BigNumber2(y, b2);
+    b2 = y.s;
+    if (!a || !b2) return new BigNumber2(NaN);
+    if (a != b2) {
+      y.s = -b2;
+      return x2.minus(y);
+    }
+    var xe2 = x2.e / LOG_BASE, ye2 = y.e / LOG_BASE, xc = x2.c, yc = y.c;
+    if (!xe2 || !ye2) {
+      if (!xc || !yc) return new BigNumber2(a / 0);
+      if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber2(xc[0] ? x2 : a * 0);
+    }
+    xe2 = bitFloor(xe2);
+    ye2 = bitFloor(ye2);
+    xc = xc.slice();
+    if (a = xe2 - ye2) {
+      if (a > 0) {
+        ye2 = xe2;
+        t = yc;
+      } else {
+        a = -a;
+        t = xc;
+      }
+      t.reverse();
+      for (; a--; t.push(0)) ;
+      t.reverse();
+    }
+    a = xc.length;
+    b2 = yc.length;
+    if (a - b2 < 0) {
+      t = yc;
+      yc = xc;
+      xc = t;
+      b2 = a;
+    }
+    for (a = 0; b2; ) {
+      a = (xc[--b2] = xc[b2] + yc[b2] + a) / BASE | 0;
+      xc[b2] = BASE === xc[b2] ? 0 : xc[b2] % BASE;
+    }
+    if (a) {
+      xc = [a].concat(xc);
+      ++ye2;
+    }
+    return normalise(y, xc, ye2);
+  };
+  P2.precision = P2.sd = function(sd, rm) {
+    var c, n, v, x2 = this;
+    if (sd != null && sd !== !!sd) {
+      intCheck(sd, 1, MAX);
+      if (rm == null) rm = ROUNDING_MODE;
+      else intCheck(rm, 0, 8);
+      return round(new BigNumber2(x2), sd, rm);
+    }
+    if (!(c = x2.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 && x2.e + 1 > n) n = x2.e + 1;
+    return n;
+  };
+  P2.shiftedBy = function(k2) {
+    intCheck(k2, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+    return this.times("1e" + k2);
+  };
+  P2.squareRoot = P2.sqrt = function() {
+    var m, n, r, rep, t, x2 = this, c = x2.c, s = x2.s, e = x2.e, dp = DECIMAL_PLACES + 4, half = new BigNumber2("0.5");
+    if (s !== 1 || !c || !c[0]) {
+      return new BigNumber2(!s || s < 0 && (!c || c[0]) ? NaN : c ? x2 : 1 / 0);
+    }
+    s = Math.sqrt(+valueOf(x2));
+    if (s == 0 || s == 1 / 0) {
+      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 == 1 / 0) {
+        n = "5e" + e;
+      } else {
+        n = s.toExponential();
+        n = n.slice(0, n.indexOf("e") + 1) + e;
+      }
+      r = new BigNumber2(n);
+    } else {
+      r = new BigNumber2(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(x2, 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(x2)) {
+                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(x2);
+            }
+            break;
+          }
+        }
+      }
+    }
+    return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
+  };
+  P2.toExponential = function(dp, rm) {
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      dp++;
+    }
+    return format(this, dp, rm, 1);
+  };
+  P2.toFixed = function(dp, rm) {
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      dp = dp + this.e + 1;
+    }
+    return format(this, dp, rm);
+  };
+  P2.toFormat = function(dp, rm, format2) {
+    var str, x2 = this;
+    if (format2 == null) {
+      if (dp != null && rm && typeof rm == "object") {
+        format2 = rm;
+        rm = null;
+      } else if (dp && typeof dp == "object") {
+        format2 = dp;
+        dp = rm = null;
+      } else {
+        format2 = FORMAT;
+      }
+    } else if (typeof format2 != "object") {
+      throw Error(bignumberError + "Argument not an object: " + format2);
+    }
+    str = x2.toFixed(dp, rm);
+    if (x2.c) {
+      var i, arr = str.split("."), g1 = +format2.groupSize, g2 = +format2.secondaryGroupSize, groupSeparator = format2.groupSeparator || "", intPart = arr[0], fractionPart = arr[1], isNeg = x2.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 + (format2.decimalSeparator || "") + ((g2 = +format2.fractionGroupSize) ? fractionPart.replace(
+        new RegExp("\\d{" + g2 + "}\\B", "g"),
+        "$&" + (format2.fractionGroupSeparator || "")
+      ) : fractionPart) : intPart;
+    }
+    return (format2.prefix || "") + str + (format2.suffix || "");
+  };
+  P2.toFraction = function(md) {
+    var d, d0, d1, d2, e, exp, n, n0, n1, q2, r, s, x2 = this, xc = x2.c;
+    if (md != null) {
+      n = new BigNumber2(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 BigNumber2(x2);
+    d = new BigNumber2(ONE);
+    n1 = d0 = new BigNumber2(ONE);
+    d1 = n0 = new BigNumber2(ONE);
+    s = coeffToString(xc);
+    e = d.e = s.length - x2.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 = 1 / 0;
+    n = new BigNumber2(s);
+    n0.c[0] = 0;
+    for (; ; ) {
+      q2 = div(n, d, 0, 1);
+      d2 = d0.plus(q2.times(d1));
+      if (d2.comparedTo(md) == 1) break;
+      d0 = d1;
+      d1 = d2;
+      n1 = n0.plus(q2.times(d2 = n1));
+      n0 = d2;
+      d = n.minus(q2.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 = x2.s;
+    e = e * 2;
+    r = div(n1, d1, e, ROUNDING_MODE).minus(x2).abs().comparedTo(
+      div(n0, d0, e, ROUNDING_MODE).minus(x2).abs()
+    ) < 1 ? [n1, d1] : [n0, d0];
+    MAX_EXP = exp;
+    return r;
+  };
+  P2.toNumber = function() {
+    return +valueOf(this);
+  };
+  P2.toPrecision = function(sd, rm) {
+    if (sd != null) intCheck(sd, 1, MAX);
+    return format(this, sd, rm, 2);
+  };
+  P2.toString = function(b2) {
+    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 (b2 == null) {
+        str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(coeffToString(n.c), e) : toFixedPoint(coeffToString(n.c), e, "0");
+      } else if (b2 === 10 && alphabetHasNormalDecimalDigits) {
+        n = round(new BigNumber2(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
+        str = toFixedPoint(coeffToString(n.c), n.e, "0");
+      } else {
+        intCheck(b2, 2, ALPHABET.length, "Base");
+        str = convertBase(toFixedPoint(coeffToString(n.c), e, "0"), 10, b2, s, true);
+      }
+      if (s < 0 && n.c[0]) str = "-" + str;
+    }
+    return str;
+  };
+  P2.valueOf = P2.toJSON = function() {
+    return valueOf(this);
+  };
+  P2._isBigNumber = true;
+  P2[Symbol.toStringTag] = "BigNumber";
+  P2[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = P2.valueOf;
+  if (configObject != null) BigNumber2.set(configObject);
+  return BigNumber2;
+}
+function bitFloor(n) {
+  var i = n | 0;
+  return n > 0 || n === i ? i : i - 1;
+}
+function coeffToString(a) {
+  var s, z2, i = 1, j = a.length, r = a[0] + "";
+  for (; i < j; ) {
+    s = a[i++] + "";
+    z2 = LOG_BASE - s.length;
+    for (; z2--; s = "0" + s) ;
+    r += s;
+  }
+  for (j = r.length; r.charCodeAt(--j) === 48; ) ;
+  return r.slice(0, j + 1 || 1);
+}
+function compare(x2, y) {
+  var a, b2, xc = x2.c, yc = y.c, i = x2.s, j = y.s, k2 = x2.e, l = y.e;
+  if (!i || !j) return null;
+  a = xc && !xc[0];
+  b2 = yc && !yc[0];
+  if (a || b2) return a ? b2 ? 0 : -j : i;
+  if (i != j) return i;
+  a = i < 0;
+  b2 = k2 == l;
+  if (!xc || !yc) return b2 ? 0 : !xc ^ a ? 1 : -1;
+  if (!b2) return k2 > l ^ a ? 1 : -1;
+  j = (k2 = xc.length) < (l = yc.length) ? k2 : l;
+  for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;
+  return k2 == l ? 0 : k2 > 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));
   }
-  async bestSaveRate(asset) {
-    const candidates = [];
-    for (const adapter of this.lending.values()) {
-      if (!adapter.supportedAssets.includes(asset)) continue;
-      if (!adapter.capabilities.includes("save")) continue;
-      try {
-        const rate = await adapter.getRates(asset);
-        candidates.push({ adapter, rate });
-      } catch {
-      }
+}
+function isOdd(n) {
+  var k2 = n.c.length - 1;
+  return bitFloor(n.e / LOG_BASE) == k2 && n.c[k2] % 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, z2) {
+  var len, zs;
+  if (e < 0) {
+    for (zs = z2 + "."; ++e; zs += z2) ;
+    str = zs + str;
+  } else {
+    len = str.length;
+    if (++e > len) {
+      for (zs = z2, e -= len; --e; zs += z2) ;
+      str += zs;
+    } else if (e < len) {
+      str = str.slice(0, e) + "." + str.slice(e);
     }
-    if (candidates.length === 0) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `No lending adapter supports saving ${asset}`);
+  }
+  return str;
+}
+var BigNumber = clone();
+var bignumber_default = BigNumber;
+var z = bcs.bytes(32).transform({
+  // To change the input type, you need to provide a type definition for the input
+  input: (e) => fromHex(e),
+  output: (e) => toHex(e)
+});
+bcs.struct("IncentiveAPYInfo", {
+  /** Asset identifier */
+  asset_id: bcs.u8(),
+  /** Annual Percentage Yield as a 256-bit integer */
+  apy: bcs.u256(),
+  /** List of supported coin types for this incentive */
+  coin_types: bcs.vector(bcs.string())
+});
+var me = bcs.struct("IncentivePoolInfo", {
+  /** Unique pool identifier */
+  pool_id: z,
+  /** Address holding the incentive funds */
+  funds: z,
+  /** Current phase of the incentive program */
+  phase: bcs.u64(),
+  /** Timestamp when the incentive started */
+  start_at: bcs.u64(),
+  /** Timestamp when the incentive ends */
+  end_at: bcs.u64(),
+  /** Timestamp when the incentive was closed */
+  closed_at: bcs.u64(),
+  /** Total supply of incentive tokens */
+  total_supply: bcs.u64(),
+  /** Asset identifier for the incentive */
+  asset_id: bcs.u8(),
+  /** Option type for the incentive */
+  option: bcs.u8(),
+  /** Factor used in incentive calculations */
+  factor: bcs.u256(),
+  /** Amount of incentives already distributed */
+  distributed: bcs.u64(),
+  /** Amount of incentives currently available */
+  available: bcs.u256(),
+  /** Total amount of incentives */
+  total: bcs.u256()
+});
+bcs.struct("IncentivePoolInfoByPhase", {
+  /** Phase number */
+  phase: bcs.u64(),
+  /** List of incentive pools in this phase */
+  pools: bcs.vector(me)
+});
+bcs.struct("OracleInfo", {
+  /** Oracle identifier */
+  oracle_id: bcs.u8(),
+  /** Current price as a 256-bit integer */
+  price: bcs.u256(),
+  /** Number of decimal places for the price */
+  decimals: bcs.u8(),
+  /** Whether the oracle data is valid */
+  valid: bcs.bool()
+});
+bcs.struct("FlashLoanAssetConfig", {
+  /** Unique identifier for the flash loan asset */
+  id: bcs.string(),
+  /** Asset identifier */
+  asset_id: bcs.u8(),
+  /** Coin type for the asset */
+  coin_type: bcs.string(),
+  /** Pool identifier for the flash loan */
+  pool_id: bcs.string(),
+  /** Rate paid to suppliers for flash loans */
+  rate_to_supplier: bcs.u64(),
+  /** Rate paid to treasury for flash loans */
+  rate_to_treasury: bcs.u64(),
+  /** Maximum flash loan amount */
+  max: bcs.u64(),
+  /** Minimum flash loan amount */
+  min: bcs.u64()
+});
+bcs.struct("ReserveDataInfo", {
+  /** Reserve identifier */
+  id: bcs.u8(),
+  /** Oracle identifier for price feeds */
+  oracle_id: bcs.u8(),
+  /** Coin type for the reserve */
+  coin_type: bcs.string(),
+  /** Maximum supply capacity */
+  supply_cap: bcs.u256(),
+  /** Maximum borrow capacity */
+  borrow_cap: bcs.u256(),
+  /** Current supply interest rate */
+  supply_rate: bcs.u256(),
+  /** Current borrow interest rate */
+  borrow_rate: bcs.u256(),
+  /** Current supply index for interest calculation */
+  supply_index: bcs.u256(),
+  /** Current borrow index for interest calculation */
+  borrow_index: bcs.u256(),
+  /** Total amount supplied to the reserve */
+  total_supply: bcs.u256(),
+  /** Total amount borrowed from the reserve */
+  total_borrow: bcs.u256(),
+  /** Timestamp of last update */
+  last_update_at: bcs.u64(),
+  /** Loan-to-Value ratio for collateral */
+  ltv: bcs.u256(),
+  /** Treasury factor for fee calculations */
+  treasury_factor: bcs.u256(),
+  /** Current treasury balance */
+  treasury_balance: bcs.u256(),
+  /** Base interest rate */
+  base_rate: bcs.u256(),
+  /** Interest rate multiplier */
+  multiplier: bcs.u256(),
+  /** Jump rate multiplier for high utilization */
+  jump_rate_multiplier: bcs.u256(),
+  /** Reserve factor for protocol fees */
+  reserve_factor: bcs.u256(),
+  /** Optimal utilization rate */
+  optimal_utilization: bcs.u256(),
+  /** Liquidation ratio threshold */
+  liquidation_ratio: bcs.u256(),
+  /** Liquidation bonus for liquidators */
+  liquidation_bonus: bcs.u256(),
+  /** Liquidation threshold */
+  liquidation_threshold: bcs.u256()
+});
+var fe = bcs.struct("UserStateInfo", {
+  /** Asset identifier */
+  asset_id: bcs.u8(),
+  /** User's current borrow balance */
+  borrow_balance: bcs.u256(),
+  /** User's current supply balance */
+  supply_balance: bcs.u256()
+});
+var ye = "1.4.0";
+var V = {
+  version: ye
+};
+var ge = V.version;
+var he = () => {
+  if (typeof process < "u" && process.versions && process.versions.node)
+    try {
+      const e = __require("os"), n = process.version, o = e.type(), r = e.arch();
+      return `Node.js ${n.startsWith("v") ? n.substring(1) : n}; ${o}/${r}`;
+    } catch {
+      return `Node.js ${process.version}; OS/Unknown (Error)`;
     }
-    candidates.sort((a, b) => b.rate.saveApy - a.rate.saveApy);
-    return candidates[0];
+  return "Node/Unknown";
+};
+var ve = () => {
+  let e = "";
+  return typeof process < "u" && process.versions && process.versions.node && (e = `lending/${ge} (${he()})`), e;
+};
+var K = ve();
+var P = new jsonRpc.SuiJsonRpcClient({
+  url: jsonRpc.getJsonRpcFullnodeUrl("mainnet")
+});
+function Q(e) {
+  const n = [];
+  return e.forEach((o, r) => {
+    const t = r === e.length - 1;
+    if (typeof o == "object" && o !== null && t) {
+      const { client: a, disableCache: s, cacheTime: i, ...c } = o;
+      n.push(c);
+    } else
+      n.push(o);
+  }), JSON.stringify(n);
+}
+function B(e) {
+  const n = {};
+  return (...o) => {
+    const r = Q(o);
+    return n[r] || (n[r] = e(...o).finally(() => {
+      delete n[r];
+    })), n[r];
+  };
+}
+function $(e) {
+  let n = {};
+  return (...o) => {
+    const r = o[o.length - 1], t = Q(o), a = n[t];
+    return !r?.disableCache && typeof a?.data < "u" && (typeof r?.cacheTime > "u" || r.cacheTime > Date.now() - a.cacheAt) ? a.data : e(...o).then((s) => (n[t] = {
+      data: s,
+      cacheAt: Date.now()
+    }, s));
+  };
+}
+function g(e, n) {
+  return typeof e == "object" ? e : n(e);
+}
+function we(e, n) {
+  return typeof n == "string" ? e.object(n) : typeof n == "object" && n.$kind ? n : e.object(n.contract.pool);
+}
+function L(e, n, o) {
+  if (e.results && e.results.length > 0) {
+    if (e.results[0].returnValues && e.results[0].returnValues.length > 0)
+      return e.results[0].returnValues.map((r, t) => (n[t] || n[0]).parse(Uint8Array.from(r[0])));
+  } else if (e.error)
+    return console.log(`Get an error, msg: ${e.error}`), [];
+  return [];
+}
+function b(e) {
+  return utils.normalizeStructTag(e);
+}
+function X(e) {
+  const n = (e || 0) / Math.pow(10, 27);
+  return n > Math.pow(10, 5) ? 1 / 0 : n;
+}
+new pythSuiJs.SuiPriceServiceConnection("https://hermes.pyth.network", {
+  timeout: 2e4
+});
+var be = 27;
+var Y = (e, n) => {
+  if (!Number(e) || !Number(n)) return new bignumber_default(0);
+  const o = new bignumber_default(1).shiftedBy(1 * be), r = o.multipliedBy(new bignumber_default(0.5));
+  return new bignumber_default(e).multipliedBy(new bignumber_default(n)).plus(r).dividedBy(o).integerValue(bignumber_default.ROUND_DOWN);
+};
+var E = K ? {
+  "User-Agent": K
+} : {};
+function H(e, n = "uniqueId") {
+  return e.reduce(
+    (o, r) => (o[r[n]] = r, o),
+    {}
+  );
+}
+function q(e, n) {
+  const o = e.emodes.find((t) => t.emodeId === n.emodeId);
+  if (!o)
+    throw new Error("EMode not found in pool");
+  const r = o.assets.find((t) => t.assetId === e.id);
+  return {
+    ...e,
+    emode: {
+      ...r,
+      emodeId: o.emodeId
+    },
+    isEMode: true
+  };
+}
+function ke(e) {
+  const [n, o] = e.split("-");
+  return !n || !o ? null : {
+    marketKey: n,
+    poolId: parseInt(o)
+  };
+}
+function T() {
+  return typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}
+var R = $(
+  B(
+    async (e) => {
+      const n = (e?.markets || [M.main]).map((t) => _(t)), o = `https://open-api.naviprotocol.io/api/navi/pools?env=${e?.env || "prod"}&sdk=${V.version}&market=${n.map(
+        (t) => t.key
+      )}`, r = await fetch(o, { headers: E }).then((t) => t.json());
+      return r.data.forEach((t) => {
+        const s = r.meta.emodes.filter((h) => {
+          const j = _(h.marketId);
+          return t.market === j.key && h.isActive;
+        }).filter((h) => !!h.assets.find((j) => j.assetId === t.id));
+        t.emodes = s;
+        const i = bignumber_default(t.totalSupplyAmount).div(Math.pow(10, 9)).decimalPlaces(t.token.decimals, bignumber_default.ROUND_DOWN).toString(), c = bignumber_default(t.borrowedAmount).shiftedBy(-9).decimalPlaces(t.token.decimals, bignumber_default.ROUND_DOWN).toString(), u = bignumber_default(i).multipliedBy(t.oracle.price).toString(), d = bignumber_default(c).multipliedBy(t.oracle.price).toString(), f = bignumber_default(t.supplyCapCeiling).shiftedBy(-27).decimalPlaces(t.token.decimals, bignumber_default.ROUND_DOWN).toString(), v = bignumber_default.max(
+          bignumber_default(t.borrowedAmount),
+          bignumber_default(t.validBorrowAmount)
+        ).shiftedBy(-9).decimalPlaces(t.token.decimals, bignumber_default.ROUND_DOWN).toString(), y = bignumber_default(f).multipliedBy(t.oracle.price).toString(), l = bignumber_default(v).multipliedBy(t.oracle.price).toString();
+        t.poolSupplyAmount = i, t.poolBorrowAmount = c, t.poolSupplyValue = u, t.poolBorrowValue = d, t.poolSupplyCapAmount = f, t.poolBorrowCapAmount = v, t.poolSupplyCapValue = y, t.poolBorrowCapValue = l;
+      }), r.data;
+    }
+  )
+);
+async function A(e, n) {
+  let o = n?.market;
+  if (typeof e == "string") {
+    const a = ke(e);
+    a && (o = a.marketKey, e = a.poolId);
   }
-  async bestBorrowRate(asset, opts) {
-    const candidates = [];
-    for (const adapter of this.lending.values()) {
-      if (!adapter.supportedAssets.includes(asset)) continue;
-      if (!adapter.capabilities.includes("borrow")) continue;
-      if (opts?.requireSameAssetBorrow && !adapter.supportsSameAssetBorrow) continue;
-      try {
-        const rate = await adapter.getRates(asset);
-        candidates.push({ adapter, rate });
-      } catch {
-      }
+  const r = await R({
+    ...n,
+    markets: [o || N],
+    cacheTime: w
+  });
+  if (typeof e == "object")
+    return e;
+  const t = r.find((a) => typeof e == "string" ? b(a.suiCoinType) === b(e) : typeof e == "number" ? a.id === e : false);
+  if (!t)
+    throw new Error("Pool not found");
+  return t.isDeprecated && console.log(`The lending pool for coinType ${t.suiCoinType} is going to be deprecated.`), t;
+}
+async function Ce(e, n, o, r) {
+  const t = await k({
+    ...r,
+    cacheTime: w
+  }), a = await A(n, r);
+  if (a?.deprecatedAt && Date.now() > a.deprecatedAt)
+    throw new Error(`The lending pool for coinType ${a.suiCoinType} has been deprecated.`);
+  const s = typeof o == "object" && o.$kind === "GasCoin";
+  if (b(a.suiCoinType) === b("0x2::sui::SUI") && s) {
+    if (!r?.amount)
+      throw new Error("Amount is required for sui coin");
+    o = e.splitCoins(o, [r.amount]);
+  }
+  let i;
+  return typeof r?.amount < "u" ? i = g(r.amount, e.pure.u64) : i = e.moveCall({
+    target: "0x2::coin::value",
+    arguments: [g(o, e.object)],
+    typeArguments: [a.suiCoinType]
+  }), r?.accountCap ? e.moveCall({
+    target: `${t.package}::incentive_v3::deposit_with_account_cap`,
+    arguments: [
+      e.object("0x06"),
+      e.object(t.storage),
+      e.object(a.contract.pool),
+      e.pure.u8(a.id),
+      g(o, e.object),
+      e.object(t.incentiveV2),
+      e.object(t.incentiveV3),
+      g(r.accountCap, e.object)
+    ],
+    typeArguments: [a.suiCoinType]
+  }) : e.moveCall({
+    target: `${t.package}::incentive_v3::entry_deposit`,
+    arguments: [
+      e.object("0x06"),
+      e.object(t.storage),
+      e.object(a.contract.pool),
+      e.pure.u8(a.id),
+      g(o, e.object),
+      i,
+      e.object(t.incentiveV2),
+      e.object(t.incentiveV3)
+    ],
+    typeArguments: [a.suiCoinType]
+  }), t.version === 2 && a.id === 0 && (!r?.env || r?.env === "prod") && e.moveCall({
+    target: `${t.package}::pool::refresh_stake`,
+    arguments: [e.object(a.contract.pool), e.object("0x05")]
+  }), e;
+}
+async function Qe(e, n, o, r) {
+  const t = await k({
+    ...r,
+    cacheTime: w
+  }), a = await A(n, r), s = g(o, e.pure.u64);
+  let i;
+  if (t.version === 1)
+    if (r?.accountCap) {
+      const [u] = e.moveCall({
+        target: `${t.package}::incentive_v3::withdraw_with_account_cap`,
+        arguments: [
+          e.object("0x06"),
+          e.object(t.priceOracle),
+          e.object(t.storage),
+          e.object(a.contract.pool),
+          e.pure.u8(a.id),
+          s,
+          e.object(t.incentiveV2),
+          e.object(t.incentiveV3),
+          g(r.accountCap, e.object)
+        ],
+        typeArguments: [a.suiCoinType]
+      });
+      i = u;
+    } else {
+      const [u] = e.moveCall({
+        target: `${t.package}::incentive_v3::withdraw`,
+        arguments: [
+          e.object("0x06"),
+          e.object(t.priceOracle),
+          e.object(t.storage),
+          e.object(a.contract.pool),
+          e.pure.u8(a.id),
+          s,
+          e.object(t.incentiveV2),
+          e.object(t.incentiveV3)
+        ],
+        typeArguments: [a.suiCoinType]
+      });
+      i = u;
     }
-    if (candidates.length === 0) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", `No lending adapter supports borrowing ${asset}`);
+  else if (r?.accountCap) {
+    const [u] = e.moveCall({
+      target: `${t.package}::incentive_v3::withdraw_with_account_cap_v2`,
+      arguments: [
+        e.object("0x06"),
+        e.object(t.priceOracle),
+        e.object(t.storage),
+        e.object(a.contract.pool),
+        e.pure.u8(a.id),
+        s,
+        e.object(t.incentiveV2),
+        e.object(t.incentiveV3),
+        g(r.accountCap, e.object),
+        e.object("0x05")
+      ],
+      typeArguments: [a.suiCoinType]
+    });
+    i = u;
+  } else {
+    const [u] = e.moveCall({
+      target: `${t.package}::incentive_v3::withdraw_v2`,
+      arguments: [
+        e.object("0x06"),
+        e.object(t.priceOracle),
+        e.object(t.storage),
+        e.object(a.contract.pool),
+        e.pure.u8(a.id),
+        s,
+        e.object(t.incentiveV2),
+        e.object(t.incentiveV3),
+        e.object("0x05")
+      ],
+      typeArguments: [a.suiCoinType]
+    });
+    i = u;
+  }
+  return e.moveCall({
+    target: "0x2::coin::from_balance",
+    arguments: [i],
+    typeArguments: [a.suiCoinType]
+  });
+}
+async function Xe(e, n, o, r) {
+  const t = await k({
+    ...r,
+    cacheTime: w
+  }), a = await A(n, r);
+  if (a?.deprecatedAt && Date.now() > a.deprecatedAt)
+    throw new Error(`The lending pool for coinType ${a.suiCoinType} has been deprecated.`);
+  const s = g(o, e.pure.u64);
+  let i;
+  if (t.version === 1)
+    if (r?.accountCap) {
+      const [u] = e.moveCall({
+        target: `${t.package}::incentive_v3::borrow_with_account_cap`,
+        arguments: [
+          e.object("0x06"),
+          e.object(t.priceOracle),
+          e.object(t.storage),
+          e.object(a.contract.pool),
+          e.pure.u8(a.id),
+          s,
+          e.object(t.incentiveV2),
+          e.object(t.incentiveV3),
+          g(r.accountCap, e.object)
+        ],
+        typeArguments: [a.suiCoinType]
+      });
+      i = u;
+    } else {
+      const [u] = e.moveCall({
+        target: `${t.package}::incentive_v3::borrow`,
+        arguments: [
+          e.object("0x06"),
+          e.object(t.priceOracle),
+          e.object(t.storage),
+          e.object(a.contract.pool),
+          e.pure.u8(a.id),
+          s,
+          e.object(t.incentiveV2),
+          e.object(t.incentiveV3)
+        ],
+        typeArguments: [a.suiCoinType]
+      });
+      i = u;
     }
-    candidates.sort((a, b) => a.rate.borrowApy - b.rate.borrowApy);
-    return candidates[0];
+  else if (r?.accountCap) {
+    const [u] = e.moveCall({
+      target: `${t.package}::incentive_v3::borrow_with_account_cap_v2`,
+      arguments: [
+        e.object("0x06"),
+        e.object(t.priceOracle),
+        e.object(t.storage),
+        e.object(a.contract.pool),
+        e.pure.u8(a.id),
+        s,
+        e.object(t.incentiveV2),
+        e.object(t.incentiveV3),
+        g(r.accountCap, e.object),
+        e.object("0x05")
+      ],
+      typeArguments: [a.suiCoinType]
+    });
+    i = u;
+  } else {
+    const [u] = e.moveCall({
+      target: `${t.package}::incentive_v3::borrow_v2`,
+      arguments: [
+        e.object("0x06"),
+        e.object(t.priceOracle),
+        e.object(t.storage),
+        e.object(a.contract.pool),
+        e.pure.u8(a.id),
+        s,
+        e.object(t.incentiveV2),
+        e.object(t.incentiveV3),
+        e.object("0x05")
+      ],
+      typeArguments: [a.suiCoinType]
+    });
+    i = u;
   }
-  async bestSaveRateAcrossAssets() {
-    const candidates = [];
-    for (const asset of STABLE_ASSETS) {
-      for (const adapter of this.lending.values()) {
-        if (!adapter.supportedAssets.includes(asset)) continue;
-        if (!adapter.capabilities.includes("save")) continue;
-        try {
-          const rate = await adapter.getRates(asset);
-          candidates.push({ adapter, rate, asset });
-        } catch {
-        }
-      }
+  return e.moveCall({
+    target: "0x2::coin::from_balance",
+    arguments: [e.object(i)],
+    typeArguments: [a.suiCoinType]
+  });
+}
+async function xe(e, n, o, r) {
+  const t = await k({
+    ...r,
+    cacheTime: w
+  }), a = await A(n, r), s = typeof o == "object" && o.$kind === "GasCoin";
+  if (b(a.suiCoinType) === b("0x2::sui::SUI") && s) {
+    if (!r?.amount)
+      throw new Error("Amount is required for sui coin");
+    o = e.splitCoins(o, [r.amount]);
+  }
+  let i;
+  if (typeof r?.amount < "u" ? i = g(r.amount, e.pure.u64) : i = e.moveCall({
+    target: "0x2::coin::value",
+    arguments: [g(o, e.object)],
+    typeArguments: [a.suiCoinType]
+  }), r?.accountCap) {
+    const [c] = e.moveCall({
+      target: `${t.package}::incentive_v3::repay_with_account_cap`,
+      arguments: [
+        e.object("0x06"),
+        e.object(t.priceOracle),
+        e.object(t.storage),
+        e.object(a.contract.pool),
+        e.pure.u8(a.id),
+        g(o, e.object),
+        e.object(t.incentiveV2),
+        e.object(t.incentiveV3),
+        g(r.accountCap, e.object)
+      ],
+      typeArguments: [a.suiCoinType]
+    });
+    return e.moveCall({
+      target: "0x2::coin::from_balance",
+      arguments: [c],
+      typeArguments: [a.suiCoinType]
+    });
+  } else
+    return e.moveCall({
+      target: `${t.package}::incentive_v3::entry_repay`,
+      arguments: [
+        e.object("0x06"),
+        e.object(t.priceOracle),
+        e.object(t.storage),
+        e.object(a.contract.pool),
+        e.pure.u8(a.id),
+        g(o, e.object),
+        i,
+        e.object(t.incentiveV2),
+        e.object(t.incentiveV3)
+      ],
+      typeArguments: [a.suiCoinType]
+    }), e;
+}
+var N = "main";
+var M = {
+  main: {
+    id: 0,
+    key: "main",
+    name: "Main Market"
+  }
+};
+var _ = (e) => {
+  const o = Object.values(M).find((r) => typeof e == "number" ? r.id === e : typeof e == "string" ? r.key === e : r.id === e.id);
+  if (!o)
+    throw new Error("Market not found");
+  return o;
+};
+var k = $(
+  B(
+    async (e) => {
+      const n = _(e?.market || N), o = `https://open-api.naviprotocol.io/api/navi/config?env=${e?.env || "prod"}&sdk=${V.version}&market=${n.key}`;
+      return (await fetch(o, { headers: E }).then((t) => t.json())).data;
     }
-    if (candidates.length === 0) {
-      throw new T2000Error("ASSET_NOT_SUPPORTED", "No lending adapter found for any stablecoin");
+  )
+);
+var w = 1e3 * 60 * 5;
+var x = $(
+  B(
+    async (e, n) => {
+      const o = await k({
+        cacheTime: w,
+        ...n
+      }), r = new transactions.Transaction(), t = n?.client ?? P;
+      r.moveCall({
+        target: `${o.emode.contract.registryPackage}::registry::find_user_emode_account_caps`,
+        arguments: [r.object(o.emode.contract.registryObject), r.pure.address(e)]
+      });
+      const s = (await t.devInspectTransactionBlock({
+        transactionBlock: r,
+        sender: e
+      })).results[0].returnValues, i = bcs$1.bcs.vector(bcs$1.bcs.u64()).parse(Uint8Array.from(s[0][0])), c = bcs$1.bcs.vector(bcs$1.bcs.u64()).parse(Uint8Array.from(s[1][0])), u = bcs$1.bcs.vector(bcs$1.bcs.Address).parse(Uint8Array.from(s[2][0]));
+      return i.map((d, f) => ({
+        marketId: Number(d),
+        emodeId: Number(c[f]),
+        accountCap: u[f].toString()
+      }));
     }
-    candidates.sort((a, b) => b.rate.saveApy - a.rate.saveApy);
-    return candidates[0];
+  )
+);
+async function ee(e, n, o, r, t, a, s) {
+  const i = await k({
+    ...s,
+    cacheTime: w
+  }), c = await A(o, s);
+  return e.moveCall({
+    target: `${i.uiGetter}::calculator_unchecked::dynamic_health_factor`,
+    arguments: [
+      e.object("0x06"),
+      e.object(i.storage),
+      e.object(i.oracle.priceOracle),
+      we(e, c),
+      g(n, e.pure.address),
+      g(c.id, e.pure.u8),
+      g(r, e.pure.u64),
+      g(t, e.pure.u64),
+      g(a, e.pure.bool)
+    ],
+    typeArguments: [c.suiCoinType]
+  });
+}
+async function Ae(e, n, o) {
+  return ee(e, n, 0, 0, 0, false, o);
+}
+async function te(e, n, o) {
+  const r = new transactions.Transaction(), t = o?.client ?? P, a = await R({
+    ...o,
+    markets: Object.values(M)
+  }), s = H(a);
+  for (let d of n) {
+    const f = await k({
+      ...o,
+      cacheTime: w,
+      market: d.market
+    });
+    r.moveCall({
+      target: `${f.uiGetter}::getter_unchecked::get_user_state`,
+      arguments: [r.object(f.storage), r.pure.address(d.address)]
+    });
   }
-  async allRatesAcrossAssets() {
-    const results = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const asset of STABLE_ASSETS) {
-      if (seen.has(asset)) continue;
-      seen.add(asset);
-      for (const adapter of this.lending.values()) {
-        if (!adapter.supportedAssets.includes(asset)) continue;
-        try {
-          const rates = await adapter.getRates(asset);
-          if (rates.saveApy > 0 || rates.borrowApy > 0) {
-            results.push({ protocol: adapter.name, protocolId: adapter.id, asset, rates });
-          }
-        } catch {
+  const c = ((await t.devInspectTransactionBlock({
+    transactionBlock: r,
+    sender: e
+  })).results || []).map((d) => d.returnValues?.map((f) => bcs$1.bcs.vector(fe).parse(Uint8Array.from(f[0])))[0] || []), u = [];
+  return c.forEach((d, f) => {
+    const v = n[f], y = _(v.market);
+    d.forEach((l) => {
+      if (l.supply_balance === "0" && l.borrow_balance === "0" && (v.emodeId === void 0 || !o?.includeZeroBalanceEmodePositions))
+        return;
+      const h = s[`${y.key}-${l.asset_id}`];
+      if (!h)
+        return;
+      const j = Y(
+        l.supply_balance,
+        h.currentSupplyIndex
+      ).toString(), I = Y(
+        l.borrow_balance,
+        h.currentBorrowIndex
+      ).toString();
+      u.push({
+        supplyBalance: j,
+        borrowBalance: I,
+        assetId: l.asset_id,
+        market: y.key,
+        pool: h,
+        emodeId: v.emodeId
+      });
+    });
+  }), u;
+}
+async function ct(e, n) {
+  const o = n?.client ?? P, r = new transactions.Transaction();
+  await Ae(r, e, n);
+  const t = await o.devInspectTransactionBlock({
+    transactionBlock: r,
+    sender: e
+  }), a = L(t, [bcs$1.bcs.u256()]);
+  return X(Number(a[0]) || 0);
+}
+var $e = $(
+  async (e, n) => {
+    const o = [], r = (n?.markets || Object.keys(M)).map((i) => _(i));
+    let t = [];
+    try {
+      t = await x(e, n);
+    } catch (i) {
+      console.error(i);
+    }
+    const a = r.map((i) => ({
+      address: e,
+      market: i.key
+    })).concat(
+      t.filter((i) => !!r.find((c) => c.id === i.marketId)).map((i) => ({
+        address: i.accountCap,
+        market: _(i.marketId).key,
+        emodeId: i.emodeId
+      }))
+    );
+    return (await te(e, a, n)).forEach((i) => {
+      const c = typeof i.emodeId == "number" ? t.find((u) => {
+        const d = _(i.market);
+        return u.emodeId === i.emodeId && u.marketId === d.id;
+      }) : void 0;
+      if (c) {
+        if (!i.pool.emodes.find((d) => d.emodeId === c.emodeId))
+          return;
+        if (bignumber_default(i.supplyBalance).gte(0)) {
+          const d = bignumber_default(i.supplyBalance).shiftedBy(-9).decimalPlaces(i.pool.token.decimals, bignumber_default.ROUND_DOWN), f = q(i.pool, c);
+          if (d.gt(0) || f.emode.isCollateral)
+            try {
+              o.push({
+                id: `${i.pool.uniqueId}_${c.emodeId}_navi-lending-emode-supply-${T()}`,
+                wallet: e,
+                protocol: "navi",
+                market: i.market,
+                type: "navi-lending-emode-supply",
+                "navi-lending-emode-supply": {
+                  amount: d.toString(),
+                  pool: q(i.pool, c),
+                  token: i.pool.token,
+                  valueUSD: d.multipliedBy(i.pool.oracle.price).toString(),
+                  emodeCap: c
+                }
+              });
+            } catch (v) {
+              console.error(v);
+            }
+        }
+        if (bignumber_default(i.borrowBalance).gte(0)) {
+          const d = bignumber_default(i.borrowBalance).shiftedBy(-9).decimalPlaces(i.pool.token.decimals, bignumber_default.ROUND_DOWN), f = q(i.pool, c);
+          if (d.gt(0) || f.emode.isDebt)
+            try {
+              o.push({
+                id: `${i.pool.uniqueId}_${c.emodeId}_navi-lending-emode-borrow-${T()}`,
+                wallet: e,
+                protocol: "navi",
+                market: i.market,
+                type: "navi-lending-emode-borrow",
+                "navi-lending-emode-borrow": {
+                  amount: d.toString(),
+                  pool: q(i.pool, c),
+                  token: i.pool.token,
+                  valueUSD: d.multipliedBy(i.pool.oracle.price).toString(),
+                  emodeCap: c
+                }
+              });
+            } catch (v) {
+              console.error(v);
+            }
+        }
+      } else {
+        if (bignumber_default(i.supplyBalance).gt(0)) {
+          const u = bignumber_default(i.supplyBalance).shiftedBy(-9).decimalPlaces(i.pool.token.decimals, bignumber_default.ROUND_DOWN);
+          o.push({
+            id: `${i.pool.uniqueId}_navi-lending-supply-${T()}`,
+            wallet: e,
+            protocol: "navi",
+            type: "navi-lending-supply",
+            market: i.market,
+            "navi-lending-supply": {
+              amount: u.toString(),
+              pool: i.pool,
+              token: i.pool.token,
+              valueUSD: u.multipliedBy(i.pool.oracle.price).toString()
+            }
+          });
+        }
+        if (bignumber_default(i.borrowBalance).gt(0)) {
+          const u = bignumber_default(i.borrowBalance).shiftedBy(-9).decimalPlaces(i.pool.token.decimals, bignumber_default.ROUND_DOWN);
+          o.push({
+            id: `${i.pool.uniqueId}_navi-lending-borrow-${T()}`,
+            wallet: e,
+            protocol: "navi",
+            market: i.market,
+            type: "navi-lending-borrow",
+            "navi-lending-borrow": {
+              amount: u.toString(),
+              pool: i.pool,
+              token: i.pool.token,
+              valueUSD: u.multipliedBy(i.pool.oracle.price).toString()
+            }
+          });
         }
       }
-    }
-    return results;
+    }), o;
   }
-  async allRates(asset) {
-    const results = [];
-    for (const adapter of this.lending.values()) {
-      if (!adapter.supportedAssets.includes(asset)) continue;
-      try {
-        const rates = await adapter.getRates(asset);
-        results.push({ protocol: adapter.name, protocolId: adapter.id, rates });
-      } catch {
+);
+var oe = new pythSuiJs.SuiPriceServiceConnection("https://hermes.pyth.network", {
+  timeout: 1e4
+});
+async function Pe(e, n) {
+  try {
+    const o = [], r = n?.client ?? P, t = e.map((s) => s.priceInfoObject), a = await r.multiGetObjects({
+      ids: Array.from(new Set(t)),
+      options: { showContent: true }
+    });
+    for (const s of a) {
+      const i = s.data;
+      if (!i || !i.content || i.content.dataType !== "moveObject") {
+        console.warn(`fetched object ${i?.objectId} datatype should be moveObject`);
+        continue;
+      }
+      const c = e.find((l) => l.priceInfoObject == i.objectId);
+      if (!c) {
+        console.warn(`unable to find pyth info from array, priceInfoObject: ${i.objectId}`);
+        continue;
       }
+      const u = i.content.fields.price_info.fields.price_feed.fields.price.fields, { magnitude: d, negative: f } = u.price.fields, v = u.conf, y = u.timestamp;
+      o.push({
+        priceFeedId: c.priceFeedId,
+        priceInfoObject: c.priceInfoObject,
+        price: f ? "-" + d : d,
+        conf: v,
+        publishTime: Number(y),
+        expiration: c.expiration
+      });
     }
-    return results;
+    return o;
+  } catch (o) {
+    console.error(o, `Polling Sui on-chain price for ${e} failed.`);
+    return;
   }
-  async allPositions(address) {
-    const results = [];
-    const errors = [];
-    for (const adapter of this.lending.values()) {
-      try {
-        const positions = await adapter.getPositions(address);
-        if (positions.supplies.length > 0 || positions.borrows.length > 0) {
-          results.push({ protocol: adapter.name, protocolId: adapter.id, positions });
-        }
-      } catch (err) {
-        errors.push(`${adapter.name}: ${err instanceof Error ? err.message : String(err)}`);
+}
+async function Se(e, n) {
+  try {
+    const o = [], r = await Pe(e, n);
+    if (!r) return o;
+    const t = Math.floor((/* @__PURE__ */ new Date()).valueOf() / 1e3);
+    for (const a of r) {
+      if (a.publishTime > t) {
+        console.warn(
+          `pyth price feed is invalid, id: ${a.priceFeedId}, publish time: ${a.publishTime}, current timestamp: ${t}`
+        );
+        continue;
       }
+      const s = a.expiration || 60;
+      t - a.publishTime > s && (console.info(
+        `stale price feed, id: ${a.priceFeedId}, publish time: ${a.publishTime}, current timestamp: ${t}`
+      ), o.push(a.priceFeedId));
     }
-    if (results.length === 0 && errors.length > 0) {
-      throw new T2000Error("PROTOCOL_UNAVAILABLE", `Protocol queries failed (${errors.length}/${this.lending.size}): ${errors.join("; ")}`);
+    return o;
+  } catch (o) {
+    throw new Error(`failed to get pyth stale price feed id, msg: ${o.message}`);
+  }
+}
+async function Ve(e, n, o) {
+  const r = o?.client ?? P, t = await k({
+    ...o,
+    cacheTime: w
+  });
+  try {
+    const a = await oe.getPriceFeedsUpdateData(n);
+    return await new pythSuiJs.SuiPythClient(
+      r,
+      t.oracle.pythStateId,
+      t.oracle.wormholeStateId
+    ).updatePriceFeeds(e, a, n);
+  } catch (a) {
+    throw new Error(`failed to update pyth price feeds, msg: ${a.message}`);
+  }
+}
+async function Ee(e, n, o) {
+  const r = await k({
+    ...o,
+    cacheTime: w
+  });
+  if (o?.updatePythPriceFeeds) {
+    const t = n.filter((a) => !!a.pythPriceFeedId && !!a.pythPriceInfoObject).map((a) => ({
+      priceFeedId: a.pythPriceFeedId,
+      priceInfoObject: a.pythPriceInfoObject,
+      expiration: 30
+    }));
+    try {
+      const a = await Se(t, o);
+      a.length > 0 && await Ve(e, a, o);
+    } catch {
+      console.error("Failed to update Pyth price feeds");
     }
-    return results;
   }
-  getLending(id) {
-    return this.lending.get(id);
+  for (const t of n)
+    o?.env === "dev" ? e.moveCall({
+      target: `${r.oracle.packageId}::oracle_pro::update_single_price`,
+      arguments: [
+        e.object("0x6"),
+        // Clock object
+        e.object(r.oracle.oracleConfig),
+        // Oracle configuration
+        e.object(r.oracle.priceOracle),
+        // Price oracle contract
+        e.object(r.oracle.supraOracleHolder),
+        // Supra oracle holder
+        e.object(t.pythPriceInfoObject),
+        // Pyth price info object
+        e.pure.address(t.feedId)
+        // Price feed ID
+      ]
+    }) : e.moveCall({
+      target: `${r.oracle.packageId}::oracle_pro::update_single_price_v2`,
+      arguments: [
+        e.object("0x6"),
+        // Clock object
+        e.object(r.oracle.oracleConfig),
+        // Oracle configuration
+        e.object(r.oracle.priceOracle),
+        // Price oracle contract
+        e.object(r.oracle.supraOracleHolder),
+        // Supra oracle holder
+        e.object(t.pythPriceInfoObject),
+        // Pyth price info object
+        e.object(r.oracle.switchboardAggregator),
+        e.pure.address(t.feedId)
+        // Price feed ID
+      ]
+    });
+  return e;
+}
+async function ne(e) {
+  return (await k({
+    ...e,
+    cacheTime: w
+  })).oracle.feeds;
+}
+function Me(e, n) {
+  return e.filter((o) => !!(n?.lendingState && n.lendingState.find((t) => t.assetId === o.assetId) || n?.lendingPositions && n.lendingPositions.find((t) => [
+    "navi-lending-supply",
+    "navi-lending-borrow",
+    "navi-lending-emode-supply",
+    "navi-lending-emode-borrow"
+  ].includes(t.type) ? t[t.type]?.pool?.id === o.assetId : false) || n?.pools && n.pools.find((t) => t.id === o.assetId)));
+}
+async function mt(e, n, o, r) {
+  try {
+    const t = await ne({
+      ...r
+    }), a = [];
+    o.forEach((u) => {
+      a.includes(u.market) || a.push(u.market);
+    });
+    const s = await $e(n, {
+      ...r,
+      markets: a
+    }), i = Me(t, {
+      lendingPositions: s,
+      pools: o
+    });
+    return await Ee(e, i, {
+      updatePythPriceFeeds: true,
+      ...r
+    });
+  } catch (t) {
+    if (r?.throws)
+      throw t;
+    return console.error(t), e;
   }
-  listLending() {
-    return [...this.lending.values()];
+}
+async function De(e, n, o) {
+  const r = o?.client ?? P, t = new transactions.Transaction(), a = await R({
+    ...o,
+    markets: Object.values(M),
+    cacheTime: w
+  }), s = await ne(o);
+  for (let d of n) {
+    const f = await k({
+      ...o,
+      cacheTime: w,
+      market: d.market
+    });
+    t.moveCall({
+      target: `${f.uiGetter}::incentive_v3_getter::get_user_atomic_claimable_rewards`,
+      arguments: [
+        t.object("0x06"),
+        // Clock object
+        t.object(f.storage),
+        // Protocol storage
+        t.object(f.incentiveV3),
+        // Incentive V3 contract
+        t.pure.address(d.address)
+        // User address
+      ]
+    });
   }
-};
-
-// src/utils/format.ts
-function stableToRaw(amount, decimals) {
-  return BigInt(Math.round(amount * 10 ** decimals));
+  const i = await r.devInspectTransactionBlock({
+    transactionBlock: t,
+    sender: e
+  }), c = [];
+  i?.results?.forEach((d) => {
+    c.push(
+      L(
+        {
+          results: [d]
+        },
+        [
+          bcs$1.bcs.vector(bcs$1.bcs.string()),
+          // Asset coin types
+          bcs$1.bcs.vector(bcs$1.bcs.string()),
+          // Reward coin types
+          bcs$1.bcs.vector(bcs$1.bcs.u8()),
+          // Reward options
+          bcs$1.bcs.vector(bcs$1.bcs.Address),
+          // Rule IDs
+          bcs$1.bcs.vector(bcs$1.bcs.u256())
+          // Claimable amounts
+        ]
+      )
+    );
+  });
+  const u = [];
+  return c.forEach((d, f) => {
+    const v = n[f];
+    if (d.length === 5 && Array.isArray(d[0])) {
+      const y = d[0].length;
+      for (let l = 0; l < y; l++) {
+        const h = s.find(
+          (I) => b(I.coinType) === b(d[1][l])
+        ), j = a.find(
+          (I) => b(I.coinType) === b(d[0][l]) && I.market === v.market
+        );
+        !h || !j || u.push({
+          assetId: j.id,
+          assetCoinType: b(d[0][l]),
+          rewardCoinType: b(d[1][l]),
+          option: Number(d[2][l]),
+          userClaimableReward: Number(d[4][l]) / Math.pow(10, h.priceDecimal),
+          ruleIds: Array.isArray(d[3][l]) ? d[3][l] : [d[3][l]],
+          market: v.market,
+          owner: v.owner,
+          address: v.address,
+          emodeId: v.emodeId
+        });
+      }
+    }
+  }), u;
 }
-var ASSET_LOOKUP = /* @__PURE__ */ new Map();
-for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
-  ASSET_LOOKUP.set(key.toUpperCase(), key);
-  if (info.displayName && info.displayName.toUpperCase() !== key.toUpperCase()) {
-    ASSET_LOOKUP.set(info.displayName.toUpperCase(), key);
+async function vt(e, n) {
+  const o = (n?.markets || [M.main]).map((a) => _(a));
+  let r = [];
+  try {
+    r = await x(e, n);
+  } catch (a) {
+    console.error(a);
   }
+  const t = o.map((a) => ({
+    address: e,
+    owner: e,
+    market: a.key
+  })).concat(
+    r.filter((a) => !!o.find((s) => s.id === a.marketId)).map((a) => {
+      const s = _(a.marketId);
+      return {
+        address: a.accountCap,
+        owner: e,
+        market: s.key,
+        emodeId: a.emodeId
+      };
+    })
+  );
+  return await De(e, t, n);
 }
-function normalizeAsset(input) {
-  return ASSET_LOOKUP.get(input.toUpperCase()) ?? input;
+function wt(e) {
+  const n = /* @__PURE__ */ new Map();
+  e.forEach((r) => {
+    const t = r.assetId, a = r.option, s = `${t}-${a}-${r.rewardCoinType}-${r.market}`;
+    n.has(s) ? n.get(s).total += r.userClaimableReward : n.set(s, {
+      assetId: t,
+      rewardType: a,
+      coinType: r.rewardCoinType,
+      total: Number(r.userClaimableReward),
+      market: r.market
+    });
+  });
+  const o = /* @__PURE__ */ new Map();
+  for (const { assetId: r, rewardType: t, coinType: a, total: s, market: i } of n.values()) {
+    const c = `${r}-${t}-${i}`;
+    o.has(c) || o.set(c, { assetId: r, rewardType: t, market: i, rewards: /* @__PURE__ */ new Map() });
+    const u = o.get(c);
+    u.rewards.set(a, (u.rewards.get(a) || 0) + s);
+  }
+  return Array.from(o.values()).map((r) => ({
+    assetId: r.assetId,
+    rewardType: r.rewardType,
+    market: r.market,
+    rewards: Array.from(r.rewards.entries()).map(([t, a]) => ({
+      coinType: t,
+      available: a.toFixed(6)
+    }))
+  }));
+}
+async function Ct(e, n, o) {
+  const r = await R({
+    ...o,
+    markets: Object.values(M),
+    cacheTime: w
+  }), t = /* @__PURE__ */ new Map();
+  for (const s of n) {
+    const { rewardCoinType: i, ruleIds: c, market: u, owner: d, address: f, emodeId: v } = s, y = `${i}___${f}`;
+    for (const l of c) {
+      t.has(y) || t.set(y, {
+        assetIds: [],
+        ruleIds: [],
+        amount: 0,
+        market: u,
+        owner: d,
+        address: f,
+        isEMode: typeof v < "u"
+      });
+      const h = t.get(y);
+      h.assetIds.push(s.assetCoinType.replace("0x", "")), h.ruleIds.push(l), h.amount += s.userClaimableReward;
+    }
+  }
+  const a = [];
+  for (const [
+    s,
+    { assetIds: i, ruleIds: c, amount: u, market: d, owner: f, address: v, isEMode: y }
+  ] of t) {
+    const l = await k({
+      ...o,
+      cacheTime: w,
+      market: d
+    }), h = s.split("___")[0], j = r.find(
+      (S) => b(S.suiCoinType) === b(h) && S.market === d
+    );
+    if (!j || !j.contract.rewardFundId)
+      throw new Error(`No matching rewardFund found for reward coin: ${h} ${d}`);
+    const I = j.contract.rewardFundId;
+    if (o?.accountCap && !o.customCoinReceive)
+      throw new Error("customCoinReceive is required when accountCap is provided");
+    if (o?.customCoinReceive) {
+      let S;
+      o.accountCap ? S = e.moveCall({
+        target: `${l.package}::incentive_v3::claim_reward_with_account_cap`,
+        arguments: [
+          e.object("0x06"),
+          // Clock object
+          e.object(l.incentiveV3),
+          // Incentive V3 contract
+          e.object(l.storage),
+          // Protocol storage
+          e.object(I),
+          // Reward fund
+          e.pure.vector("string", i),
+          // Asset IDs
+          e.pure.vector("address", c),
+          // Rule IDs
+          g(o.accountCap, e.object)
+          // Account capability
+        ],
+        typeArguments: [h]
+      }) : y ? S = e.moveCall({
+        target: `${l.package}::incentive_v3::claim_reward_with_account_cap`,
+        arguments: [
+          e.object("0x06"),
+          // Clock object
+          e.object(l.incentiveV3),
+          // Incentive V3 contract
+          e.object(l.storage),
+          // Protocol storage
+          e.object(I),
+          // Reward fund
+          e.pure.vector("string", i),
+          // Asset IDs
+          e.pure.vector("address", c),
+          // Rule IDs
+          g(v, e.object)
+          // Account capability
+        ],
+        typeArguments: [h]
+      }) : S = e.moveCall({
+        target: `${l.package}::incentive_v3::claim_reward`,
+        arguments: [
+          e.object("0x06"),
+          // Clock object
+          e.object(l.incentiveV3),
+          // Incentive V3 contract
+          e.object(l.storage),
+          // Protocol storage
+          e.object(I),
+          // Reward fund
+          e.pure.vector("string", i),
+          // Asset IDs
+          e.pure.vector("address", c)
+          // Rule IDs
+        ],
+        typeArguments: [h]
+      });
+      const [D] = e.moveCall({
+        target: "0x2::coin::from_balance",
+        arguments: [S],
+        typeArguments: [h]
+      });
+      if (o?.customCoinReceive.type === "transfer") {
+        if (!o.customCoinReceive.transfer)
+          throw new Error("customCoinReceive.transfer is required");
+        e.transferObjects(
+          [D],
+          g(o.customCoinReceive.transfer, e.pure.address)
+        );
+      }
+      if (o?.customCoinReceive.type === "depositNAVI") {
+        const re = bignumber_default(j.totalSupplyAmount).shiftedBy(-9), ae = bignumber_default(j.supplyCapCeiling).shiftedBy(-27);
+        re.plus(u).isGreaterThan(ae) && o?.customCoinReceive.depositNAVI?.fallbackReceiveAddress ? e.transferObjects(
+          [D],
+          e.pure.address(o.customCoinReceive.depositNAVI.fallbackReceiveAddress)
+        ) : await Ce(e, j, D, o);
+      } else
+        a.push({
+          coin: D,
+          identifier: j,
+          owner: f,
+          isEMode: y
+        });
+    } else if (o?.accountCap || y) {
+      const S = e.moveCall({
+        target: `${l.package}::incentive_v3::claim_reward_with_account_cap`,
+        arguments: [
+          e.object("0x06"),
+          // Clock object
+          e.object(l.incentiveV3),
+          // Incentive V3 contract
+          e.object(l.storage),
+          // Protocol storage
+          e.object(I),
+          // Reward fund
+          e.pure.vector("string", i),
+          // Asset IDs
+          e.pure.vector("address", c),
+          // Rule IDs
+          g(o?.accountCap || v, e.object)
+          // Account capability
+        ],
+        typeArguments: [h]
+      }), [D] = e.moveCall({
+        target: "0x2::coin::from_balance",
+        arguments: [S],
+        typeArguments: [h]
+      });
+      e.transferObjects(
+        [D],
+        g(o?.accountCap || f, e.pure.address)
+      );
+    } else
+      e.moveCall({
+        target: `${l.package}::incentive_v3::claim_reward_entry`,
+        arguments: [
+          e.object("0x06"),
+          // Clock object
+          e.object(l.incentiveV3),
+          // Incentive V3 contract
+          e.object(l.storage),
+          // Protocol storage
+          e.object(I),
+          // Reward fund
+          e.pure.vector("string", i),
+          // Asset IDs
+          e.pure.vector("address", c)
+          // Rule IDs
+        ],
+        typeArguments: [h]
+      });
+  }
+  return a;
 }
 
 // src/protocols/protocolFee.ts
@@ -265,7 +4273,7 @@ async function refreshOracle(tx, client, address, options) {
     origWarn.apply(console, args);
   };
   try {
-    const pools = await lending.getPools(sdkOptions(client));
+    const pools = await R(sdkOptions(client));
     const oracleOpts = {
       ...sdkOptions(client),
       throws: false,
@@ -273,7 +4281,7 @@ async function refreshOracle(tx, client, address, options) {
       // with sponsored transactions where tx.gas belongs to the sponsor.
       updatePythPriceFeeds: !options?.skipPythUpdate
     };
-    await lending.updateOraclePriceBeforeUserOperationPTB(tx, address, pools, oracleOpts);
+    await mt(tx, address, pools, oracleOpts);
   } catch {
   } finally {
     console.info = origInfo;
@@ -335,7 +4343,7 @@ function mergeCoins(tx, coins) {
 }
 async function getPositions(client, address) {
   try {
-    const naviPositions = await lending.getLendingPositions(address, {
+    const naviPositions = await $e(address, {
       ...sdkOptions(client),
       markets: ["main"]
     });
@@ -369,7 +4377,7 @@ async function getPositions(client, address) {
 }
 async function getRates(client) {
   try {
-    const pools = await lending.getPools(sdkOptions(client));
+    const pools = await R(sdkOptions(client));
     const result = {};
     for (const asset of ALL_NAVI_ASSETS) {
       const targetType = SUPPORTED_ASSETS[asset].type;
@@ -402,7 +4410,7 @@ async function getHealthFactor(client, address) {
   }
   let healthFactor;
   try {
-    const hf = await lending.getHealthFactor(address, sdkOptions(client));
+    const hf = await ct(address, sdkOptions(client));
     healthFactor = hf > 1e5 ? Infinity : hf;
   } catch {
     healthFactor = borrowed > 0 ? supplied * 0.75 / borrowed : Infinity;
@@ -434,7 +4442,7 @@ async function buildSaveTx(client, address, amount, options = {}) {
   }
   const rawAmount = Math.min(Number(stableToRaw(amount, assetInfo.decimals)), Number(totalBalance));
   try {
-    await lending.depositCoinPTB(tx, assetInfo.type, coinObj, {
+    await Ce(tx, assetInfo.type, coinObj, {
       ...sdkOptions(client),
       amount: rawAmount
     });
@@ -463,7 +4471,7 @@ async function buildWithdrawTx(client, address, amount, options = {}) {
   tx.setSender(address);
   await refreshOracle(tx, client, address, { skipPythUpdate: options.sponsored });
   try {
-    const coin = await lending.withdrawCoinPTB(tx, assetInfo.type, rawAmount, sdkOptions(client));
+    const coin = await Qe(tx, assetInfo.type, rawAmount, sdkOptions(client));
     tx.transferObjects([coin], address);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -493,7 +4501,7 @@ async function addWithdrawToTx(tx, client, address, amount, options = {}) {
   }
   await refreshOracle(tx, client, address, { skipPythUpdate: sponsored });
   try {
-    const coin = await lending.withdrawCoinPTB(tx, assetInfo.type, rawAmount, sdkOptions(client));
+    const coin = await Qe(tx, assetInfo.type, rawAmount, sdkOptions(client));
     return { coin, effectiveAmount };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -507,7 +4515,7 @@ async function addSaveToTx(tx, _client, _address, coin, options = {}) {
     addCollectFeeToTx(tx, coin, "save");
   }
   try {
-    await lending.depositCoinPTB(tx, assetInfo.type, coin, { env: "prod" });
+    await Ce(tx, assetInfo.type, coin, { env: "prod" });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI deposit failed: ${msg}`);
@@ -519,7 +4527,7 @@ async function addRepayToTx(tx, client, address, coin, options = {}) {
   const assetInfo = resolveAssetInfo(asset);
   await refreshOracle(tx, client, address, { skipPythUpdate: sponsored });
   try {
-    await lending.repayCoinPTB(tx, assetInfo.type, coin, { env: "prod" });
+    await xe(tx, assetInfo.type, coin, { env: "prod" });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new T2000Error("PROTOCOL_UNAVAILABLE", `NAVI repay failed: ${msg}`);
@@ -536,7 +4544,7 @@ async function buildBorrowTx(client, address, amount, options = {}) {
   tx.setSender(address);
   await refreshOracle(tx, client, address, { skipPythUpdate: options.sponsored });
   try {
-    const borrowedCoin = await lending.borrowCoinPTB(tx, assetInfo.type, rawAmount, sdkOptions(client));
+    const borrowedCoin = await Xe(tx, assetInfo.type, rawAmount, sdkOptions(client));
     if (options.collectFee) {
       addCollectFeeToTx(tx, borrowedCoin, "borrow");
     }
@@ -570,7 +4578,7 @@ async function buildRepayTx(client, address, amount, options = {}) {
     skipOracle: options.skipOracle
   });
   try {
-    await lending.repayCoinPTB(tx, assetInfo.type, repayCoin, {
+    await xe(tx, assetInfo.type, repayCoin, {
       ...sdkOptions(client),
       amount: rawAmount
     });
@@ -601,12 +4609,12 @@ async function maxBorrowAmount(client, address) {
 }
 async function getPendingRewards(client, address) {
   try {
-    const rewards = await lending.getUserAvailableLendingRewards(address, {
+    const rewards = await vt(address, {
       ...sdkOptions(client),
       markets: ["main"]
     });
     if (!rewards || rewards.length === 0) return [];
-    const summary = lending.summaryLendingRewards(rewards);
+    const summary = wt(rewards);
     const result = [];
     for (const s of summary) {
       for (const rw of s.rewards) {
@@ -630,7 +4638,7 @@ async function getPendingRewards(client, address) {
 }
 async function addClaimRewardsToTx(tx, client, address) {
   try {
-    const rewards = await lending.getUserAvailableLendingRewards(address, {
+    const rewards = await vt(address, {
       ...sdkOptions(client),
       markets: ["main"]
     });
@@ -639,7 +4647,7 @@ async function addClaimRewardsToTx(tx, client, address) {
       (r) => Number(r.userClaimableReward) > 0
     );
     if (claimable.length === 0) return [];
-    const claimed = await lending.claimLendingRewardsPTB(tx, claimable, {
+    const claimed = await Ct(tx, claimable, {
       env: "prod",
       customCoinReceive: { type: "transfer", transfer: address }
     });
@@ -758,6 +4766,11 @@ var NaviAdapter = class {
     return addClaimRewardsToTx(tx, this.client, address);
   }
 };
+/*! Bundled license information:
+
+@scure/base/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 
 exports.NaviAdapter = NaviAdapter;
 exports.ProtocolRegistry = ProtocolRegistry;