@scallop-io/sui-scallop-sdk 1.4.6 → 1.4.8

package/dist/index.mjs

@@ -352,7 +352,9 @@ var POOL_ADDRESSES = {
     spool: "0x0b5f5f413bd3799e4052c37311966c77f3a4545eb125d2e93e67a68478021918",
     spoolReward: "0x85ed6ed72ea97c35dbf0cdc7ed6fbc48d8ec15de9b17c74bf4512df8a6d7f166",
     sCoinTreasury: "0xbe6b63021f3d82e0e7e977cdd718ed7c019cf2eba374b7b546220402452f938e",
-    coinDecimalId: "0x69b7a7c3c200439c1b5f3b19d7d495d5966d5f08de66c69276152f8db3992ec6"
+    sCoinType: "0x854950aa624b1df59fe64e630b2ba7c550642e9342267a33061d59fb31582da5::scallop_usdc::SCALLOP_USDC",
+    coinDecimalId: "0x69b7a7c3c200439c1b5f3b19d7d495d5966d5f08de66c69276152f8db3992ec6",
+    coinType: "dba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC"
   },
   sbeth: {
     lendingPoolAddress: "0xaa34c938e0394e5186c7dc626ad69be96af2194b23fdc6ac1c63090e399f5ba4",
@@ -367,7 +369,9 @@ var POOL_ADDRESSES = {
     spool: void 0,
     spoolReward: void 0,
     sCoinTreasury: "0xfd0f02def6358a1f266acfa1493d4707ee8387460d434fb667d63d755ff907ed",
-    coinDecimalId: "0x89b04ba87f8832d4d76e17a1c9dce72eb3e64d372cf02012b8d2de5384faeef0"
+    sCoinType: "0xb14f82d8506d139eacef109688d1b71e7236bcce9b2c0ad526abcd6aa5be7de0::scallop_sb_eth::SCALLOP_SB_ETH",
+    coinDecimalId: "0x89b04ba87f8832d4d76e17a1c9dce72eb3e64d372cf02012b8d2de5384faeef0",
+    coinType: "d0e89b2af5e4910726fbcd8b8dd37bb79b29e5f83f7491bca830e94f7f226d29::eth::ETH"
   },
   weth: {
     lendingPoolAddress: "0xc8fcdff48efc265740ae0b74aae3faccae9ec00034039a113f3339798035108c",
@@ -382,7 +386,9 @@ var POOL_ADDRESSES = {
     spool: "0xeec40beccb07c575bebd842eeaabb835f77cd3dab73add433477e57f583a6787",
     spoolReward: "0x957de68a18d87817de8309b30c1ec269a4d87ae513abbeed86b5619cb9ce1077",
     sCoinTreasury: "0x4b7f5da0e306c9d52490a0c1d4091e653d6b89778b9b4f23c877e534e4d9cd21",
-    coinDecimalId: "0x8900e4ceede3363bef086d6b50ca89d816d0e90bf6bc46efefe1f8455e08f50f"
+    sCoinType: "0x67540ceb850d418679e69f1fb6b2093d6df78a2a699ffc733f7646096d552e9b::scallop_wormhole_eth::SCALLOP_WORMHOLE_ETH",
+    coinDecimalId: "0x8900e4ceede3363bef086d6b50ca89d816d0e90bf6bc46efefe1f8455e08f50f",
+    coinType: "af8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5::coin::COIN"
   },
   wbtc: {
     lendingPoolAddress: "0x65cc08a5aca0a0b8d72e1993ded8d145f06dd102fd0d8f285b92934faed564ab",
@@ -397,7 +403,9 @@ var POOL_ADDRESSES = {
     spool: void 0,
     spoolReward: void 0,
     sCoinTreasury: "0xe2883934ea42c99bc998bbe0f01dd6d27aa0e27a56455707b1b34e6a41c20baa",
-    coinDecimalId: "0x5d3c6e60eeff8a05b693b481539e7847dfe33013e7070cdcb387f5c0cac05dfd"
+    sCoinType: "0x2cf76a9cf5d3337961d1154283234f94da2dcff18544dfe5cbdef65f319591b5::scallop_wormhole_btc::SCALLOP_WORMHOLE_BTC",
+    coinDecimalId: "0x5d3c6e60eeff8a05b693b481539e7847dfe33013e7070cdcb387f5c0cac05dfd",
+    coinType: "027792d9fed7f9844eb4839566001bb6f6cb4804f66aa2da6fe1ee242d896881::coin::COIN"
   },
   wusdc: {
     lendingPoolAddress: "0x2f4df5e1368fbbdaa5c712d28b837b3d41c2d3872979ccededcdfdac55ff8a93",
@@ -412,7 +420,9 @@ var POOL_ADDRESSES = {
     spool: "0x4ace6648ddc64e646ba47a957c562c32c9599b3bba8f5ac1aadb2ae23a2f8ca0",
     spoolReward: "0xf4268cc9b9413b9bfe09e8966b8de650494c9e5784bf0930759cfef4904daff8",
     sCoinTreasury: "0x50c5cfcbcca3aaacab0984e4d7ad9a6ad034265bebb440f0d1cd688ec20b2548",
-    coinDecimalId: "0x4fbf84f3029bd0c0b77164b587963be957f853eccf834a67bb9ecba6ec80f189"
+    sCoinType: "0xad4d71551d31092230db1fd482008ea42867dbf27b286e9c70a79d2a6191d58d::scallop_wormhole_usdc::SCALLOP_WORMHOLE_USDC",
+    coinDecimalId: "0x4fbf84f3029bd0c0b77164b587963be957f853eccf834a67bb9ecba6ec80f189",
+    coinType: "5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN"
   },
   wusdt: {
     lendingPoolAddress: "0xfbc056f126dd35adc1f8fe985e2cedc8010e687e8e851e1c5b99fdf63cd1c879",
@@ -427,7 +437,9 @@ var POOL_ADDRESSES = {
     spool: "0xcb328f7ffa7f9342ed85af3fdb2f22919e1a06dfb2f713c04c73543870d7548f",
     spoolReward: "0x2c9f934d67a5baa586ceec2cc24163a2f049a6af3d5ba36b84d8ac40f25c4080",
     sCoinTreasury: "0x1f02e2fed702b477732d4ad6044aaed04f2e8e586a169153694861a901379df0",
-    coinDecimalId: "0xfb0e3eb97dd158a5ae979dddfa24348063843c5b20eb8381dd5fa7c93699e45c"
+    sCoinType: "0xe6e5a012ec20a49a3d1d57bd2b67140b96cd4d3400b9d79e541f7bdbab661f95::scallop_wormhole_usdt::SCALLOP_WORMHOLE_USDT",
+    coinDecimalId: "0xfb0e3eb97dd158a5ae979dddfa24348063843c5b20eb8381dd5fa7c93699e45c",
+    coinType: "c060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN"
   },
   sui: {
     lendingPoolAddress: "0x9c9077abf7a29eebce41e33addbcd6f5246a5221dd733e56ea0f00ae1b25c9e8",
@@ -442,7 +454,9 @@ var POOL_ADDRESSES = {
     spool: "0x4f0ba970d3c11db05c8f40c64a15b6a33322db3702d634ced6536960ab6f3ee4",
     spoolReward: "0x162250ef72393a4ad3d46294c4e1bdfcb03f04c869d390e7efbfc995353a7ee9",
     sCoinTreasury: "0x5c1678c8261ac9eec024d4d630006a9f55c80dc0b1aa38a003fcb1d425818c6b",
-    coinDecimalId: "0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3"
+    sCoinType: "0xaafc4f740de0dd0dde642a31148fb94517087052f19afb0f7bed1dc41a50c77b::scallop_sui::SCALLOP_SUI",
+    coinDecimalId: "0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3",
+    coinType: "0000000000000000000000000000000000000000000000000000000000000002::sui::SUI"
   },
   wapt: {
     lendingPoolAddress: "0xca8c14a24e0c32b198eaf479a3317461e3cc339097ce88eaf296a15df8dcfdf5",
@@ -457,22 +471,9 @@ var POOL_ADDRESSES = {
     spool: void 0,
     spoolReward: void 0,
     sCoinTreasury: void 0,
-    coinDecimalId: "0xc969c5251f372c0f34c32759f1d315cf1ea0ee5e4454b52aea08778eacfdd0a8"
-  },
-  wsol: {
-    lendingPoolAddress: "0x985682c42984cdfb03f9ff7d8923344c2fe096b1ae4b82ea17721af19d22a21f",
-    collateralPoolAddress: "0xdc1cc2c371a043ae8e3c3fe2d013c35f1346960b7dbb4c072982c5b794ed144f",
-    borrowDynamic: "0xe3f301e16d4f1273ea659dd82c5c3f124ca5a5883a5726c7ec0f77bf43b70895",
-    interestModel: "0xd95affaee077006b8dbb4b108c1b087e95fc6e5143ef0682da345d5b35bc6356",
-    riskModel: "0x8e0da6358073144ec3557400c87f04991ba3a13ca7e0d0a19daed45260b32f16",
-    borrowFeeKey: "0x604bffbc817e8e12db15f2373a9e15b2c7adbc510649cdf2cc62a594af90671c",
-    supplyLimitKey: "0xbd419b536b3f9c9d4adfc20372ca6feedc53cc31798ac860dbfc847bcf05f54b",
-    borrowLimitKey: "0x77d453c51948f32564c810bc73f9ba7abde880657b7f89e1c8a3bc28fa36ee87",
-    isolatedAssetKey: void 0,
-    spool: void 0,
-    spoolReward: void 0,
-    sCoinTreasury: "0x760fd66f5be869af4382fa32b812b3c67f0eca1bb1ed7a5578b21d56e1848819",
-    coinDecimalId: "0x4d2c39082b4477e3e79dc4562d939147ab90c42fc5f3e4acf03b94383cd69b6e"
+    sCoinType: void 0,
+    coinDecimalId: "0xc969c5251f372c0f34c32759f1d315cf1ea0ee5e4454b52aea08778eacfdd0a8",
+    coinType: "3a5143bb1196e3bcdfab6203d1683ae29edd26294fc8bfeafe4aaa9d2704df37::coin::COIN"
   },
   cetus: {
     lendingPoolAddress: "0xc09858f60e74a1b671635bec4e8a2c84a0ff313eb87f525fba3258e88c6b6282",
@@ -487,7 +488,26 @@ var POOL_ADDRESSES = {
     spool: "0xac1bb13bf4472a637c18c2415fb0e3c1227ea2bcf35242e50563c98215bd298e",
     spoolReward: "0x6835c1224126a45086fc6406adc249e3f30df18d779ca4f4e570e38716a17f3f",
     sCoinTreasury: "0xa283c63488773c916cb3d6c64109536160d5eb496caddc721eb39aad2977d735",
-    coinDecimalId: "0x4c0dce55eff2db5419bbd2d239d1aa22b4a400c01bbb648b058a9883989025da"
+    sCoinType: "0xea346ce428f91ab007210443efcea5f5cdbbb3aae7e9affc0ca93f9203c31f0c::scallop_cetus::SCALLOP_CETUS",
+    coinDecimalId: "0x4c0dce55eff2db5419bbd2d239d1aa22b4a400c01bbb648b058a9883989025da",
+    coinType: "06864a6f921804860930db6ddbe2e16acdf8504495ea7481637a1c8b9a8fe54b::cetus::CETUS"
+  },
+  wsol: {
+    lendingPoolAddress: "0x985682c42984cdfb03f9ff7d8923344c2fe096b1ae4b82ea17721af19d22a21f",
+    collateralPoolAddress: "0xdc1cc2c371a043ae8e3c3fe2d013c35f1346960b7dbb4c072982c5b794ed144f",
+    borrowDynamic: "0xe3f301e16d4f1273ea659dd82c5c3f124ca5a5883a5726c7ec0f77bf43b70895",
+    interestModel: "0xd95affaee077006b8dbb4b108c1b087e95fc6e5143ef0682da345d5b35bc6356",
+    riskModel: "0x8e0da6358073144ec3557400c87f04991ba3a13ca7e0d0a19daed45260b32f16",
+    borrowFeeKey: "0x604bffbc817e8e12db15f2373a9e15b2c7adbc510649cdf2cc62a594af90671c",
+    supplyLimitKey: "0xbd419b536b3f9c9d4adfc20372ca6feedc53cc31798ac860dbfc847bcf05f54b",
+    borrowLimitKey: "0x77d453c51948f32564c810bc73f9ba7abde880657b7f89e1c8a3bc28fa36ee87",
+    isolatedAssetKey: void 0,
+    spool: void 0,
+    spoolReward: void 0,
+    sCoinTreasury: "0x760fd66f5be869af4382fa32b812b3c67f0eca1bb1ed7a5578b21d56e1848819",
+    sCoinType: "0x1392650f2eca9e3f6ffae3ff89e42a3590d7102b80e2b430f674730bc30d3259::scallop_wormhole_sol::SCALLOP_WORMHOLE_SOL",
+    coinDecimalId: "0x4d2c39082b4477e3e79dc4562d939147ab90c42fc5f3e4acf03b94383cd69b6e",
+    coinType: "b7844e289a8410e50fb3ca48d69eb9cf29e27d223ef90353fe1bd8e27ff8f3f8::coin::COIN"
   },
   afsui: {
     lendingPoolAddress: "0x9b942a24ce390b7f5016d34a0217057bf9487b92aa6d7cc9894271dbbe62471a",
@@ -502,7 +522,9 @@ var POOL_ADDRESSES = {
     spool: "0xeedf438abcaa6ce4d9625ffca110920592d5867e4c5637d84ad9f466c4feb800",
     spoolReward: "0x89255a2f86ed7fbfef35ab8b7be48cc7667015975be2685dd9a55a9a64baf76e",
     sCoinTreasury: "0x55f4dfe9e40bc4cc11c70fcb1f3daefa2bdc330567c58d4f0792fbd9f9175a62",
-    coinDecimalId: "0x2f9217f533e51334873a39b8026a4aa6919497b47f49d0986a4f1aec66f8a34d"
+    sCoinType: "0x00671b1fa2a124f5be8bdae8b91ee711462c5d9e31bda232e70fd9607b523c88::scallop_af_sui::SCALLOP_AF_SUI",
+    coinDecimalId: "0x2f9217f533e51334873a39b8026a4aa6919497b47f49d0986a4f1aec66f8a34d",
+    coinType: "f325ce1300e8dac124071d3152c5c5ee6174914f8bc2161e88329cf579246efc::afsui::AFSUI"
   },
   hasui: {
     lendingPoolAddress: "0x7ebc607f6bdeb659fb6506cb91c5cc1d47bb365cfd5d2e637ea765346ec84ed4",
@@ -517,7 +539,9 @@ var POOL_ADDRESSES = {
     spool: "0xa6148bc1b623e936d39a952ceb5bea79e8b37228a8f595067bf1852efd3c34aa",
     spoolReward: "0x6f3563644d3e2ef13176dbf9d865bd93479df60ccbe07b7e66db57f6309f5a66",
     sCoinTreasury: "0x404ccc1404d74a90eb6f9c9d4b6cda6d417fb03189f80d9070a35e5dab1df0f5",
-    coinDecimalId: "0x2c5f33af93f6511df699aaaa5822d823aac6ed99d4a0de2a4a50b3afa0172e24"
+    sCoinType: "0x9a2376943f7d22f88087c259c5889925f332ca4347e669dc37d54c2bf651af3c::scallop_ha_sui::SCALLOP_HA_SUI",
+    coinDecimalId: "0x2c5f33af93f6511df699aaaa5822d823aac6ed99d4a0de2a4a50b3afa0172e24",
+    coinType: "bde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::hasui::HASUI"
   },
   vsui: {
     lendingPoolAddress: "0xda9257c0731d8822e8a438ebced13415850d705b779c79958dcf2aeb21fcb43d",
@@ -532,7 +556,9 @@ var POOL_ADDRESSES = {
     spool: "0x69ce8e537e750a95381e6040794afa5ab1758353a1a2e1de7760391b01f91670",
     spoolReward: "0xbca914adce058ad0902c7f3cfcd698392a475f00dcfdc3f76001d0370b98777a",
     sCoinTreasury: "0xc06688ee1af25abc286ffb1d18ce273d1d5907cd1064c25f4e8ca61ea989c1d1",
-    coinDecimalId: "0xabd84a23467b33854ab25cf862006fd97479f8f6f53e50fe732c43a274d939bd"
+    sCoinType: "0xe1a1cc6bcf0001a015eab84bcc6713393ce20535f55b8b6f35c142e057a25fbe::scallop_v_sui::SCALLOP_V_SUI",
+    coinDecimalId: "0xabd84a23467b33854ab25cf862006fd97479f8f6f53e50fe732c43a274d939bd",
+    coinType: "549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT"
   },
   sca: {
     lendingPoolAddress: "0x6fc7d4211fc7018b6c75e7b908b88f2e0536443239804a3d32af547637bd28d7",
@@ -547,7 +573,9 @@ var POOL_ADDRESSES = {
     spool: void 0,
     spoolReward: void 0,
     sCoinTreasury: "0xe04bfc95e00252bd654ee13c08edef9ac5e4b6ae4074e8390db39e9a0109c529",
-    coinDecimalId: "0x5d26a1e9a55c88147ac870bfa31b729d7f49f8804b8b3adfdf3582d301cca844"
+    sCoinType: "0x5ca17430c1d046fae9edeaa8fd76c7b4193a00d764a0ecfa9418d733ad27bc1e::scallop_sca::SCALLOP_SCA",
+    coinDecimalId: "0x5d26a1e9a55c88147ac870bfa31b729d7f49f8804b8b3adfdf3582d301cca844",
+    coinType: "7016aae72cfc67f2fadf55769c0a7dd54291a583b63051a5ed71081cce836ac6::sca::SCA"
   },
   fud: {
     lendingPoolAddress: "0xefed2cbe76b344792ac724523c8b2236740d1cea2100d46a0ed0dc760c7f4231",
@@ -562,7 +590,9 @@ var POOL_ADDRESSES = {
     spool: void 0,
     spoolReward: void 0,
     sCoinTreasury: "0xf25212f11d182decff7a86165699a73e3d5787aced203ca539f43cfbc10db867",
-    coinDecimalId: "0x01087411ef48aaac1eb6e24803213e3a60a03b147dac930e5e341f17a85e524e"
+    sCoinType: "0xe56d5167f427cbe597da9e8150ef5c337839aaf46891d62468dcf80bdd8e10d1::scallop_fud::SCALLOP_FUD",
+    coinDecimalId: "0x01087411ef48aaac1eb6e24803213e3a60a03b147dac930e5e341f17a85e524e",
+    coinType: "76cb819b01abed502bee8a702b4c2d547532c12f25001c9dea795a5e631c26f1::fud::FUD"
   },
   deep: {
     lendingPoolAddress: "0xf4a67ffb43da1e1c61c049f188f19463ea8dbbf2d5ef4722d6df854ff1b1cc03",
@@ -577,7 +607,9 @@ var POOL_ADDRESSES = {
     spool: void 0,
     spoolReward: void 0,
     sCoinTreasury: "0xc63838fabe37b25ad897392d89876d920f5e0c6a406bf3abcb84753d2829bc88",
-    coinDecimalId: "0x6e60b051a08fa836f5a7acd7c464c8d9825bc29c44657fe170fe9b8e1e4770c0"
+    sCoinType: "0xeb7a05a3224837c5e5503575aed0be73c091d1ce5e43aa3c3e716e0ae614608f::scallop_deep::SCALLOP_DEEP",
+    coinDecimalId: "0x6e60b051a08fa836f5a7acd7c464c8d9825bc29c44657fe170fe9b8e1e4770c0",
+    coinType: "deeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep::DEEP"
   },
   fdusd: {
     lendingPoolAddress: "0x4f46051a01f05c3ad9aecf29a771aad5c884e1a1888e08d7709085e3a095bc9c",
@@ -592,7 +624,9 @@ var POOL_ADDRESSES = {
     spool: void 0,
     spoolReward: void 0,
     sCoinTreasury: "0xdad9bc6293e694f67a5274ea51b596e0bdabfafc585ae6d7e82888e65f1a03e0",
-    coinDecimalId: "0xdebee5265a67c186ed87fe93303d33dfe1de53e3b4fd7d9329c2852860acd3e7"
+    sCoinType: "0x6711551c1e7652a270d9fbf0eee25d99594c157cde3cb5fbb49035eb59b1b001::scallop_fdusd::SCALLOP_FDUSD",
+    coinDecimalId: "0xdebee5265a67c186ed87fe93303d33dfe1de53e3b4fd7d9329c2852860acd3e7",
+    coinType: "f16e6b723f242ec745dfd7634ad072c42d5c1d9ac9d62a39c381303eaa57693a::fdusd::FDUSD"
   }
 };
 
@@ -1200,10 +1234,6 @@ var TEST_ADDRESSES = {
   }
 };
 
-// src/constants/tokenBucket.ts
-var DEFAULT_TOKENS_PER_INTERVAL = 10;
-var DEFAULT_INTERVAL_IN_MS = 250;
-
 // src/constants/vesca.ts
 var UNLOCK_ROUND_DURATION = 60 * 60 * 24;
 var MAX_LOCK_ROUNDS = 1460;
@@ -1211,1651 +1241,1641 @@ var MAX_LOCK_DURATION = MAX_LOCK_ROUNDS * UNLOCK_ROUND_DURATION;
 var MIN_INITIAL_LOCK_AMOUNT = 1e10;
 var MIN_TOP_UP_AMOUNT = 1e9;
 
-// src/models/scallopAddress.ts
-import { SuiKit } from "@scallop-io/sui-kit";
-
 // src/models/scallopCache.ts
 import { QueryClient } from "@tanstack/query-core";
 import {
   SuiTxBlock,
-  normalizeStructTag as normalizeStructTag2,
-  parseStructTag as parseStructTag2
+  normalizeStructTag,
+  parseStructTag
 } from "@scallop-io/sui-kit";
 
-// src/utils/builder.ts
-var requireSender = (txBlock) => {
-  const sender = txBlock.blockData.sender;
-  if (!sender) {
-    throw new Error("Sender is required");
-  }
-  return sender;
+// src/models/suiKit.ts
+import { SuiKit } from "@scallop-io/sui-kit";
+var newSuiKit = (params) => {
+  return new SuiKit({
+    ...params,
+    fullnodeUrls: Array.from(
+      /* @__PURE__ */ new Set([...params.fullnodeUrls ?? [], ...RPC_PROVIDERS])
+    )
+  });
 };
-var checkVesca = (prevUnlockAtInMillisTimestamp) => {
-  if (prevUnlockAtInMillisTimestamp === void 0) {
-    throw new Error("veSca not found");
+
+// src/models/scallopCache.ts
+var DEFAULT_TOKENS_PER_INTERVAL = 10;
+var DEFAULT_INTERVAL_IN_MS = 250;
+var ScallopCache = class {
+  constructor(params, instance) {
+    this.tokensPerInterval = DEFAULT_TOKENS_PER_INTERVAL;
+    this.interval = DEFAULT_INTERVAL_IN_MS;
+    this.params = params;
+    this.suiKit = instance?.suiKit ?? newSuiKit(params);
+    this.queryClient = instance?.queryClient ?? new QueryClient(params?.cacheOptions ?? DEFAULT_CACHE_OPTIONS);
+    this.tokens = this.tokensPerInterval;
+    this.lastRefill = Date.now();
+    this.walletAddress = params.walletAddress ?? this.suiKit.currentAddress();
   }
-};
-var checkVescaExpired = (prevUnlockAtInMillisTimestamp) => {
-  if (prevUnlockAtInMillisTimestamp <= (/* @__PURE__ */ new Date()).getTime()) {
-    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
+  get client() {
+    return this.suiKit.client();
   }
-};
-var checkExtendLockPeriod = (lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInMillisTimestamp) => {
-  checkVesca(prevUnlockAtInMillisTimestamp);
-  checkVescaExpired(prevUnlockAtInMillisTimestamp);
-  const prevUnlockAtInSecondTimestamp = Math.floor(
-    prevUnlockAtInMillisTimestamp / 1e3
-  );
-  if (lockPeriodInDays < 1) {
-    throw new Error("Minimum lock period is 1 day");
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    if (elapsed >= this.interval) {
+      const tokensToAdd = Math.floor(elapsed / this.interval) * this.tokensPerInterval;
+      this.tokens = Math.min(this.tokens + tokensToAdd, this.tokensPerInterval);
+      this.lastRefill += Math.floor(elapsed / this.interval) * this.interval;
+    }
   }
-  const availableLockPeriodInDays = Math.floor(
-    (newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp) / UNLOCK_ROUND_DURATION
-  );
-  if (lockPeriodInDays > availableLockPeriodInDays) {
-    throw new Error(
-      `Cannot extend lock period by ${lockPeriodInDays} days, maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days), remaining lock period is ${MAX_LOCK_ROUNDS - availableLockPeriodInDays}`
-    );
+  removeTokens(count) {
+    this.refill();
+    if (this.tokens >= count) {
+      this.tokens -= count;
+      return true;
+    }
+    return false;
   }
-};
-var checkLockSca = (scaAmountOrCoin, lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInMillisTimestamp) => {
-  const prevUnlockAtInSecondTimestamp = prevUnlockAtInMillisTimestamp ? Math.floor(prevUnlockAtInMillisTimestamp / 1e3) : void 0;
-  const isInitialLock = !prevUnlockAtInSecondTimestamp;
-  const isLockExpired = !isInitialLock && prevUnlockAtInSecondTimestamp * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
-  if (isInitialLock || isLockExpired) {
-    if (scaAmountOrCoin !== void 0 && lockPeriodInDays !== void 0) {
-      if (lockPeriodInDays <= 0) {
-        throw new Error("Lock period must be greater than 0");
+  async callWithRateLimit(fn, maxRetries = 15, backoffFactor = 1.25) {
+    let retries = 0;
+    const tryRequest = async () => {
+      if (this.removeTokens(1)) {
+        const result = await fn();
+        return result;
+      } else if (retries < maxRetries) {
+        retries++;
+        const delay = this.interval * Math.pow(backoffFactor, retries);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return tryRequest();
+      } else {
+        console.error("Maximum retries reached");
+        return null;
       }
-      if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_INITIAL_LOCK_AMOUNT) {
-        throw new Error(
-          `Minimum lock amount for ${isLockExpired ? "renewing expired veSca" : "initial lock"} is 10 SCA`
+    };
+    return tryRequest();
+  }
+  /**
+   * @description Invalidate cache based on the refetchType parameter
+   * @param refetchType Determines the type of queries to be refetched. Defaults to `active`.
+   *
+   * - `active`: Only queries that match the refetch predicate and are actively being rendered via useQuery and related functions will be refetched in the background.
+   * - `inactive`: Only queries that match the refetch predicate and are NOT actively being rendered via useQuery and related functions will be refetched in the background.
+   * - `all`: All queries that match the refetch predicate will be refetched in the background.
+   * - `none`: No queries will be refetched. Queries that match the refetch predicate will only be marked as invalid.
+   */
+  // public async invalidateAllCache() {
+  //   return Object.values(queryKeys.rpc).map((t) =>
+  //     this.queryClient.invalidateQueries({
+  //       queryKey: t(),
+  //       type: 'all',
+  //     })
+  //   );
+  // }
+  retryFn(errCount, e) {
+    if (errCount === 5)
+      return false;
+    if (e.status === 429)
+      return true;
+    return false;
+  }
+  /**
+   * @description Provides cache for inspectTxn of the SuiKit.
+   * @param QueryInspectTxnParams
+   * @param txBlock
+   * @returns Promise<DevInspectResults>
+   */
+  async queryInspectTxn({
+    queryTarget,
+    args,
+    typeArgs
+  }) {
+    const txBlock = new SuiTxBlock();
+    const resolvedQueryTarget = await this.queryGetNormalizedMoveFunction(queryTarget);
+    if (!resolvedQueryTarget)
+      throw new Error("Invalid query target");
+    const { parameters } = resolvedQueryTarget;
+    const resolvedArgs = await Promise.all(
+      (args ?? []).map(async (arg, idx) => {
+        if (typeof arg !== "string")
+          return arg;
+        const cachedData = (await this.queryGetObject(arg))?.data;
+        if (!cachedData)
+          return arg;
+        const owner = cachedData.owner;
+        if (!owner || typeof owner !== "object" || !("Shared" in owner))
+          return {
+            objectId: cachedData.objectId,
+            version: cachedData.version,
+            digest: cachedData.digest
+          };
+        const parameter = parameters[idx];
+        if (typeof parameter !== "object" || !("MutableReference" in parameter || "Reference" in parameter))
+          return arg;
+        return {
+          objectId: cachedData.objectId,
+          initialSharedVersion: owner.Shared.initial_shared_version,
+          mutable: "MutableReference" in parameter
+        };
+      })
+    );
+    txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
+    const query = await this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
+      queryKey: queryKeys.rpc.getInspectTxn(queryTarget, args, typeArgs),
+      queryFn: async () => {
+        return await this.callWithRateLimit(
+          async () => await this.suiKit.inspectTxn(txBlock)
         );
       }
-      const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
-      if (extendLockPeriodInSecond > MAX_LOCK_DURATION) {
-        throw new Error(
-          `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days)`
+    });
+    return query;
+  }
+  async queryGetNormalizedMoveFunction(target) {
+    const { address, module, name } = parseStructTag(target);
+    return this.queryClient.fetchQuery({
+      queryKey: queryKeys.rpc.getNormalizedMoveFunction(target),
+      queryFn: async () => {
+        return await this.callWithRateLimit(
+          async () => await this.suiKit.client().getNormalizedMoveFunction({
+            package: address,
+            module,
+            function: name
+          })
         );
       }
-    } else {
-      throw new Error(
-        `SCA amount and lock period is required for ${isLockExpired ? "renewing expired veSca" : "initial lock"}`
-      );
-    }
-  } else {
-    checkVesca(prevUnlockAtInMillisTimestamp);
-    checkVescaExpired(prevUnlockAtInMillisTimestamp);
-    if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_TOP_UP_AMOUNT) {
-      throw new Error("Minimum top up amount is 1 SCA");
-    }
-    if (newUnlockAtInSecondTimestamp && lockPeriodInDays) {
-      checkExtendLockPeriod(
-        lockPeriodInDays,
-        newUnlockAtInSecondTimestamp,
-        prevUnlockAtInMillisTimestamp
-      );
-    }
-  }
-};
-var checkExtendLockAmount = (scaAmount, prevUnlockAtInMillisTimestamp) => {
-  checkVesca(prevUnlockAtInMillisTimestamp);
-  checkVescaExpired(prevUnlockAtInMillisTimestamp);
-  if (scaAmount < MIN_TOP_UP_AMOUNT) {
-    throw new Error("Minimum top up amount is 1 SCA");
+    });
   }
-  const isInitialLock = !prevUnlockAtInMillisTimestamp;
-  const isLockExpired = !isInitialLock && prevUnlockAtInMillisTimestamp <= (/* @__PURE__ */ new Date()).getTime();
-  if (isLockExpired) {
-    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
+  /**
+   * @description Provides cache for getObject of the SuiKit.
+   * @param objectId
+   * @param QueryObjectParams
+   * @returns Promise<SuiObjectResponse>
+   */
+  async queryGetObject(objectId, options) {
+    options = {
+      ...options,
+      showOwner: true,
+      showContent: true
+    };
+    return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
+      queryKey: queryKeys.rpc.getObject(objectId, options),
+      queryFn: async () => {
+        return await this.callWithRateLimit(
+          async () => await this.client.getObject({
+            id: objectId,
+            options
+          })
+        );
+      }
+    });
   }
-};
-var checkRenewExpiredVeSca = (scaAmount, lockPeriodInDays, prevUnlockAtInMillisTimestamp) => {
-  if (!prevUnlockAtInMillisTimestamp || prevUnlockAtInMillisTimestamp > (/* @__PURE__ */ new Date()).getTime()) {
-    throw new Error("Renew method can only be used for expired veSca");
+  /**
+   * @description Provides cache for getObjects of the SuiKit.
+   * @param objectIds
+   * @returns Promise<SuiObjectData[]>
+   */
+  async queryGetObjects(objectIds, options = {
+    showContent: true
+  }) {
+    if (objectIds.length === 0)
+      return [];
+    return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
+      queryKey: queryKeys.rpc.getObjects(
+        objectIds,
+        this.walletAddress,
+        options
+      ),
+      queryFn: async () => {
+        const results = await this.callWithRateLimit(
+          async () => await this.suiKit.getObjects(objectIds, options)
+        );
+        if (results) {
+          results.forEach((result) => {
+            this.queryClient.setQueriesData(
+              {
+                exact: false,
+                queryKey: queryKeys.rpc.getObject(result.objectId, options)
+              },
+              {
+                data: result,
+                error: null
+              },
+              {
+                updatedAt: Date.now()
+              }
+            );
+          });
+        }
+        return results;
+      }
+    });
   }
-  if (scaAmount < MIN_INITIAL_LOCK_AMOUNT) {
-    throw new Error("Minimum lock amount for renewing expired vesca 10 SCA");
+  /**
+   * @description Provides cache for getOwnedObjects of the SuiKit.
+   * @param input
+   * @returns Promise<PaginatedObjectsResponse>
+   */
+  async queryGetOwnedObjects(input) {
+    return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
+      queryKey: queryKeys.rpc.getOwnedObjects(input),
+      queryFn: async () => {
+        const results = await this.callWithRateLimit(
+          async () => await this.client.getOwnedObjects(input)
+        );
+        if (results && results.data.length > 0) {
+          results.data.filter(
+            (result) => !!result.data
+          ).forEach((result) => {
+            this.queryClient.setQueriesData(
+              {
+                exact: false,
+                queryKey: queryKeys.rpc.getObject(
+                  result.data.objectId,
+                  input.options ?? {}
+                )
+              },
+              {
+                data: result.data,
+                error: null
+              },
+              {
+                updatedAt: Date.now()
+              }
+            );
+          });
+        }
+        return results;
+      }
+    });
   }
-  const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
-  if (extendLockPeriodInSecond >= MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
-    throw new Error(
-      `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
-    );
+  async queryGetDynamicFields(input) {
+    return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
+      queryKey: queryKeys.rpc.getDynamicFields(input),
+      queryFn: async () => {
+        return await this.callWithRateLimit(
+          async () => await this.client.getDynamicFields(input)
+        );
+      }
+    });
+  }
+  async queryGetDynamicFieldObject(input) {
+    return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: (attemptIndex) => Math.min(1e3 * attemptIndex, 8e3),
+      queryKey: queryKeys.rpc.getDynamicFieldObject(input),
+      queryFn: async () => {
+        const result = await this.callWithRateLimit(
+          () => this.client.getDynamicFieldObject(input)
+        );
+        if (result?.data) {
+          this.queryClient.setQueriesData(
+            {
+              exact: false,
+              queryKey: queryKeys.rpc.getObject(result?.data.objectId, {
+                showContent: true,
+                showOwner: true
+              })
+            },
+            {
+              data: result.data,
+              error: null
+            },
+            {
+              updatedAt: Date.now()
+            }
+          );
+        }
+        return result;
+      }
+    });
+  }
+  async queryGetAllCoinBalances(owner) {
+    return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
+      queryKey: queryKeys.rpc.getAllCoinBalances(owner),
+      queryFn: async () => {
+        const allBalances = await this.callWithRateLimit(
+          async () => await this.client.getAllBalances({ owner })
+        );
+        if (!allBalances)
+          return {};
+        const balances = allBalances.reduce(
+          (acc, coinBalance) => {
+            if (coinBalance.totalBalance !== "0") {
+              acc[normalizeStructTag(coinBalance.coinType)] = coinBalance;
+            }
+            return acc;
+          },
+          {}
+        );
+        return balances;
+      }
+    });
+  }
+  async queryGetCoinBalance(input) {
+    if (!input.coinType)
+      return null;
+    return (await this.queryGetAllCoinBalances(input.owner) ?? {})[normalizeStructTag(input.coinType)] ?? "0";
   }
 };
 
-// src/utils/query.ts
-import BigNumber from "bignumber.js";
-import { normalizeStructTag, parseStructTag } from "@mysten/sui/utils";
-var parseOriginMarketPoolData = (originMarketPoolData) => {
-  return {
-    coinType: normalizeStructTag(originMarketPoolData.type.name),
-    // Parse origin data required for basic calculations.
-    maxBorrowRate: Number(originMarketPoolData.maxBorrowRate.value) / 2 ** 32,
-    borrowRate: Number(originMarketPoolData.interestRate.value) / 2 ** 32,
-    borrowRateScale: Number(originMarketPoolData.interestRateScale),
-    borrowIndex: Number(originMarketPoolData.borrowIndex),
-    lastUpdated: Number(originMarketPoolData.lastUpdated),
-    cashAmount: Number(originMarketPoolData.cash),
-    debtAmount: Number(originMarketPoolData.debt),
-    marketCoinSupplyAmount: Number(originMarketPoolData.marketCoinSupply),
-    reserveAmount: Number(originMarketPoolData.reserve),
-    reserveFactor: Number(originMarketPoolData.reserveFactor.value) / 2 ** 32,
-    borrowWeight: Number(originMarketPoolData.borrowWeight.value) / 2 ** 32,
-    borrowFee: Number(originMarketPoolData.borrowFeeRate.value) / 2 ** 32,
-    // Parse origin data required for additional display.
-    baseBorrowRate: Number(originMarketPoolData.baseBorrowRatePerSec.value) / 2 ** 32,
-    borrowRateOnHighKink: Number(originMarketPoolData.borrowRateOnHighKink.value) / 2 ** 32,
-    borrowRateOnMidKink: Number(originMarketPoolData.borrowRateOnMidKink.value) / 2 ** 32,
-    highKink: Number(originMarketPoolData.highKink.value) / 2 ** 32,
-    midKink: Number(originMarketPoolData.midKink.value) / 2 ** 32,
-    minBorrowAmount: Number(originMarketPoolData.minBorrowAmount),
-    isIsolated: originMarketPoolData.isIsolated,
-    supplyLimit: Number(originMarketPoolData.supplyLimit),
-    borrowLimit: Number(originMarketPoolData.borrowLimit)
-  };
-};
-var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
-  const poolCoinName = utils.parseCoinNameFromType(
-    parsedMarketPoolData.coinType
-  );
-  const coinDecimal = utils.getCoinDecimal(poolCoinName);
-  const borrowYearFactor = 24 * 365 * 3600;
-  const baseBorrowApr = parsedMarketPoolData.baseBorrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const borrowAprOnHighKink = parsedMarketPoolData.borrowRateOnHighKink * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const borrowAprOnMidKink = parsedMarketPoolData.borrowRateOnMidKink * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const maxBorrowApr = parsedMarketPoolData.maxBorrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const borrowApr = parsedMarketPoolData.borrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
-  const timeDelta = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedMarketPoolData.lastUpdated;
-  const borrowIndexDelta = BigNumber(parsedMarketPoolData.borrowIndex).multipliedBy(
-    BigNumber(timeDelta).multipliedBy(parsedMarketPoolData.borrowRate)
-  ).dividedBy(parsedMarketPoolData.borrowRateScale);
-  const currentBorrowIndex = BigNumber(parsedMarketPoolData.borrowIndex).plus(
-    borrowIndexDelta
-  );
-  const growthInterest = BigNumber(currentBorrowIndex).dividedBy(parsedMarketPoolData.borrowIndex).minus(1);
-  const increasedDebtAmount = BigNumber(
-    parsedMarketPoolData.debtAmount
-  ).multipliedBy(growthInterest);
-  const borrowAmount = increasedDebtAmount.plus(
-    parsedMarketPoolData.debtAmount
-  );
-  const borrowCoin = borrowAmount.shiftedBy(-1 * coinDecimal);
-  const reserveAmount = BigNumber(parsedMarketPoolData.reserveAmount).plus(
-    increasedDebtAmount.multipliedBy(parsedMarketPoolData.reserveFactor)
-  );
-  const reserveCoin = reserveAmount.shiftedBy(-1 * coinDecimal);
-  const supplyAmount = BigNumber(borrowAmount).plus(
-    Math.max(parsedMarketPoolData.cashAmount - reserveAmount.toNumber(), 0)
-  );
-  const supplyCoin = supplyAmount.shiftedBy(-1 * coinDecimal);
-  let utilizationRate = BigNumber(borrowAmount).dividedBy(supplyAmount);
-  utilizationRate = utilizationRate.isFinite() ? utilizationRate : BigNumber(0);
-  let supplyApr = BigNumber(borrowApr).multipliedBy(utilizationRate).multipliedBy(1 - parsedMarketPoolData.reserveFactor);
-  supplyApr = supplyApr.isFinite() ? supplyApr : BigNumber(0);
-  let conversionRate = supplyAmount.dividedBy(
-    parsedMarketPoolData.marketCoinSupplyAmount
-  );
-  conversionRate = conversionRate.isFinite() && !conversionRate.isNaN() ? conversionRate : BigNumber(1);
-  return {
-    baseBorrowApr,
-    baseBorrowApy: utils.parseAprToApy(baseBorrowApr),
-    borrowAprOnHighKink,
-    borrowApyOnHighKink: utils.parseAprToApy(borrowAprOnHighKink),
-    borrowAprOnMidKink,
-    borrowApyOnMidKink: utils.parseAprToApy(borrowAprOnMidKink),
-    coinDecimal,
-    maxBorrowApr,
-    maxBorrowApy: utils.parseAprToApy(maxBorrowApr),
-    borrowApr: Math.min(borrowApr, maxBorrowApr),
-    borrowApy: Math.min(
-      utils.parseAprToApy(borrowApr),
-      utils.parseAprToApy(maxBorrowApr)
-    ),
-    borrowIndex: currentBorrowIndex.toNumber(),
-    growthInterest: growthInterest.toNumber(),
-    supplyAmount: supplyAmount.toNumber(),
-    supplyCoin: supplyCoin.toNumber(),
-    borrowAmount: borrowAmount.toNumber(),
-    borrowCoin: borrowCoin.toNumber(),
-    reserveAmount: reserveAmount.toNumber(),
-    reserveCoin: reserveCoin.toNumber(),
-    utilizationRate: utilizationRate.toNumber(),
-    supplyApr: supplyApr.toNumber(),
-    supplyApy: utils.parseAprToApy(supplyApr.toNumber()),
-    conversionRate: conversionRate.toNumber(),
-    isIsolated: parsedMarketPoolData.isIsolated,
-    maxSupplyCoin: BigNumber(parsedMarketPoolData.supplyLimit).shiftedBy(-coinDecimal).toNumber(),
-    maxBorrowCoin: BigNumber(parsedMarketPoolData.borrowLimit).shiftedBy(-coinDecimal).toNumber()
-  };
-};
-var parseOriginMarketCollateralData = (originMarketCollateralData) => {
-  const divisor = 2 ** 32;
-  return {
-    coinType: normalizeStructTag(originMarketCollateralData.type.name),
-    isIsolated: originMarketCollateralData.isIsolated,
-    collateralFactor: Number(originMarketCollateralData.collateralFactor.value) / divisor,
-    liquidationFactor: Number(originMarketCollateralData.liquidationFactor.value) / divisor,
-    liquidationDiscount: Number(originMarketCollateralData.liquidationDiscount.value) / divisor,
-    liquidationPenalty: Number(originMarketCollateralData.liquidationPenalty.value) / divisor,
-    liquidationReserveFactor: Number(originMarketCollateralData.liquidationReserveFactor.value) / divisor,
-    maxCollateralAmount: Number(originMarketCollateralData.maxCollateralAmount),
-    totalCollateralAmount: Number(
-      originMarketCollateralData.totalCollateralAmount
-    )
-  };
-};
-var calculateMarketCollateralData = (utils, parsedMarketCollateralData) => {
-  const collateralCoinName = utils.parseCoinNameFromType(
-    parsedMarketCollateralData.coinType
-  );
-  const coinDecimal = utils.getCoinDecimal(collateralCoinName);
-  const maxCollateralCoin = BigNumber(
-    parsedMarketCollateralData.maxCollateralAmount
-  ).shiftedBy(-1 * coinDecimal);
-  const depositCoin = BigNumber(
-    parsedMarketCollateralData.totalCollateralAmount
-  ).shiftedBy(-1 * coinDecimal);
-  return {
-    coinDecimal,
-    isIsolated: parsedMarketCollateralData.isIsolated,
-    maxDepositAmount: parsedMarketCollateralData.maxCollateralAmount,
-    maxDepositCoin: maxCollateralCoin.toNumber(),
-    depositAmount: parsedMarketCollateralData.totalCollateralAmount,
-    depositCoin: depositCoin.toNumber()
-  };
-};
-var parseOriginSpoolData = (originSpoolData) => {
-  return {
-    stakeType: normalizeStructTag(originSpoolData.stakeType.fields.name),
-    maxPoint: Number(originSpoolData.maxDistributedPoint),
-    distributedPoint: Number(originSpoolData.distributedPoint),
-    pointPerPeriod: Number(originSpoolData.distributedPointPerPeriod),
-    period: Number(originSpoolData.pointDistributionTime),
-    maxStake: Number(originSpoolData.maxStake),
-    staked: Number(originSpoolData.stakes),
-    index: Number(originSpoolData.index),
-    createdAt: Number(originSpoolData.createdAt),
-    lastUpdate: Number(originSpoolData.lastUpdate)
-  };
-};
-var calculateSpoolData = (parsedSpoolData, stakeMarketCoinPrice, stakeMarketCoinDecimal) => {
-  const baseIndexRate = 1e9;
-  const distributedPointPerSec = BigNumber(
-    parsedSpoolData.pointPerPeriod
-  ).dividedBy(parsedSpoolData.period);
-  const pointPerSec = BigNumber(parsedSpoolData.pointPerPeriod).dividedBy(
-    parsedSpoolData.period
-  );
-  const remainingPeriod = pointPerSec.gt(0) ? BigNumber(parsedSpoolData.maxPoint).minus(parsedSpoolData.distributedPoint).dividedBy(pointPerSec) : BigNumber(0);
-  const startDate = parsedSpoolData.createdAt;
-  const endDate = remainingPeriod.plus(parsedSpoolData.lastUpdate).integerValue().toNumber();
-  const timeDelta = BigNumber(
-    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedSpoolData.lastUpdate
-  ).dividedBy(parsedSpoolData.period).toFixed(0);
-  const remainingPoints = BigNumber(parsedSpoolData.maxPoint).minus(
-    parsedSpoolData.distributedPoint
-  );
-  const accumulatedPoints = BigNumber.minimum(
-    BigNumber(timeDelta).multipliedBy(parsedSpoolData.pointPerPeriod),
-    remainingPoints
-  );
-  const currentPointIndex = BigNumber(parsedSpoolData.index).plus(
-    accumulatedPoints.dividedBy(parsedSpoolData.staked).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedSpoolData.staked) : 0
-  );
-  const currentTotalDistributedPoint = BigNumber(
-    parsedSpoolData.distributedPoint
-  ).plus(accumulatedPoints);
-  const stakedAmount = BigNumber(parsedSpoolData.staked);
-  const stakedCoin = stakedAmount.shiftedBy(-1 * stakeMarketCoinDecimal);
-  const stakedValue = stakedCoin.multipliedBy(stakeMarketCoinPrice);
-  return {
-    distributedPointPerSec: distributedPointPerSec.toNumber(),
-    accumulatedPoints: accumulatedPoints.toNumber(),
-    currentPointIndex: currentPointIndex.toNumber(),
-    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
-    startDate: new Date(startDate * 1e3),
-    endDate: new Date(endDate * 1e3),
-    stakedAmount: stakedAmount.toNumber(),
-    stakedCoin: stakedCoin.toNumber(),
-    stakedValue: stakedValue.toNumber()
-  };
-};
-var parseOriginSpoolRewardPoolData = (originSpoolRewardPoolData) => {
-  return {
-    claimedRewards: Number(originSpoolRewardPoolData.claimed_rewards),
-    exchangeRateDenominator: Number(
-      originSpoolRewardPoolData.exchange_rate_denominator
-    ),
-    exchangeRateNumerator: Number(
-      originSpoolRewardPoolData.exchange_rate_numerator
-    ),
-    rewards: Number(originSpoolRewardPoolData.rewards),
-    spoolId: String(originSpoolRewardPoolData.spool_id)
-  };
-};
-var calculateSpoolRewardPoolData = (parsedSpoolData, parsedSpoolRewardPoolData, calculatedSpoolData, rewardCoinPrice, rewardCoinDecimal) => {
-  const rateYearFactor = 365 * 24 * 60 * 60;
-  const rewardPerSec = BigNumber(calculatedSpoolData.distributedPointPerSec).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
-  const totalRewardAmount = BigNumber(parsedSpoolData.maxPoint).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
-  const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
-  const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
-  const remaindRewardAmount = BigNumber(parsedSpoolRewardPoolData.rewards);
-  const remaindRewardCoin = remaindRewardAmount.shiftedBy(
-    -1 * rewardCoinDecimal
-  );
-  const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
-  const claimedRewardAmount = BigNumber(
-    parsedSpoolRewardPoolData.claimedRewards
-  );
-  const claimedRewardCoin = claimedRewardAmount.shiftedBy(
-    -1 * rewardCoinDecimal
-  );
-  const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
-  const rewardValueForYear = BigNumber(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
-  let rewardRate = rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).toNumber() : Infinity;
-  if (parsedSpoolData.maxPoint <= parsedSpoolData.distributedPoint || parsedSpoolData.pointPerPeriod === 0) {
-    rewardRate = Infinity;
-  }
-  return {
-    rewardApr: rewardRate,
-    totalRewardAmount: totalRewardAmount.toNumber(),
-    totalRewardCoin: totalRewardCoin.toNumber(),
-    totalRewardValue: totalRewardValue.toNumber(),
-    remaindRewardAmount: remaindRewardAmount.toNumber(),
-    remaindRewardCoin: remaindRewardCoin.toNumber(),
-    remaindRewardValue: remaindRewardValue.toNumber(),
-    claimedRewardAmount: claimedRewardAmount.toNumber(),
-    claimedRewardCoin: claimedRewardCoin.toNumber(),
-    claimedRewardValue: claimedRewardValue.toNumber(),
-    rewardPerSec: rewardPerSec.toNumber()
-  };
-};
-var parseOriginBorrowIncentivesPoolPointData = (originBorrowIncentivePoolPointData) => {
-  return {
-    pointType: normalizeStructTag(
-      originBorrowIncentivePoolPointData.point_type.name
-    ),
-    distributedPointPerPeriod: Number(
-      originBorrowIncentivePoolPointData.distributed_point_per_period
-    ),
-    period: Number(originBorrowIncentivePoolPointData.point_distribution_time),
-    distributedPoint: Number(
-      originBorrowIncentivePoolPointData.distributed_point
-    ),
-    points: Number(originBorrowIncentivePoolPointData.points),
-    index: Number(originBorrowIncentivePoolPointData.index),
-    baseWeight: Number(originBorrowIncentivePoolPointData.base_weight),
-    weightedAmount: Number(originBorrowIncentivePoolPointData.weighted_amount),
-    lastUpdate: Number(originBorrowIncentivePoolPointData.last_update),
-    createdAt: Number(originBorrowIncentivePoolPointData.created_at)
-  };
-};
-var parseOriginBorrowIncentivePoolData = (utils, originBorrowIncentivePoolData) => {
-  return {
-    poolType: normalizeStructTag(originBorrowIncentivePoolData.pool_type.name),
-    minStakes: Number(originBorrowIncentivePoolData.min_stakes),
-    maxStakes: Number(originBorrowIncentivePoolData.max_stakes),
-    staked: Number(originBorrowIncentivePoolData.stakes),
-    poolPoints: originBorrowIncentivePoolData.points.reduce(
-      (acc, point) => {
-        const parsed = parseOriginBorrowIncentivesPoolPointData(point);
-        const name = utils.parseSCoinTypeNameToMarketCoinName(
-          parseStructTag(parsed.pointType).name.toLowerCase()
-        );
-        acc[name] = parsed;
-        return acc;
+// src/models/scallopAddress.ts
+import axios from "axios";
+var EMPTY_ADDRESSES = {
+  core: {
+    version: "",
+    versionCap: "",
+    object: "",
+    market: "",
+    adminCap: "",
+    coinDecimalsRegistry: "",
+    obligationAccessStore: "",
+    coins: {
+      cetus: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
       },
-      {}
-    )
-  };
-};
-var calculateBorrowIncentivePoolPointData = (parsedBorrowIncentivePoolPointData, rewardCoinPrice, rewardCoinDecimal, poolCoinPrice, poolCoinDecimal) => {
-  const baseIndexRate = 1e9;
-  const distributedPointPerSec = BigNumber(
-    parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
-  ).dividedBy(parsedBorrowIncentivePoolPointData.period);
-  const timeDelta = BigNumber(
-    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedBorrowIncentivePoolPointData.lastUpdate
-  ).dividedBy(parsedBorrowIncentivePoolPointData.period).toFixed(0);
-  const accumulatedPoints = BigNumber.minimum(
-    BigNumber(timeDelta).multipliedBy(
-      parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
-    ),
-    BigNumber(parsedBorrowIncentivePoolPointData.points)
-  );
-  const currentPointIndex = BigNumber(
-    parsedBorrowIncentivePoolPointData.index
-  ).plus(
-    accumulatedPoints.dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount) : 0
-  );
-  const currentTotalDistributedPoint = BigNumber(
-    parsedBorrowIncentivePoolPointData.distributedPoint
-  ).plus(accumulatedPoints);
-  const baseWeight = BigNumber(parsedBorrowIncentivePoolPointData.baseWeight);
-  const weightedStakedAmount = BigNumber(
-    parsedBorrowIncentivePoolPointData.weightedAmount
-  );
-  const weightedStakedCoin = weightedStakedAmount.shiftedBy(
-    -1 * poolCoinDecimal
-  );
-  const weightedStakedValue = weightedStakedCoin.multipliedBy(poolCoinPrice);
-  const rateYearFactor = 365 * 24 * 60 * 60;
-  const rewardPerSec = BigNumber(distributedPointPerSec).shiftedBy(
-    -1 * rewardCoinDecimal
-  );
-  const rewardValueForYear = BigNumber(rewardPerSec).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
-  const weightScale = BigNumber(1e12);
-  const rewardRate = rewardValueForYear.multipliedBy(
-    BigNumber(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
-      weightScale
-    )
-  ).dividedBy(weightedStakedValue).isFinite() && parsedBorrowIncentivePoolPointData.points > 0 ? rewardValueForYear.multipliedBy(
-    BigNumber(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
-      weightScale
-    )
-  ).dividedBy(weightedStakedValue).toNumber() : Infinity;
-  return {
-    distributedPointPerSec: distributedPointPerSec.toNumber(),
-    accumulatedPoints: accumulatedPoints.toNumber(),
-    currentPointIndex: currentPointIndex.toNumber(),
-    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
-    baseWeight: baseWeight.toNumber(),
-    weightedStakedAmount: weightedStakedAmount.toNumber(),
-    weightedStakedCoin: weightedStakedCoin.toNumber(),
-    weightedStakedValue: weightedStakedValue.toNumber(),
-    rewardApr: rewardRate,
-    rewardPerSec: rewardPerSec.toNumber()
-  };
-};
-var parseOriginBorrowIncentiveAccountPoolPointData = (originBorrowIncentiveAccountPoolPointData) => {
-  return {
-    pointType: normalizeStructTag(
-      originBorrowIncentiveAccountPoolPointData.point_type.name
-    ),
-    weightedAmount: Number(
-      originBorrowIncentiveAccountPoolPointData.weighted_amount
-    ),
-    points: Number(originBorrowIncentiveAccountPoolPointData.points),
-    totalPoints: Number(originBorrowIncentiveAccountPoolPointData.total_points),
-    index: Number(originBorrowIncentiveAccountPoolPointData.index)
-  };
-};
-var parseOriginBorrowIncentiveAccountData = (originBorrowIncentiveAccountData) => {
-  return {
-    poolType: normalizeStructTag(
-      originBorrowIncentiveAccountData.pool_type.name
-    ),
-    debtAmount: Number(originBorrowIncentiveAccountData.debt_amount),
-    pointList: originBorrowIncentiveAccountData.points_list.reduce(
-      (acc, point) => {
-        const parsed = parseOriginBorrowIncentiveAccountPoolPointData(point);
-        const name = parseStructTag(
-          parsed.pointType
-        ).name.toLowerCase();
-        acc[name] = parsed;
-        return acc;
+      wapt: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      wsol: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      wbtc: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      weth: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
       },
-      {}
-    )
-  };
-};
-var minBigNumber = (...args) => {
-  return BigNumber(
-    args.reduce(
-      (min, current) => new BigNumber(current).lt(min) ? current : min
-    )
-  );
-};
-var estimatedFactor = (amount, scaleStep, type) => {
-  const amountOfDigits = Math.max(
-    1,
-    Math.floor(Math.log10(Math.abs(amount)) + 1)
-  );
-  const adjustScale = Math.max(Math.floor((amountOfDigits - 1) / scaleStep), 1) + 1;
-  let adjustFactor = Math.pow(10, -adjustScale);
-  adjustFactor = type === "increase" ? 1 - adjustFactor : 1 + adjustFactor;
-  return adjustFactor;
-};
-
-// src/utils/util.ts
-var COIN_SET = Array.from(
-  /* @__PURE__ */ new Set([
-    ...SUPPORT_POOLS,
-    ...SUPPORT_COLLATERALS,
-    ...SUPPORT_SPOOLS_REWARDS,
-    ...SUPPORT_BORROW_INCENTIVE_REWARDS,
-    ...SUPPORT_SCOIN
-  ])
-);
-var isMarketCoin = (coinName) => {
-  const assetCoinName = coinName.slice(1).toLowerCase();
-  return coinName.charAt(0).toLowerCase() === "s" && COIN_SET.includes(assetCoinName);
-};
-var isSuiBridgeAsset = (coinName) => {
-  return SUPPORT_SUI_BRIDGE.includes(coinName);
-};
-var isWormholeAsset = (coinName) => {
-  return SUPPORT_WORMHOLE.includes(coinName);
-};
-var parseAssetSymbol = (coinName) => {
-  if (isWormholeAsset(coinName)) {
-    return `w${coinName.slice(1).toUpperCase()}`;
-  }
-  if (isSuiBridgeAsset(coinName)) {
-    return `sb${coinName.slice(2).toUpperCase()}`;
-  }
-  if (isMarketCoin(coinName)) {
-    const assetCoinName = coinName.slice(1).toLowerCase();
-    return coinName.slice(0, 1).toLowerCase() + parseAssetSymbol(assetCoinName);
-  }
-  switch (coinName) {
-    case "afsui":
-      return "afSUI";
-    case "hasui":
-      return "haSUI";
-    case "vsui":
-      return "vSUI";
-    default:
-      return coinName.toUpperCase();
-  }
-};
-var parseDataFromPythPriceFeed = (feed, address) => {
-  const assetCoinNames = COIN_SET;
-  const assetCoinName = assetCoinNames.find((assetCoinName2) => {
-    return address.get(`core.coins.${assetCoinName2}.oracle.pyth.feed`) === feed.id;
-  });
-  if (assetCoinName) {
-    const price = feed.price.price * 10 ** feed.price.expo;
-    return {
-      coinName: assetCoinName,
-      price,
-      publishTime: Number(feed.price.publishTime) * 10 ** 3
-    };
-  } else {
-    throw new Error("Invalid feed id");
-  }
-};
-var findClosestUnlockRound = (unlockAtInSecondTimestamp) => {
-  const unlockDate = new Date(unlockAtInSecondTimestamp * 1e3);
-  const closestTwelveAM = new Date(unlockAtInSecondTimestamp * 1e3);
-  closestTwelveAM.setUTCHours(0, 0, 0, 0);
-  if (unlockDate.getUTCHours() >= 0) {
-    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() + 1);
-  }
-  const now = (/* @__PURE__ */ new Date()).getTime();
-  if (closestTwelveAM.getTime() - now > MAX_LOCK_DURATION * 1e3) {
-    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() - 1);
-  }
-  return Math.floor(closestTwelveAM.getTime() / 1e3);
-};
-var partitionArray = (array, chunkSize) => {
-  const result = [];
-  for (let i = 0; i < array.length; i += chunkSize) {
-    result.push(array.slice(i, i + chunkSize));
-  }
-  return result;
-};
-
-// src/utils/tokenBucket.ts
-var TokenBucket = class {
-  constructor(tokensPerInterval, intervalInMs) {
-    this.tokensPerInterval = tokensPerInterval;
-    this.interval = intervalInMs;
-    this.tokens = tokensPerInterval;
-    this.lastRefill = Date.now();
-  }
-  refill() {
-    const now = Date.now();
-    const elapsed = now - this.lastRefill;
-    if (elapsed >= this.interval) {
-      const tokensToAdd = Math.floor(elapsed / this.interval) * this.tokensPerInterval;
-      this.tokens = Math.min(this.tokens + tokensToAdd, this.tokensPerInterval);
-      this.lastRefill += Math.floor(elapsed / this.interval) * this.interval;
-    }
-  }
-  removeTokens(count) {
-    this.refill();
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return true;
-    }
-    return false;
-  }
-};
-var callWithRateLimit = async (tokenBucket, fn, retryDelayInMs = DEFAULT_INTERVAL_IN_MS, maxRetries = 15, backoffFactor = 1.25) => {
-  let retries = 0;
-  const tryRequest = async () => {
-    if (tokenBucket.removeTokens(1)) {
-      const result = await fn();
-      return result;
-    } else if (retries < maxRetries) {
-      retries++;
-      const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      return tryRequest();
-    } else {
-      console.error("Maximum retries reached");
-      return null;
-    }
-  };
-  return tryRequest();
-};
-
-// src/utils/indexer.ts
-async function callMethodWithIndexerFallback(method, context, ...args) {
-  const lastArgs = args[args.length - 1];
-  if (typeof lastArgs === "object" && lastArgs.indexer) {
-    try {
-      return await method.apply(context, args);
-    } catch (e) {
-      console.warn(`Indexer requests failed: ${e}. Retrying without indexer..`);
-      return await method.apply(context, [
-        ...args.slice(0, -1),
-        {
-          ...lastArgs,
-          indexer: false
+      wusdc: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
         }
-      ]);
-    }
-  }
-  return await method.apply(context, args);
-}
-function withIndexerFallback(method) {
-  return (...args) => {
-    return callMethodWithIndexerFallback(method, this, ...args);
-  };
-}
-
-// src/utils/core.ts
-var parseObjectAs = (object) => {
-  if (!(object && object.content && "fields" in object.content))
-    throw new Error(`Failed to parse object`);
-  const fields = object.content.fields;
-  if (typeof fields === "object" && "value" in fields) {
-    const value = fields.value;
-    if (typeof value === "object" && "fields" in value)
-      return value.fields;
-    return value;
-  } else if (typeof fields === "object") {
-    return fields;
-  }
-  return fields;
-};
-
-// src/models/scallopCache.ts
-var ScallopCache = class {
-  constructor(suiKit, walletAddress, cacheOptions, tokenBucket, queryClient) {
-    this.queryClient = queryClient ?? new QueryClient(cacheOptions ?? DEFAULT_CACHE_OPTIONS);
-    this._suiKit = suiKit;
-    this.tokenBucket = tokenBucket ?? new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS);
-    this.walletAddress = walletAddress ?? suiKit.currentAddress();
-  }
-  get suiKit() {
-    if (!this._suiKit) {
-      throw new Error("SuiKit instance is not initialized");
+      },
+      wusdt: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      sui: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      afsui: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      hasui: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      vsui: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      },
+      sca: {
+        id: "",
+        metaData: "",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "",
+            feedObject: ""
+          }
+        }
+      }
+    },
+    oracles: {
+      xOracle: "",
+      xOracleCap: "",
+      supra: { registry: "", registryCap: "", holder: "" },
+      switchboard: { registry: "", registryCap: "" },
+      pyth: {
+        registry: "",
+        registryCap: "",
+        state: "",
+        wormhole: "",
+        wormholeState: ""
+      }
+    },
+    packages: {
+      coinDecimalsRegistry: {
+        id: "",
+        upgradeCap: ""
+      },
+      math: {
+        id: "",
+        upgradeCap: ""
+      },
+      whitelist: {
+        id: "",
+        upgradeCap: ""
+      },
+      x: {
+        id: "",
+        upgradeCap: ""
+      },
+      protocol: {
+        id: "",
+        upgradeCap: ""
+      },
+      protocolWhitelist: {
+        id: "",
+        upgradeCap: ""
+      },
+      query: {
+        id: "",
+        upgradeCap: ""
+      },
+      supra: { id: "", upgradeCap: "" },
+      pyth: {
+        id: "",
+        upgradeCap: ""
+      },
+      switchboard: { id: "", upgradeCap: "" },
+      xOracle: {
+        id: "",
+        upgradeCap: ""
+      },
+      testCoin: { id: "", upgradeCap: "" }
     }
-    return this._suiKit;
-  }
-  get client() {
-    return this.suiKit.client();
-  }
-  /**
-   * @description Invalidate cache based on the refetchType parameter
-   * @param refetchType Determines the type of queries to be refetched. Defaults to `active`.
-   *
-   * - `active`: Only queries that match the refetch predicate and are actively being rendered via useQuery and related functions will be refetched in the background.
-   * - `inactive`: Only queries that match the refetch predicate and are NOT actively being rendered via useQuery and related functions will be refetched in the background.
-   * - `all`: All queries that match the refetch predicate will be refetched in the background.
-   * - `none`: No queries will be refetched. Queries that match the refetch predicate will only be marked as invalid.
-   */
-  // public async invalidateAllCache() {
-  //   return Object.values(queryKeys.rpc).map((t) =>
-  //     this.queryClient.invalidateQueries({
-  //       queryKey: t(),
-  //       type: 'all',
-  //     })
-  //   );
-  // }
-  retryFn(errCount, e) {
-    if (errCount === 5)
-      return false;
-    if (e.status === 429)
-      return true;
-    return false;
-  }
-  /**
-   * @description Provides cache for inspectTxn of the SuiKit.
-   * @param QueryInspectTxnParams
-   * @param txBlock
-   * @returns Promise<DevInspectResults>
-   */
-  async queryInspectTxn({
-    queryTarget,
-    args,
-    typeArgs
-  }) {
-    const txBlock = new SuiTxBlock();
-    const resolvedQueryTarget = await this.queryGetNormalizedMoveFunction(queryTarget);
-    if (!resolvedQueryTarget)
-      throw new Error("Invalid query target");
-    const { parameters } = resolvedQueryTarget;
-    const resolvedArgs = await Promise.all(
-      (args ?? []).map(async (arg, idx) => {
-        if (typeof arg !== "string")
-          return arg;
-        const cachedData = (await this.queryGetObject(arg))?.data;
-        if (!cachedData)
-          return arg;
-        const owner = cachedData.owner;
-        if (!owner || typeof owner !== "object" || !("Shared" in owner))
-          return {
-            objectId: cachedData.objectId,
-            version: cachedData.version,
-            digest: cachedData.digest
-          };
-        const parameter = parameters[idx];
-        if (typeof parameter !== "object" || !("MutableReference" in parameter || "Reference" in parameter))
-          return arg;
-        return {
-          objectId: cachedData.objectId,
-          initialSharedVersion: owner.Shared.initial_shared_version,
-          mutable: "MutableReference" in parameter
-        };
-      })
-    );
-    txBlock.moveCall(queryTarget, resolvedArgs, typeArgs);
-    const query = await this.queryClient.fetchQuery({
-      retry: this.retryFn,
-      retryDelay: 1e3,
-      queryKey: queryKeys.rpc.getInspectTxn(queryTarget, args, typeArgs),
-      queryFn: async () => {
-        return await callWithRateLimit(
-          this.tokenBucket,
-          async () => await this.suiKit.inspectTxn(txBlock)
-        );
+  },
+  spool: {
+    id: "",
+    adminCap: "",
+    object: "",
+    pools: {
+      sweth: {
+        id: "",
+        rewardPoolId: ""
+      },
+      ssui: {
+        id: "",
+        rewardPoolId: ""
+      },
+      swusdc: {
+        id: "",
+        rewardPoolId: ""
+      },
+      swusdt: {
+        id: "",
+        rewardPoolId: ""
+      },
+      scetus: {
+        id: "",
+        rewardPoolId: ""
+      },
+      safsui: {
+        id: "",
+        rewardPoolId: ""
+      },
+      shasui: {
+        id: "",
+        rewardPoolId: ""
+      },
+      svsui: {
+        id: "",
+        rewardPoolId: ""
       }
-    });
-    return query;
-  }
-  async queryGetNormalizedMoveFunction(target) {
-    const { address, module, name } = parseStructTag2(target);
-    return this.queryClient.fetchQuery({
-      queryKey: queryKeys.rpc.getNormalizedMoveFunction(target),
-      queryFn: async () => {
-        return await callWithRateLimit(
-          this.tokenBucket,
-          async () => await this.suiKit.client().getNormalizedMoveFunction({
-            package: address,
-            module,
-            function: name
-          })
-        );
+    },
+    config: ""
+  },
+  borrowIncentive: {
+    id: "",
+    adminCap: "",
+    object: "",
+    query: "",
+    incentivePools: "",
+    incentiveAccounts: "",
+    config: ""
+  },
+  vesca: {
+    id: "",
+    object: "",
+    adminCap: "",
+    tableId: "",
+    table: "",
+    treasury: "",
+    config: ""
+  },
+  referral: {
+    id: "",
+    version: "",
+    object: "",
+    adminCap: "",
+    referralBindings: "",
+    bindingTableId: "",
+    referralRevenuePool: "",
+    revenueTableId: "",
+    referralTiers: "",
+    tiersTableId: "",
+    authorizedWitnessList: ""
+  },
+  loyaltyProgram: {
+    id: "",
+    object: "",
+    rewardPool: "",
+    userRewardTableId: ""
+  },
+  scoin: {
+    id: "",
+    coins: {
+      ssui: {
+        coinType: "",
+        treasury: ""
+      },
+      scetus: {
+        coinType: "",
+        treasury: ""
+      },
+      ssca: {
+        coinType: "",
+        treasury: ""
+      },
+      swusdc: {
+        coinType: "",
+        treasury: ""
+      },
+      swusdt: {
+        coinType: "",
+        treasury: ""
+      },
+      sweth: {
+        coinType: "",
+        treasury: ""
+      },
+      safsui: {
+        coinType: "",
+        treasury: ""
+      },
+      shasui: {
+        coinType: "",
+        treasury: ""
+      },
+      svsui: {
+        coinType: "",
+        treasury: ""
       }
+    }
+  }
+};
+var ScallopAddress = class {
+  constructor(params, instance) {
+    const { id, auth, network, forceInterface } = params;
+    this.cache = instance?.cache ?? new ScallopCache({});
+    this._requestClient = axios.create({
+      baseURL: API_BASE_URL,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      timeout: 8e3
     });
+    if (auth)
+      this._auth = auth;
+    this._id = id;
+    this._network = network ?? "mainnet";
+    this._addressesMap = USE_TEST_ADDRESS ? /* @__PURE__ */ new Map([["mainnet", TEST_ADDRESSES]]) : /* @__PURE__ */ new Map();
+    if (USE_TEST_ADDRESS)
+      this._currentAddresses = TEST_ADDRESSES;
+    if (forceInterface) {
+      for (const [network2, addresses] of Object.entries(
+        forceInterface
+      )) {
+        if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
+          if (network2 === this._network)
+            this._currentAddresses = addresses;
+          this._addressesMap.set(network2, addresses);
+        }
+      }
+    }
   }
   /**
-   * @description Provides cache for getObject of the SuiKit.
-   * @param objectId
-   * @param QueryObjectParams
-   * @returns Promise<SuiObjectResponse>
+   * Get addresses API id.
+   *
+   * @return The addresses API id.
    */
-  async queryGetObject(objectId, options) {
-    options = {
-      ...options,
-      showOwner: true,
-      showContent: true
-    };
-    return this.queryClient.fetchQuery({
-      retry: this.retryFn,
-      retryDelay: 1e3,
-      queryKey: queryKeys.rpc.getObject(objectId, options),
-      queryFn: async () => {
-        return await callWithRateLimit(
-          this.tokenBucket,
-          async () => await this.client.getObject({
-            id: objectId,
-            options
-          })
-        );
-      }
-    });
+  getId() {
+    return this._id || void 0;
   }
   /**
-   * @description Provides cache for getObjects of the SuiKit.
-   * @param objectIds
-   * @returns Promise<SuiObjectData[]>
+   * Get the address at the provided path.
+   *
+   * @param path - The path of the address to get.
+   * @return The address at the provided path.
    */
-  async queryGetObjects(objectIds, options = {
-    showContent: true
-  }) {
-    if (objectIds.length === 0)
-      return [];
-    return this.queryClient.fetchQuery({
-      retry: this.retryFn,
-      retryDelay: 1e3,
-      queryKey: queryKeys.rpc.getObjects(
-        objectIds,
-        this.walletAddress,
-        options
-      ),
-      queryFn: async () => {
-        const results = await callWithRateLimit(
-          this.tokenBucket,
-          async () => await this.suiKit.getObjects(objectIds, options)
-        );
-        if (results) {
-          results.forEach((result) => {
-            this.queryClient.setQueriesData(
-              {
-                exact: false,
-                queryKey: queryKeys.rpc.getObject(result.objectId, options)
-              },
-              {
-                data: result,
-                error: null
-              },
-              {
-                updatedAt: Date.now()
-              }
-            );
-          });
-        }
-        return results;
-      }
-    });
+  get(path) {
+    if (this._currentAddresses) {
+      const value = path.split(".").reduce(
+        (nestedAddressObj, key) => typeof nestedAddressObj === "object" ? nestedAddressObj[key] : nestedAddressObj,
+        this._currentAddresses
+      );
+      return value || void 0;
+    } else {
+      return void 0;
+    }
   }
   /**
-   * @description Provides cache for getOwnedObjects of the SuiKit.
-   * @param input
-   * @returns Promise<PaginatedObjectsResponse>
+   * Sets the address for the specified path, it does not interact with the API.
+   *
+   * @param path - The path of the address to set.
+   * @param address - The address be setted to the tartget path.
+   * @return The addresses.
    */
-  async queryGetOwnedObjects(input) {
-    return this.queryClient.fetchQuery({
-      retry: this.retryFn,
-      retryDelay: 1e3,
-      queryKey: queryKeys.rpc.getOwnedObjects(input),
-      queryFn: async () => {
-        const results = await callWithRateLimit(
-          this.tokenBucket,
-          async () => await this.client.getOwnedObjects(input)
-        );
-        if (results && results.data.length > 0) {
-          results.data.filter(
-            (result) => !!result.data
-          ).forEach((result) => {
-            this.queryClient.setQueriesData(
-              {
-                exact: false,
-                queryKey: queryKeys.rpc.getObject(
-                  result.data.objectId,
-                  input.options ?? {}
-                )
-              },
-              {
-                data: result.data,
-                error: null
-              },
-              {
-                updatedAt: Date.now()
-              }
-            );
-          });
+  set(path, address) {
+    if (this._currentAddresses) {
+      const keys = path.split(".");
+      keys.reduce((nestedAddressObj, key, index) => {
+        if (index === keys.length - 1) {
+          nestedAddressObj[key] = address;
+        } else {
+          return nestedAddressObj[key];
         }
-        return results;
-      }
-    });
-  }
-  async queryGetDynamicFields(input) {
-    return this.queryClient.fetchQuery({
-      retry: this.retryFn,
-      retryDelay: 1e3,
-      queryKey: queryKeys.rpc.getDynamicFields(input),
-      queryFn: async () => {
-        return await callWithRateLimit(
-          this.tokenBucket,
-          async () => await this.client.getDynamicFields(input)
-        );
-      }
-    });
+      }, this._currentAddresses);
+    }
+    return this._currentAddresses;
   }
-  async queryGetDynamicFieldObject(input) {
-    return this.queryClient.fetchQuery({
-      retry: this.retryFn,
-      retryDelay: (attemptIndex) => Math.min(1e3 * attemptIndex, 8e3),
-      queryKey: queryKeys.rpc.getDynamicFieldObject(input),
-      queryFn: async () => {
-        const result = await callWithRateLimit(
-          this.tokenBucket,
-          () => this.client.getDynamicFieldObject(input)
-        );
-        if (result?.data) {
-          this.queryClient.setQueriesData(
-            {
-              exact: false,
-              queryKey: queryKeys.rpc.getObject(result?.data.objectId, {
-                showContent: true,
-                showOwner: true
-              })
-            },
-            {
-              data: result.data,
-              error: null
-            },
-            {
-              updatedAt: Date.now()
-            }
-          );
-        }
-        return result;
-      }
-    });
+  /**
+   * Synchronize the specified network addresses from the addresses map to the
+   * current addresses and change the default network to specified network.
+   *
+   * @param network - Specifies which network's addresses you want to get.
+   * @return Current addresses.
+   */
+  switchCurrentAddresses(network) {
+    if (this._addressesMap.has(network)) {
+      this._currentAddresses = this._addressesMap.get(network);
+      this._network = network;
+    }
+    return this._currentAddresses;
   }
-  async queryGetAllCoinBalances(owner) {
-    return this.queryClient.fetchQuery({
-      retry: this.retryFn,
-      retryDelay: 1e3,
-      queryKey: queryKeys.rpc.getAllCoinBalances(owner),
-      queryFn: async () => {
-        const allBalances = await callWithRateLimit(
-          this.tokenBucket,
-          async () => await this.client.getAllBalances({ owner })
-        );
-        if (!allBalances)
-          return {};
-        const balances = allBalances.reduce(
-          (acc, coinBalance) => {
-            if (coinBalance.totalBalance !== "0") {
-              acc[normalizeStructTag2(coinBalance.coinType)] = coinBalance.totalBalance;
-            }
-            return acc;
-          },
-          {}
-        );
-        return balances;
-      }
-    });
+  /**
+   * Get the addresses, If `network` is not provided, returns the current
+   * addresses or the default network addresses in the addresses map.
+   *
+   * @param network - Specifies which network's addresses you want to get.
+   */
+  getAddresses(network) {
+    if (network) {
+      return this._addressesMap.get(network);
+    } else {
+      return this._currentAddresses ?? this._addressesMap.get(this._network);
+    }
   }
-  async queryGetCoinBalance(input) {
-    if (!input.coinType)
-      return "0";
-    return (await this.queryGetAllCoinBalances(input.owner) ?? {})[normalizeStructTag2(input.coinType)] ?? "0";
+  /**
+   * Set the addresses into addresses map. If the specified network is the same
+   * as the current network, the current addresses will be updated at the same time.
+   *
+   * @param addresses - The addresses be setted to the tartget network.
+   * @param network - Specifies which network's addresses you want to set.
+   * @return The addresses.
+   */
+  setAddresses(addresses, network) {
+    const targetNetwork = network || this._network;
+    if (targetNetwork === this._network)
+      this._currentAddresses = addresses;
+    this._addressesMap.set(targetNetwork, addresses);
   }
-};
-
-// src/models/scallopAddress.ts
-import axios from "axios";
-var EMPTY_ADDRESSES = {
-  core: {
-    version: "",
-    versionCap: "",
-    object: "",
-    market: "",
-    adminCap: "",
-    coinDecimalsRegistry: "",
-    obligationAccessStore: "",
-    coins: {
-      cetus: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      wapt: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      wsol: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      wbtc: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      weth: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
-        }
-      },
-      wusdc: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
+  /**
+   * Get all addresses.
+   *
+   * @return All addresses.
+   */
+  getAllAddresses() {
+    return Object.fromEntries(this._addressesMap);
+  }
+  /**
+   * Create a new addresses through the API and synchronize it back to the
+   * instance.
+   *
+   * @description
+   * If the `network` is not specified, the mainnet is used by default.
+   * If no `addresses` from instance or parameter is provided, an addresses with
+   * all empty strings is created by default.
+   *
+   * This function only allows for one addresses to be input into a specific network
+   * at a time, and does not provide an addresses map for setting addresses
+   * across all networks at once.
+   *
+   * @param params.addresses - The addresses be setted to the tartget network.
+   * @param params.network - Specifies which network's addresses you want to set.
+   * @param params.auth - The authentication API key.
+   * @param params.memo - Add memo to the addresses created in the API.
+   * @return All addresses.
+   */
+  async create(params) {
+    const { addresses, network, auth, memo } = params ?? {};
+    const apiKey = auth || this._auth || void 0;
+    const targetNetwork = network || this._network;
+    const targetAddresses = addresses || this._currentAddresses || this._addressesMap.get(targetNetwork) || EMPTY_ADDRESSES;
+    if (apiKey !== void 0) {
+      this._addressesMap.clear();
+      this.setAddresses(targetAddresses, targetNetwork);
+      const response = await this._requestClient.post(
+        `/addresses`,
+        JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
           }
         }
-      },
-      wusdt: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
+      );
+      if (response.status === 201) {
+        for (const [network2, addresses2] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
+            if (network2 === this._network)
+              this._currentAddresses = addresses2;
+            this._addressesMap.set(network2, addresses2);
           }
         }
-      },
-      sui: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
-          }
+        this._id = response.data.id;
+        return this.getAllAddresses();
+      } else {
+        throw Error("Failed to create addresses.");
+      }
+    } else {
+      throw Error("You don't have permission to access this request.");
+    }
+  }
+  /**
+   * Read and synchronizes all addresses from the API into instance.
+   *
+   * @param id - The id of the addresses to get.
+   * @return All addresses.
+   */
+  async read(id) {
+    const addressesId = id || this._id || void 0;
+    if (addressesId !== void 0) {
+      const response = await this.cache.queryClient.fetchQuery({
+        queryKey: queryKeys.api.getAddresses(addressesId),
+        queryFn: async () => {
+          return await this._requestClient.get(`/addresses/${addressesId}`, {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
         }
-      },
-      afsui: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
+      });
+      if (response.status === 200) {
+        for (const [network, addresses] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network)) {
+            if (network === this._network)
+              this._currentAddresses = addresses;
+            this._addressesMap.set(network, addresses);
           }
         }
-      },
-      hasui: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
+        this._id = response.data.id;
+        return this.getAllAddresses();
+      } else {
+        throw Error("Failed to create addresses.");
+      }
+    } else {
+      throw Error("Please provide API addresses id.");
+    }
+  }
+  /**
+   * Update the addresses through the API and synchronize it back to the
+   * instance.
+   *
+   * @description
+   * If the `network` is not specified, the mainnet is used by default.
+   * If no `addresses` from instance or parameter is provided, an addresses with
+   * all empty strings is created by default.
+   *
+   * This function only allows for one addresses to be input into a specific network
+   * at a time, and does not provide an addresses map for setting addresses
+   * across all networks at once.
+   *
+   * @param params.id - The id of the addresses to update.
+   * @param params.addresses - The addresses be setted to the tartget network.
+   * @param params.network - Specifies which network's addresses you want to set.
+   * @param params.auth - The authentication api key.
+   * @param params.memo - Add memo to the addresses created in the API.
+   * @return All addresses.
+   */
+  async update(params) {
+    const { id, addresses, network, auth, memo } = params ?? {};
+    const apiKey = auth || this._auth || void 0;
+    const targetId = id || this._id || void 0;
+    const targetNetwork = network || this._network;
+    const targetAddresses = addresses || this._currentAddresses || this._addressesMap.get(targetNetwork) || EMPTY_ADDRESSES;
+    if (targetId === void 0)
+      throw Error("Require specific addresses id to be updated.");
+    if (apiKey !== void 0) {
+      if (id !== this._id) {
+        this._addressesMap.clear();
+      }
+      this.setAddresses(targetAddresses, targetNetwork);
+      const response = await this._requestClient.put(
+        `/addresses/${targetId}`,
+        JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
           }
         }
-      },
-      vsui: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
+      );
+      if (response.status === 200) {
+        for (const [network2, addresses2] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
+            if (network2 === this._network)
+              this._currentAddresses = addresses2;
+            this._addressesMap.set(network2, addresses2);
           }
         }
-      },
-      sca: {
-        id: "",
-        metaData: "",
-        treasury: "",
-        oracle: {
-          supra: "",
-          switchboard: "",
-          pyth: {
-            feed: "",
-            feedObject: ""
+        this._id = response.data.id;
+        return this.getAllAddresses();
+      } else {
+        throw Error("Failed to update addresses.");
+      }
+    } else {
+      throw Error("You don't have permission to access this request.");
+    }
+  }
+  /**
+   * Deletes all addresses of a specified id through the API and clear all
+   * addresses in the instance.
+   *
+   * @param id - The id of the addresses to delete.
+   * @param auth - The authentication API key.
+   */
+  async delete(id, auth) {
+    const apiKey = auth || this._auth || void 0;
+    const targetId = id || this._id || void 0;
+    if (targetId === void 0)
+      throw Error("Require specific addresses id to be deleted.");
+    if (apiKey !== void 0) {
+      const response = await this._requestClient.delete(
+        `/addresses/${targetId}`,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
           }
         }
+      );
+      if (response.status === 200) {
+        this._id = void 0;
+        this._currentAddresses = void 0;
+        this._addressesMap.clear();
+      } else {
+        throw Error("Failed to delete addresses.");
       }
-    },
-    oracles: {
-      xOracle: "",
-      xOracleCap: "",
-      supra: { registry: "", registryCap: "", holder: "" },
-      switchboard: { registry: "", registryCap: "" },
-      pyth: {
-        registry: "",
-        registryCap: "",
-        state: "",
-        wormhole: "",
-        wormholeState: ""
-      }
-    },
-    packages: {
-      coinDecimalsRegistry: {
-        id: "",
-        upgradeCap: ""
-      },
-      math: {
-        id: "",
-        upgradeCap: ""
-      },
-      whitelist: {
-        id: "",
-        upgradeCap: ""
-      },
-      x: {
-        id: "",
-        upgradeCap: ""
-      },
-      protocol: {
-        id: "",
-        upgradeCap: ""
-      },
-      protocolWhitelist: {
-        id: "",
-        upgradeCap: ""
-      },
-      query: {
-        id: "",
-        upgradeCap: ""
-      },
-      supra: { id: "", upgradeCap: "" },
-      pyth: {
-        id: "",
-        upgradeCap: ""
-      },
-      switchboard: { id: "", upgradeCap: "" },
-      xOracle: {
-        id: "",
-        upgradeCap: ""
-      },
-      testCoin: { id: "", upgradeCap: "" }
+    } else {
+      throw Error("You don't have permission to access this request.");
     }
-  },
-  spool: {
-    id: "",
-    adminCap: "",
-    object: "",
-    pools: {
-      sweth: {
-        id: "",
-        rewardPoolId: ""
-      },
-      ssui: {
-        id: "",
-        rewardPoolId: ""
-      },
-      swusdc: {
-        id: "",
-        rewardPoolId: ""
-      },
-      swusdt: {
-        id: "",
-        rewardPoolId: ""
-      },
-      scetus: {
-        id: "",
-        rewardPoolId: ""
-      },
-      safsui: {
-        id: "",
-        rewardPoolId: ""
-      },
-      shasui: {
-        id: "",
-        rewardPoolId: ""
-      },
-      svsui: {
-        id: "",
-        rewardPoolId: ""
+  }
+};
+
+// src/models/scallopClient.ts
+import { normalizeSuiAddress as normalizeSuiAddress3 } from "@mysten/sui/utils";
+
+// src/models/scallopUtils.ts
+import { SUI_TYPE_ARG as SUI_TYPE_ARG2, normalizeStructTag as normalizeStructTag7 } from "@mysten/sui/utils";
+import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
+
+// src/queries/borrowIncentiveQuery.ts
+import { normalizeStructTag as normalizeStructTag3 } from "@mysten/sui/utils";
+
+// src/utils/builder.ts
+var requireSender = (txBlock) => {
+  const sender = txBlock.blockData.sender;
+  if (!sender) {
+    throw new Error("Sender is required");
+  }
+  return sender;
+};
+var checkVesca = (prevUnlockAtInMillisTimestamp) => {
+  if (prevUnlockAtInMillisTimestamp === void 0) {
+    throw new Error("veSca not found");
+  }
+};
+var checkVescaExpired = (prevUnlockAtInMillisTimestamp) => {
+  if (prevUnlockAtInMillisTimestamp <= (/* @__PURE__ */ new Date()).getTime()) {
+    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
+  }
+};
+var checkExtendLockPeriod = (lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInMillisTimestamp) => {
+  checkVesca(prevUnlockAtInMillisTimestamp);
+  checkVescaExpired(prevUnlockAtInMillisTimestamp);
+  const prevUnlockAtInSecondTimestamp = Math.floor(
+    prevUnlockAtInMillisTimestamp / 1e3
+  );
+  if (lockPeriodInDays < 1) {
+    throw new Error("Minimum lock period is 1 day");
+  }
+  const availableLockPeriodInDays = Math.floor(
+    (newUnlockAtInSecondTimestamp - prevUnlockAtInSecondTimestamp) / UNLOCK_ROUND_DURATION
+  );
+  if (lockPeriodInDays > availableLockPeriodInDays) {
+    throw new Error(
+      `Cannot extend lock period by ${lockPeriodInDays} days, maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days), remaining lock period is ${MAX_LOCK_ROUNDS - availableLockPeriodInDays}`
+    );
+  }
+};
+var checkLockSca = (scaAmountOrCoin, lockPeriodInDays, newUnlockAtInSecondTimestamp, prevUnlockAtInMillisTimestamp) => {
+  const prevUnlockAtInSecondTimestamp = prevUnlockAtInMillisTimestamp ? Math.floor(prevUnlockAtInMillisTimestamp / 1e3) : void 0;
+  const isInitialLock = !prevUnlockAtInSecondTimestamp;
+  const isLockExpired = !isInitialLock && prevUnlockAtInSecondTimestamp * 1e3 <= (/* @__PURE__ */ new Date()).getTime();
+  if (isInitialLock || isLockExpired) {
+    if (scaAmountOrCoin !== void 0 && lockPeriodInDays !== void 0) {
+      if (lockPeriodInDays <= 0) {
+        throw new Error("Lock period must be greater than 0");
+      }
+      if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_INITIAL_LOCK_AMOUNT) {
+        throw new Error(
+          `Minimum lock amount for ${isLockExpired ? "renewing expired veSca" : "initial lock"} is 10 SCA`
+        );
+      }
+      const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
+      if (extendLockPeriodInSecond > MAX_LOCK_DURATION) {
+        throw new Error(
+          `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS} days)`
+        );
       }
-    },
-    config: ""
-  },
-  borrowIncentive: {
-    id: "",
-    adminCap: "",
-    object: "",
-    query: "",
-    incentivePools: "",
-    incentiveAccounts: "",
-    config: ""
-  },
-  vesca: {
-    id: "",
-    object: "",
-    adminCap: "",
-    tableId: "",
-    table: "",
-    treasury: "",
-    config: ""
-  },
-  referral: {
-    id: "",
-    version: "",
-    object: "",
-    adminCap: "",
-    referralBindings: "",
-    bindingTableId: "",
-    referralRevenuePool: "",
-    revenueTableId: "",
-    referralTiers: "",
-    tiersTableId: "",
-    authorizedWitnessList: ""
-  },
-  loyaltyProgram: {
-    id: "",
-    object: "",
-    rewardPool: "",
-    userRewardTableId: ""
-  },
-  scoin: {
-    id: "",
-    coins: {
-      ssui: {
-        coinType: "",
-        treasury: ""
-      },
-      scetus: {
-        coinType: "",
-        treasury: ""
-      },
-      ssca: {
-        coinType: "",
-        treasury: ""
-      },
-      swusdc: {
-        coinType: "",
-        treasury: ""
-      },
-      swusdt: {
-        coinType: "",
-        treasury: ""
-      },
-      sweth: {
-        coinType: "",
-        treasury: ""
-      },
-      safsui: {
-        coinType: "",
-        treasury: ""
+    } else {
+      throw new Error(
+        `SCA amount and lock period is required for ${isLockExpired ? "renewing expired veSca" : "initial lock"}`
+      );
+    }
+  } else {
+    checkVesca(prevUnlockAtInMillisTimestamp);
+    checkVescaExpired(prevUnlockAtInMillisTimestamp);
+    if (typeof scaAmountOrCoin === "number" && scaAmountOrCoin < MIN_TOP_UP_AMOUNT) {
+      throw new Error("Minimum top up amount is 1 SCA");
+    }
+    if (newUnlockAtInSecondTimestamp && lockPeriodInDays) {
+      checkExtendLockPeriod(
+        lockPeriodInDays,
+        newUnlockAtInSecondTimestamp,
+        prevUnlockAtInMillisTimestamp
+      );
+    }
+  }
+};
+var checkExtendLockAmount = (scaAmount, prevUnlockAtInMillisTimestamp) => {
+  checkVesca(prevUnlockAtInMillisTimestamp);
+  checkVescaExpired(prevUnlockAtInMillisTimestamp);
+  if (scaAmount < MIN_TOP_UP_AMOUNT) {
+    throw new Error("Minimum top up amount is 1 SCA");
+  }
+  const isInitialLock = !prevUnlockAtInMillisTimestamp;
+  const isLockExpired = !isInitialLock && prevUnlockAtInMillisTimestamp <= (/* @__PURE__ */ new Date()).getTime();
+  if (isLockExpired) {
+    throw new Error("veSca is expired, use renewExpiredVeScaQuick instead");
+  }
+};
+var checkRenewExpiredVeSca = (scaAmount, lockPeriodInDays, prevUnlockAtInMillisTimestamp) => {
+  if (!prevUnlockAtInMillisTimestamp || prevUnlockAtInMillisTimestamp > (/* @__PURE__ */ new Date()).getTime()) {
+    throw new Error("Renew method can only be used for expired veSca");
+  }
+  if (scaAmount < MIN_INITIAL_LOCK_AMOUNT) {
+    throw new Error("Minimum lock amount for renewing expired vesca 10 SCA");
+  }
+  const extendLockPeriodInSecond = lockPeriodInDays * UNLOCK_ROUND_DURATION;
+  if (extendLockPeriodInSecond >= MAX_LOCK_DURATION - UNLOCK_ROUND_DURATION) {
+    throw new Error(
+      `Maximum lock period is ~4 years (${MAX_LOCK_ROUNDS - 1} days)`
+    );
+  }
+};
+
+// src/utils/query.ts
+import BigNumber from "bignumber.js";
+import { normalizeStructTag as normalizeStructTag2, parseStructTag as parseStructTag2 } from "@mysten/sui/utils";
+var parseOriginMarketPoolData = (originMarketPoolData) => {
+  return {
+    coinType: normalizeStructTag2(originMarketPoolData.type.name),
+    // Parse origin data required for basic calculations.
+    maxBorrowRate: Number(originMarketPoolData.maxBorrowRate.value) / 2 ** 32,
+    borrowRate: Number(originMarketPoolData.interestRate.value) / 2 ** 32,
+    borrowRateScale: Number(originMarketPoolData.interestRateScale),
+    borrowIndex: Number(originMarketPoolData.borrowIndex),
+    lastUpdated: Number(originMarketPoolData.lastUpdated),
+    cashAmount: Number(originMarketPoolData.cash),
+    debtAmount: Number(originMarketPoolData.debt),
+    marketCoinSupplyAmount: Number(originMarketPoolData.marketCoinSupply),
+    reserveAmount: Number(originMarketPoolData.reserve),
+    reserveFactor: Number(originMarketPoolData.reserveFactor.value) / 2 ** 32,
+    borrowWeight: Number(originMarketPoolData.borrowWeight.value) / 2 ** 32,
+    borrowFee: Number(originMarketPoolData.borrowFeeRate.value) / 2 ** 32,
+    // Parse origin data required for additional display.
+    baseBorrowRate: Number(originMarketPoolData.baseBorrowRatePerSec.value) / 2 ** 32,
+    borrowRateOnHighKink: Number(originMarketPoolData.borrowRateOnHighKink.value) / 2 ** 32,
+    borrowRateOnMidKink: Number(originMarketPoolData.borrowRateOnMidKink.value) / 2 ** 32,
+    highKink: Number(originMarketPoolData.highKink.value) / 2 ** 32,
+    midKink: Number(originMarketPoolData.midKink.value) / 2 ** 32,
+    minBorrowAmount: Number(originMarketPoolData.minBorrowAmount),
+    isIsolated: originMarketPoolData.isIsolated,
+    supplyLimit: Number(originMarketPoolData.supplyLimit),
+    borrowLimit: Number(originMarketPoolData.borrowLimit)
+  };
+};
+var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
+  const poolCoinName = utils.parseCoinNameFromType(
+    parsedMarketPoolData.coinType
+  );
+  const coinDecimal = utils.getCoinDecimal(poolCoinName);
+  const borrowYearFactor = 24 * 365 * 3600;
+  const baseBorrowApr = parsedMarketPoolData.baseBorrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const borrowAprOnHighKink = parsedMarketPoolData.borrowRateOnHighKink * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const borrowAprOnMidKink = parsedMarketPoolData.borrowRateOnMidKink * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const maxBorrowApr = parsedMarketPoolData.maxBorrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const borrowApr = parsedMarketPoolData.borrowRate * borrowYearFactor / parsedMarketPoolData.borrowRateScale;
+  const timeDelta = Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedMarketPoolData.lastUpdated;
+  const borrowIndexDelta = BigNumber(parsedMarketPoolData.borrowIndex).multipliedBy(
+    BigNumber(timeDelta).multipliedBy(parsedMarketPoolData.borrowRate)
+  ).dividedBy(parsedMarketPoolData.borrowRateScale);
+  const currentBorrowIndex = BigNumber(parsedMarketPoolData.borrowIndex).plus(
+    borrowIndexDelta
+  );
+  const growthInterest = BigNumber(currentBorrowIndex).dividedBy(parsedMarketPoolData.borrowIndex).minus(1);
+  const increasedDebtAmount = BigNumber(
+    parsedMarketPoolData.debtAmount
+  ).multipliedBy(growthInterest);
+  const borrowAmount = increasedDebtAmount.plus(
+    parsedMarketPoolData.debtAmount
+  );
+  const borrowCoin = borrowAmount.shiftedBy(-1 * coinDecimal);
+  const reserveAmount = BigNumber(parsedMarketPoolData.reserveAmount).plus(
+    increasedDebtAmount.multipliedBy(parsedMarketPoolData.reserveFactor)
+  );
+  const reserveCoin = reserveAmount.shiftedBy(-1 * coinDecimal);
+  const supplyAmount = BigNumber(borrowAmount).plus(
+    Math.max(parsedMarketPoolData.cashAmount - reserveAmount.toNumber(), 0)
+  );
+  const supplyCoin = supplyAmount.shiftedBy(-1 * coinDecimal);
+  let utilizationRate = BigNumber(borrowAmount).dividedBy(supplyAmount);
+  utilizationRate = utilizationRate.isFinite() ? utilizationRate : BigNumber(0);
+  let supplyApr = BigNumber(borrowApr).multipliedBy(utilizationRate).multipliedBy(1 - parsedMarketPoolData.reserveFactor);
+  supplyApr = supplyApr.isFinite() ? supplyApr : BigNumber(0);
+  let conversionRate = supplyAmount.dividedBy(
+    parsedMarketPoolData.marketCoinSupplyAmount
+  );
+  conversionRate = conversionRate.isFinite() && !conversionRate.isNaN() ? conversionRate : BigNumber(1);
+  return {
+    baseBorrowApr,
+    baseBorrowApy: utils.parseAprToApy(baseBorrowApr),
+    borrowAprOnHighKink,
+    borrowApyOnHighKink: utils.parseAprToApy(borrowAprOnHighKink),
+    borrowAprOnMidKink,
+    borrowApyOnMidKink: utils.parseAprToApy(borrowAprOnMidKink),
+    coinDecimal,
+    maxBorrowApr,
+    maxBorrowApy: utils.parseAprToApy(maxBorrowApr),
+    borrowApr: Math.min(borrowApr, maxBorrowApr),
+    borrowApy: Math.min(
+      utils.parseAprToApy(borrowApr),
+      utils.parseAprToApy(maxBorrowApr)
+    ),
+    borrowIndex: currentBorrowIndex.toNumber(),
+    growthInterest: growthInterest.toNumber(),
+    supplyAmount: supplyAmount.toNumber(),
+    supplyCoin: supplyCoin.toNumber(),
+    borrowAmount: borrowAmount.toNumber(),
+    borrowCoin: borrowCoin.toNumber(),
+    reserveAmount: reserveAmount.toNumber(),
+    reserveCoin: reserveCoin.toNumber(),
+    utilizationRate: utilizationRate.toNumber(),
+    supplyApr: supplyApr.toNumber(),
+    supplyApy: utils.parseAprToApy(supplyApr.toNumber()),
+    conversionRate: conversionRate.toNumber(),
+    isIsolated: parsedMarketPoolData.isIsolated,
+    maxSupplyCoin: BigNumber(parsedMarketPoolData.supplyLimit).shiftedBy(-coinDecimal).toNumber(),
+    maxBorrowCoin: BigNumber(parsedMarketPoolData.borrowLimit).shiftedBy(-coinDecimal).toNumber()
+  };
+};
+var parseOriginMarketCollateralData = (originMarketCollateralData) => {
+  const divisor = 2 ** 32;
+  return {
+    coinType: normalizeStructTag2(originMarketCollateralData.type.name),
+    isIsolated: originMarketCollateralData.isIsolated,
+    collateralFactor: Number(originMarketCollateralData.collateralFactor.value) / divisor,
+    liquidationFactor: Number(originMarketCollateralData.liquidationFactor.value) / divisor,
+    liquidationDiscount: Number(originMarketCollateralData.liquidationDiscount.value) / divisor,
+    liquidationPenalty: Number(originMarketCollateralData.liquidationPenalty.value) / divisor,
+    liquidationReserveFactor: Number(originMarketCollateralData.liquidationReserveFactor.value) / divisor,
+    maxCollateralAmount: Number(originMarketCollateralData.maxCollateralAmount),
+    totalCollateralAmount: Number(
+      originMarketCollateralData.totalCollateralAmount
+    )
+  };
+};
+var calculateMarketCollateralData = (utils, parsedMarketCollateralData) => {
+  const collateralCoinName = utils.parseCoinNameFromType(
+    parsedMarketCollateralData.coinType
+  );
+  const coinDecimal = utils.getCoinDecimal(collateralCoinName);
+  const maxCollateralCoin = BigNumber(
+    parsedMarketCollateralData.maxCollateralAmount
+  ).shiftedBy(-1 * coinDecimal);
+  const depositCoin = BigNumber(
+    parsedMarketCollateralData.totalCollateralAmount
+  ).shiftedBy(-1 * coinDecimal);
+  return {
+    coinDecimal,
+    isIsolated: parsedMarketCollateralData.isIsolated,
+    maxDepositAmount: parsedMarketCollateralData.maxCollateralAmount,
+    maxDepositCoin: maxCollateralCoin.toNumber(),
+    depositAmount: parsedMarketCollateralData.totalCollateralAmount,
+    depositCoin: depositCoin.toNumber()
+  };
+};
+var parseOriginSpoolData = (originSpoolData) => {
+  return {
+    stakeType: normalizeStructTag2(originSpoolData.stakeType.fields.name),
+    maxPoint: Number(originSpoolData.maxDistributedPoint),
+    distributedPoint: Number(originSpoolData.distributedPoint),
+    pointPerPeriod: Number(originSpoolData.distributedPointPerPeriod),
+    period: Number(originSpoolData.pointDistributionTime),
+    maxStake: Number(originSpoolData.maxStake),
+    staked: Number(originSpoolData.stakes),
+    index: Number(originSpoolData.index),
+    createdAt: Number(originSpoolData.createdAt),
+    lastUpdate: Number(originSpoolData.lastUpdate)
+  };
+};
+var calculateSpoolData = (parsedSpoolData, stakeMarketCoinPrice, stakeMarketCoinDecimal) => {
+  const baseIndexRate = 1e9;
+  const distributedPointPerSec = BigNumber(
+    parsedSpoolData.pointPerPeriod
+  ).dividedBy(parsedSpoolData.period);
+  const pointPerSec = BigNumber(parsedSpoolData.pointPerPeriod).dividedBy(
+    parsedSpoolData.period
+  );
+  const remainingPeriod = pointPerSec.gt(0) ? BigNumber(parsedSpoolData.maxPoint).minus(parsedSpoolData.distributedPoint).dividedBy(pointPerSec) : BigNumber(0);
+  const startDate = parsedSpoolData.createdAt;
+  const endDate = remainingPeriod.plus(parsedSpoolData.lastUpdate).integerValue().toNumber();
+  const timeDelta = BigNumber(
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedSpoolData.lastUpdate
+  ).dividedBy(parsedSpoolData.period).toFixed(0);
+  const remainingPoints = BigNumber(parsedSpoolData.maxPoint).minus(
+    parsedSpoolData.distributedPoint
+  );
+  const accumulatedPoints = BigNumber.minimum(
+    BigNumber(timeDelta).multipliedBy(parsedSpoolData.pointPerPeriod),
+    remainingPoints
+  );
+  const currentPointIndex = BigNumber(parsedSpoolData.index).plus(
+    accumulatedPoints.dividedBy(parsedSpoolData.staked).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedSpoolData.staked) : 0
+  );
+  const currentTotalDistributedPoint = BigNumber(
+    parsedSpoolData.distributedPoint
+  ).plus(accumulatedPoints);
+  const stakedAmount = BigNumber(parsedSpoolData.staked);
+  const stakedCoin = stakedAmount.shiftedBy(-1 * stakeMarketCoinDecimal);
+  const stakedValue = stakedCoin.multipliedBy(stakeMarketCoinPrice);
+  return {
+    distributedPointPerSec: distributedPointPerSec.toNumber(),
+    accumulatedPoints: accumulatedPoints.toNumber(),
+    currentPointIndex: currentPointIndex.toNumber(),
+    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
+    startDate: new Date(startDate * 1e3),
+    endDate: new Date(endDate * 1e3),
+    stakedAmount: stakedAmount.toNumber(),
+    stakedCoin: stakedCoin.toNumber(),
+    stakedValue: stakedValue.toNumber()
+  };
+};
+var parseOriginSpoolRewardPoolData = (originSpoolRewardPoolData) => {
+  return {
+    claimedRewards: Number(originSpoolRewardPoolData.claimed_rewards),
+    exchangeRateDenominator: Number(
+      originSpoolRewardPoolData.exchange_rate_denominator
+    ),
+    exchangeRateNumerator: Number(
+      originSpoolRewardPoolData.exchange_rate_numerator
+    ),
+    rewards: Number(originSpoolRewardPoolData.rewards),
+    spoolId: String(originSpoolRewardPoolData.spool_id)
+  };
+};
+var calculateSpoolRewardPoolData = (parsedSpoolData, parsedSpoolRewardPoolData, calculatedSpoolData, rewardCoinPrice, rewardCoinDecimal) => {
+  const rateYearFactor = 365 * 24 * 60 * 60;
+  const rewardPerSec = BigNumber(calculatedSpoolData.distributedPointPerSec).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
+  const totalRewardAmount = BigNumber(parsedSpoolData.maxPoint).multipliedBy(parsedSpoolRewardPoolData.exchangeRateNumerator).dividedBy(parsedSpoolRewardPoolData.exchangeRateDenominator);
+  const totalRewardCoin = totalRewardAmount.shiftedBy(-1 * rewardCoinDecimal);
+  const totalRewardValue = totalRewardCoin.multipliedBy(rewardCoinPrice);
+  const remaindRewardAmount = BigNumber(parsedSpoolRewardPoolData.rewards);
+  const remaindRewardCoin = remaindRewardAmount.shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const remaindRewardValue = remaindRewardCoin.multipliedBy(rewardCoinPrice);
+  const claimedRewardAmount = BigNumber(
+    parsedSpoolRewardPoolData.claimedRewards
+  );
+  const claimedRewardCoin = claimedRewardAmount.shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const claimedRewardValue = claimedRewardCoin.multipliedBy(rewardCoinPrice);
+  const rewardValueForYear = BigNumber(rewardPerSec).shiftedBy(-1 * rewardCoinDecimal).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
+  let rewardRate = rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).isFinite() ? rewardValueForYear.dividedBy(calculatedSpoolData.stakedValue).toNumber() : Infinity;
+  if (parsedSpoolData.maxPoint <= parsedSpoolData.distributedPoint || parsedSpoolData.pointPerPeriod === 0) {
+    rewardRate = Infinity;
+  }
+  return {
+    rewardApr: rewardRate,
+    totalRewardAmount: totalRewardAmount.toNumber(),
+    totalRewardCoin: totalRewardCoin.toNumber(),
+    totalRewardValue: totalRewardValue.toNumber(),
+    remaindRewardAmount: remaindRewardAmount.toNumber(),
+    remaindRewardCoin: remaindRewardCoin.toNumber(),
+    remaindRewardValue: remaindRewardValue.toNumber(),
+    claimedRewardAmount: claimedRewardAmount.toNumber(),
+    claimedRewardCoin: claimedRewardCoin.toNumber(),
+    claimedRewardValue: claimedRewardValue.toNumber(),
+    rewardPerSec: rewardPerSec.toNumber()
+  };
+};
+var parseOriginBorrowIncentivesPoolPointData = (originBorrowIncentivePoolPointData) => {
+  return {
+    pointType: normalizeStructTag2(
+      originBorrowIncentivePoolPointData.point_type.name
+    ),
+    distributedPointPerPeriod: Number(
+      originBorrowIncentivePoolPointData.distributed_point_per_period
+    ),
+    period: Number(originBorrowIncentivePoolPointData.point_distribution_time),
+    distributedPoint: Number(
+      originBorrowIncentivePoolPointData.distributed_point
+    ),
+    points: Number(originBorrowIncentivePoolPointData.points),
+    index: Number(originBorrowIncentivePoolPointData.index),
+    baseWeight: Number(originBorrowIncentivePoolPointData.base_weight),
+    weightedAmount: Number(originBorrowIncentivePoolPointData.weighted_amount),
+    lastUpdate: Number(originBorrowIncentivePoolPointData.last_update),
+    createdAt: Number(originBorrowIncentivePoolPointData.created_at)
+  };
+};
+var parseOriginBorrowIncentivePoolData = (utils, originBorrowIncentivePoolData) => {
+  return {
+    poolType: normalizeStructTag2(originBorrowIncentivePoolData.pool_type.name),
+    minStakes: Number(originBorrowIncentivePoolData.min_stakes),
+    maxStakes: Number(originBorrowIncentivePoolData.max_stakes),
+    staked: Number(originBorrowIncentivePoolData.stakes),
+    poolPoints: originBorrowIncentivePoolData.points.reduce(
+      (acc, point) => {
+        const parsed = parseOriginBorrowIncentivesPoolPointData(point);
+        const name = utils.parseSCoinTypeNameToMarketCoinName(
+          parseStructTag2(parsed.pointType).name.toLowerCase()
+        );
+        acc[name] = parsed;
+        return acc;
       },
-      shasui: {
-        coinType: "",
-        treasury: ""
+      {}
+    )
+  };
+};
+var calculateBorrowIncentivePoolPointData = (parsedBorrowIncentivePoolPointData, rewardCoinPrice, rewardCoinDecimal, poolCoinPrice, poolCoinDecimal) => {
+  const baseIndexRate = 1e9;
+  const distributedPointPerSec = BigNumber(
+    parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
+  ).dividedBy(parsedBorrowIncentivePoolPointData.period);
+  const timeDelta = BigNumber(
+    Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3) - parsedBorrowIncentivePoolPointData.lastUpdate
+  ).dividedBy(parsedBorrowIncentivePoolPointData.period).toFixed(0);
+  const accumulatedPoints = BigNumber.minimum(
+    BigNumber(timeDelta).multipliedBy(
+      parsedBorrowIncentivePoolPointData.distributedPointPerPeriod
+    ),
+    BigNumber(parsedBorrowIncentivePoolPointData.points)
+  );
+  const currentPointIndex = BigNumber(
+    parsedBorrowIncentivePoolPointData.index
+  ).plus(
+    accumulatedPoints.dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount).isFinite() ? BigNumber(baseIndexRate).multipliedBy(accumulatedPoints).dividedBy(parsedBorrowIncentivePoolPointData.weightedAmount) : 0
+  );
+  const currentTotalDistributedPoint = BigNumber(
+    parsedBorrowIncentivePoolPointData.distributedPoint
+  ).plus(accumulatedPoints);
+  const baseWeight = BigNumber(parsedBorrowIncentivePoolPointData.baseWeight);
+  const weightedStakedAmount = BigNumber(
+    parsedBorrowIncentivePoolPointData.weightedAmount
+  );
+  const weightedStakedCoin = weightedStakedAmount.shiftedBy(
+    -1 * poolCoinDecimal
+  );
+  const weightedStakedValue = weightedStakedCoin.multipliedBy(poolCoinPrice);
+  const rateYearFactor = 365 * 24 * 60 * 60;
+  const rewardPerSec = BigNumber(distributedPointPerSec).shiftedBy(
+    -1 * rewardCoinDecimal
+  );
+  const rewardValueForYear = BigNumber(rewardPerSec).multipliedBy(rateYearFactor).multipliedBy(rewardCoinPrice);
+  const weightScale = BigNumber(1e12);
+  const rewardRate = rewardValueForYear.multipliedBy(
+    BigNumber(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
+      weightScale
+    )
+  ).dividedBy(weightedStakedValue).isFinite() && parsedBorrowIncentivePoolPointData.points > 0 ? rewardValueForYear.multipliedBy(
+    BigNumber(parsedBorrowIncentivePoolPointData.baseWeight).dividedBy(
+      weightScale
+    )
+  ).dividedBy(weightedStakedValue).toNumber() : Infinity;
+  return {
+    distributedPointPerSec: distributedPointPerSec.toNumber(),
+    accumulatedPoints: accumulatedPoints.toNumber(),
+    currentPointIndex: currentPointIndex.toNumber(),
+    currentTotalDistributedPoint: currentTotalDistributedPoint.toNumber(),
+    baseWeight: baseWeight.toNumber(),
+    weightedStakedAmount: weightedStakedAmount.toNumber(),
+    weightedStakedCoin: weightedStakedCoin.toNumber(),
+    weightedStakedValue: weightedStakedValue.toNumber(),
+    rewardApr: rewardRate,
+    rewardPerSec: rewardPerSec.toNumber()
+  };
+};
+var parseOriginBorrowIncentiveAccountPoolPointData = (originBorrowIncentiveAccountPoolPointData) => {
+  return {
+    pointType: normalizeStructTag2(
+      originBorrowIncentiveAccountPoolPointData.point_type.name
+    ),
+    weightedAmount: Number(
+      originBorrowIncentiveAccountPoolPointData.weighted_amount
+    ),
+    points: Number(originBorrowIncentiveAccountPoolPointData.points),
+    totalPoints: Number(originBorrowIncentiveAccountPoolPointData.total_points),
+    index: Number(originBorrowIncentiveAccountPoolPointData.index)
+  };
+};
+var parseOriginBorrowIncentiveAccountData = (originBorrowIncentiveAccountData) => {
+  return {
+    poolType: normalizeStructTag2(
+      originBorrowIncentiveAccountData.pool_type.name
+    ),
+    debtAmount: Number(originBorrowIncentiveAccountData.debt_amount),
+    pointList: originBorrowIncentiveAccountData.points_list.reduce(
+      (acc, point) => {
+        const parsed = parseOriginBorrowIncentiveAccountPoolPointData(point);
+        const name = parseStructTag2(
+          parsed.pointType
+        ).name.toLowerCase();
+        acc[name] = parsed;
+        return acc;
       },
-      svsui: {
-        coinType: "",
-        treasury: ""
-      }
-    }
-  }
+      {}
+    )
+  };
+};
+var minBigNumber = (...args) => {
+  return BigNumber(
+    args.reduce(
+      (min, current) => new BigNumber(current).lt(min) ? current : min
+    )
+  );
+};
+var estimatedFactor = (amount, scaleStep, type) => {
+  const amountOfDigits = Math.max(
+    1,
+    Math.floor(Math.log10(Math.abs(amount)) + 1)
+  );
+  const adjustScale = Math.max(Math.floor((amountOfDigits - 1) / scaleStep), 1) + 1;
+  let adjustFactor = Math.pow(10, -adjustScale);
+  adjustFactor = type === "increase" ? 1 - adjustFactor : 1 + adjustFactor;
+  return adjustFactor;
+};
+
+// src/utils/util.ts
+var COIN_SET = Array.from(
+  /* @__PURE__ */ new Set([
+    ...SUPPORT_POOLS,
+    ...SUPPORT_COLLATERALS,
+    ...SUPPORT_SPOOLS_REWARDS,
+    ...SUPPORT_BORROW_INCENTIVE_REWARDS,
+    ...SUPPORT_SCOIN
+  ])
+);
+var isMarketCoin = (coinName) => {
+  const assetCoinName = coinName.slice(1).toLowerCase();
+  return coinName.charAt(0).toLowerCase() === "s" && COIN_SET.includes(assetCoinName);
 };
-var ScallopAddress = class {
-  constructor(params, instance) {
-    const { id, auth, network, forceInterface } = params;
-    this.cache = instance?.cache ?? new ScallopCache(
-      instance?.suiKit ?? new SuiKit({}),
-      void 0,
-      DEFAULT_CACHE_OPTIONS
-    );
-    this._requestClient = axios.create({
-      baseURL: API_BASE_URL,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      timeout: 8e3
-    });
-    if (auth)
-      this._auth = auth;
-    this._id = id;
-    this._network = network ?? "mainnet";
-    this._addressesMap = USE_TEST_ADDRESS ? /* @__PURE__ */ new Map([["mainnet", TEST_ADDRESSES]]) : /* @__PURE__ */ new Map();
-    if (USE_TEST_ADDRESS)
-      this._currentAddresses = TEST_ADDRESSES;
-    if (forceInterface) {
-      for (const [network2, addresses] of Object.entries(
-        forceInterface
-      )) {
-        if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
-          if (network2 === this._network)
-            this._currentAddresses = addresses;
-          this._addressesMap.set(network2, addresses);
-        }
-      }
-    }
-  }
-  /**
-   * Get addresses API id.
-   *
-   * @return The addresses API id.
-   */
-  getId() {
-    return this._id || void 0;
-  }
-  /**
-   * Get the address at the provided path.
-   *
-   * @param path - The path of the address to get.
-   * @return The address at the provided path.
-   */
-  get(path) {
-    if (this._currentAddresses) {
-      const value = path.split(".").reduce(
-        (nestedAddressObj, key) => typeof nestedAddressObj === "object" ? nestedAddressObj[key] : nestedAddressObj,
-        this._currentAddresses
-      );
-      return value || void 0;
-    } else {
-      return void 0;
-    }
-  }
-  /**
-   * Sets the address for the specified path, it does not interact with the API.
-   *
-   * @param path - The path of the address to set.
-   * @param address - The address be setted to the tartget path.
-   * @return The addresses.
-   */
-  set(path, address) {
-    if (this._currentAddresses) {
-      const keys = path.split(".");
-      keys.reduce((nestedAddressObj, key, index) => {
-        if (index === keys.length - 1) {
-          nestedAddressObj[key] = address;
-        } else {
-          return nestedAddressObj[key];
-        }
-      }, this._currentAddresses);
-    }
-    return this._currentAddresses;
-  }
-  /**
-   * Synchronize the specified network addresses from the addresses map to the
-   * current addresses and change the default network to specified network.
-   *
-   * @param network - Specifies which network's addresses you want to get.
-   * @return Current addresses.
-   */
-  switchCurrentAddresses(network) {
-    if (this._addressesMap.has(network)) {
-      this._currentAddresses = this._addressesMap.get(network);
-      this._network = network;
-    }
-    return this._currentAddresses;
-  }
-  /**
-   * Get the addresses, If `network` is not provided, returns the current
-   * addresses or the default network addresses in the addresses map.
-   *
-   * @param network - Specifies which network's addresses you want to get.
-   */
-  getAddresses(network) {
-    if (network) {
-      return this._addressesMap.get(network);
-    } else {
-      return this._currentAddresses ?? this._addressesMap.get(this._network);
-    }
+var isSuiBridgeAsset = (coinName) => {
+  return SUPPORT_SUI_BRIDGE.includes(coinName);
+};
+var isWormholeAsset = (coinName) => {
+  return SUPPORT_WORMHOLE.includes(coinName);
+};
+var parseAssetSymbol = (coinName) => {
+  if (isWormholeAsset(coinName)) {
+    return `w${coinName.slice(1).toUpperCase()}`;
   }
-  /**
-   * Set the addresses into addresses map. If the specified network is the same
-   * as the current network, the current addresses will be updated at the same time.
-   *
-   * @param addresses - The addresses be setted to the tartget network.
-   * @param network - Specifies which network's addresses you want to set.
-   * @return The addresses.
-   */
-  setAddresses(addresses, network) {
-    const targetNetwork = network || this._network;
-    if (targetNetwork === this._network)
-      this._currentAddresses = addresses;
-    this._addressesMap.set(targetNetwork, addresses);
+  if (isSuiBridgeAsset(coinName)) {
+    return `sb${coinName.slice(2).toUpperCase()}`;
   }
-  /**
-   * Get all addresses.
-   *
-   * @return All addresses.
-   */
-  getAllAddresses() {
-    return Object.fromEntries(this._addressesMap);
+  if (isMarketCoin(coinName)) {
+    const assetCoinName = coinName.slice(1).toLowerCase();
+    return coinName.slice(0, 1).toLowerCase() + parseAssetSymbol(assetCoinName);
   }
-  /**
-   * Create a new addresses through the API and synchronize it back to the
-   * instance.
-   *
-   * @description
-   * If the `network` is not specified, the mainnet is used by default.
-   * If no `addresses` from instance or parameter is provided, an addresses with
-   * all empty strings is created by default.
-   *
-   * This function only allows for one addresses to be input into a specific network
-   * at a time, and does not provide an addresses map for setting addresses
-   * across all networks at once.
-   *
-   * @param params.addresses - The addresses be setted to the tartget network.
-   * @param params.network - Specifies which network's addresses you want to set.
-   * @param params.auth - The authentication API key.
-   * @param params.memo - Add memo to the addresses created in the API.
-   * @return All addresses.
-   */
-  async create(params) {
-    const { addresses, network, auth, memo } = params ?? {};
-    const apiKey = auth || this._auth || void 0;
-    const targetNetwork = network || this._network;
-    const targetAddresses = addresses || this._currentAddresses || this._addressesMap.get(targetNetwork) || EMPTY_ADDRESSES;
-    if (apiKey !== void 0) {
-      this._addressesMap.clear();
-      this.setAddresses(targetAddresses, targetNetwork);
-      const response = await this._requestClient.post(
-        `/addresses`,
-        JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
-        {
-          headers: {
-            "Content-Type": "application/json",
-            "api-key": auth || this._auth
-          }
-        }
-      );
-      if (response.status === 201) {
-        for (const [network2, addresses2] of Object.entries(
-          response.data
-        )) {
-          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
-            if (network2 === this._network)
-              this._currentAddresses = addresses2;
-            this._addressesMap.set(network2, addresses2);
-          }
-        }
-        this._id = response.data.id;
-        return this.getAllAddresses();
-      } else {
-        throw Error("Failed to create addresses.");
-      }
-    } else {
-      throw Error("You don't have permission to access this request.");
-    }
+  switch (coinName) {
+    case "afsui":
+      return "afSUI";
+    case "hasui":
+      return "haSUI";
+    case "vsui":
+      return "vSUI";
+    default:
+      return coinName.toUpperCase();
   }
-  /**
-   * Read and synchronizes all addresses from the API into instance.
-   *
-   * @param id - The id of the addresses to get.
-   * @return All addresses.
-   */
-  async read(id) {
-    const addressesId = id || this._id || void 0;
-    if (addressesId !== void 0) {
-      const response = await this.cache.queryClient.fetchQuery({
-        queryKey: queryKeys.api.getAddresses(addressesId),
-        queryFn: async () => {
-          return await this._requestClient.get(`/addresses/${addressesId}`, {
-            headers: {
-              "Content-Type": "application/json"
-            }
-          });
-        }
-      });
-      if (response.status === 200) {
-        for (const [network, addresses] of Object.entries(
-          response.data
-        )) {
-          if (["localnet", "devnet", "testnet", "mainnet"].includes(network)) {
-            if (network === this._network)
-              this._currentAddresses = addresses;
-            this._addressesMap.set(network, addresses);
-          }
-        }
-        this._id = response.data.id;
-        return this.getAllAddresses();
-      } else {
-        throw Error("Failed to create addresses.");
-      }
-    } else {
-      throw Error("Please provide API addresses id.");
-    }
+};
+var parseDataFromPythPriceFeed = (feed, address) => {
+  const assetCoinNames = COIN_SET;
+  const assetCoinName = assetCoinNames.find((assetCoinName2) => {
+    return address.get(`core.coins.${assetCoinName2}.oracle.pyth.feed`) === feed.id;
+  });
+  if (assetCoinName) {
+    const price = feed.price.price * 10 ** feed.price.expo;
+    return {
+      coinName: assetCoinName,
+      price,
+      publishTime: Number(feed.price.publishTime) * 10 ** 3
+    };
+  } else {
+    throw new Error("Invalid feed id");
   }
-  /**
-   * Update the addresses through the API and synchronize it back to the
-   * instance.
-   *
-   * @description
-   * If the `network` is not specified, the mainnet is used by default.
-   * If no `addresses` from instance or parameter is provided, an addresses with
-   * all empty strings is created by default.
-   *
-   * This function only allows for one addresses to be input into a specific network
-   * at a time, and does not provide an addresses map for setting addresses
-   * across all networks at once.
-   *
-   * @param params.id - The id of the addresses to update.
-   * @param params.addresses - The addresses be setted to the tartget network.
-   * @param params.network - Specifies which network's addresses you want to set.
-   * @param params.auth - The authentication api key.
-   * @param params.memo - Add memo to the addresses created in the API.
-   * @return All addresses.
-   */
-  async update(params) {
-    const { id, addresses, network, auth, memo } = params ?? {};
-    const apiKey = auth || this._auth || void 0;
-    const targetId = id || this._id || void 0;
-    const targetNetwork = network || this._network;
-    const targetAddresses = addresses || this._currentAddresses || this._addressesMap.get(targetNetwork) || EMPTY_ADDRESSES;
-    if (targetId === void 0)
-      throw Error("Require specific addresses id to be updated.");
-    if (apiKey !== void 0) {
-      if (id !== this._id) {
-        this._addressesMap.clear();
-      }
-      this.setAddresses(targetAddresses, targetNetwork);
-      const response = await this._requestClient.put(
-        `/addresses/${targetId}`,
-        JSON.stringify({ ...Object.fromEntries(this._addressesMap), memo }),
-        {
-          headers: {
-            "Content-Type": "application/json",
-            "api-key": auth || this._auth
-          }
-        }
-      );
-      if (response.status === 200) {
-        for (const [network2, addresses2] of Object.entries(
-          response.data
-        )) {
-          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
-            if (network2 === this._network)
-              this._currentAddresses = addresses2;
-            this._addressesMap.set(network2, addresses2);
-          }
-        }
-        this._id = response.data.id;
-        return this.getAllAddresses();
-      } else {
-        throw Error("Failed to update addresses.");
-      }
-    } else {
-      throw Error("You don't have permission to access this request.");
-    }
+};
+var findClosestUnlockRound = (unlockAtInSecondTimestamp) => {
+  const unlockDate = new Date(unlockAtInSecondTimestamp * 1e3);
+  const closestTwelveAM = new Date(unlockAtInSecondTimestamp * 1e3);
+  closestTwelveAM.setUTCHours(0, 0, 0, 0);
+  if (unlockDate.getUTCHours() >= 0) {
+    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() + 1);
   }
-  /**
-   * Deletes all addresses of a specified id through the API and clear all
-   * addresses in the instance.
-   *
-   * @param id - The id of the addresses to delete.
-   * @param auth - The authentication API key.
-   */
-  async delete(id, auth) {
-    const apiKey = auth || this._auth || void 0;
-    const targetId = id || this._id || void 0;
-    if (targetId === void 0)
-      throw Error("Require specific addresses id to be deleted.");
-    if (apiKey !== void 0) {
-      const response = await this._requestClient.delete(
-        `/addresses/${targetId}`,
+  const now = (/* @__PURE__ */ new Date()).getTime();
+  if (closestTwelveAM.getTime() - now > MAX_LOCK_DURATION * 1e3) {
+    closestTwelveAM.setUTCDate(closestTwelveAM.getUTCDate() - 1);
+  }
+  return Math.floor(closestTwelveAM.getTime() / 1e3);
+};
+var partitionArray = (array, chunkSize) => {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};
+
+// src/utils/indexer.ts
+async function callMethodWithIndexerFallback(method, context, ...args) {
+  const lastArgs = args[args.length - 1];
+  if (typeof lastArgs === "object" && lastArgs.indexer) {
+    try {
+      return await method.apply(context, args);
+    } catch (e) {
+      console.warn(
+        `Indexer requests failed: ${e.message}. Retrying without indexer..`
+      );
+      return await method.apply(context, [
+        ...args.slice(0, -1),
         {
-          headers: {
-            "Content-Type": "application/json",
-            "api-key": auth || this._auth
-          }
+          ...lastArgs,
+          indexer: false
         }
-      );
-      if (response.status === 200) {
-        this._id = void 0;
-        this._currentAddresses = void 0;
-        this._addressesMap.clear();
-      } else {
-        throw Error("Failed to delete addresses.");
-      }
-    } else {
-      throw Error("You don't have permission to access this request.");
+      ]);
     }
   }
-};
-
-// src/models/scallopClient.ts
-import { normalizeSuiAddress as normalizeSuiAddress3 } from "@mysten/sui/utils";
+  return await method.apply(context, args);
+}
+function withIndexerFallback(method) {
+  return (...args) => {
+    return callMethodWithIndexerFallback(method, this, ...args);
+  };
+}
 
-// src/models/scallopUtils.ts
-import { SUI_TYPE_ARG, normalizeStructTag as normalizeStructTag6 } from "@mysten/sui/utils";
-import { SuiPriceServiceConnection } from "@pythnetwork/pyth-sui-js";
+// src/utils/core.ts
+var parseObjectAs = (object) => {
+  if (!(object && object.content && "fields" in object.content))
+    throw new Error(`Failed to parse object`);
+  const fields = object.content.fields;
+  if (typeof fields === "object" && "value" in fields) {
+    const value = fields.value;
+    if (typeof value === "object" && "fields" in value)
+      return value.fields;
+    return value;
+  } else if (typeof fields === "object") {
+    return fields;
+  }
+  return fields;
+};
 
 // src/queries/borrowIncentiveQuery.ts
-import { normalizeStructTag as normalizeStructTag3 } from "@mysten/sui/utils";
 import BigNumber2 from "bignumber.js";
 var queryBorrowIncentivePools = async (address) => {
   const queryPkgId = address.get("borrowIncentive.query");
@@ -3881,11 +3901,11 @@ var getCoinAmounts = async (query, assetCoinNames = [...SUPPORT_POOLS], ownerAdd
 var getCoinAmount = async (query, assetCoinName, ownerAddress) => {
   const owner = ownerAddress ?? query.suiKit.currentAddress();
   const coinType = query.utils.parseCoinType(assetCoinName);
-  const amount = await query.cache.queryGetCoinBalance({
+  const coinBalance = await query.cache.queryGetCoinBalance({
     owner,
     coinType
   });
-  return BigNumber3(amount).toNumber();
+  return BigNumber3(coinBalance?.totalBalance ?? "0").toNumber();
 };
 var getMarketCoinAmounts = async (query, marketCoinNames, ownerAddress) => {
   marketCoinNames = marketCoinNames || [...SUPPORT_POOLS].map(
@@ -3908,11 +3928,11 @@ var getMarketCoinAmounts = async (query, marketCoinNames, ownerAddress) => {
 var getMarketCoinAmount = async (query, marketCoinName, ownerAddress) => {
   const owner = ownerAddress ?? query.suiKit.currentAddress();
   const marketCoinType = query.utils.parseMarketCoinType(marketCoinName);
-  const amount = await query.cache.queryGetCoinBalance({
+  const coinBalance = await query.cache.queryGetCoinBalance({
     owner,
     coinType: marketCoinType
   });
-  return BigNumber3(amount).toNumber();
+  return BigNumber3(coinBalance?.totalBalance ?? "0").toNumber();
 };
 var getFlashLoanFees = async (query, assetNames) => {
   const FEE_RATE = 1e4;
@@ -4026,15 +4046,16 @@ var getLoyaltyProgramInformations = async (query, veScaKey) => {
 
 // src/queries/portfolioQuery.ts
 import BigNumber5 from "bignumber.js";
-var getLendings = async (query, poolCoinNames = [...SUPPORT_POOLS], ownerAddress, indexer = false) => {
+import { normalizeStructTag as normalizeStructTag5, SUI_TYPE_ARG } from "@scallop-io/sui-kit";
+var getLendings = async (query, poolCoinNames = [...SUPPORT_POOLS], ownerAddress, marketPools, coinPrices, indexer = false) => {
   const marketCoinNames = poolCoinNames.map(
     (poolCoinName) => query.utils.parseMarketCoinName(poolCoinName)
   );
   const stakeMarketCoinNames = marketCoinNames.filter(
     (marketCoinName) => SUPPORT_SPOOLS.includes(marketCoinName)
   );
-  const coinPrices = await query.utils.getCoinPrices();
-  const marketPools = (await query.getMarketPools(poolCoinNames, {
+  coinPrices = coinPrices ?? await query.utils.getCoinPrices();
+  marketPools = marketPools ?? (await query.getMarketPools(poolCoinNames, {
     indexer,
     coinPrices
   })).pools;
@@ -4204,9 +4225,9 @@ var getLending = async (query, poolCoinName, ownerAddress, indexer = false, mark
   };
   return lending;
 };
-var getObligationAccounts = async (query, ownerAddress, indexer = false) => {
-  const market = await query.getMarketPools(void 0, { indexer });
-  const coinPrices = await query.getAllCoinPrices({
+var getObligationAccounts = async (query, ownerAddress, market, coinPrices, indexer = false) => {
+  market = market ?? await query.getMarketPools(void 0, { indexer });
+  coinPrices = coinPrices ?? await query.getAllCoinPrices({
     marketPools: market.pools
   });
   const [coinAmounts, obligations] = await Promise.all([
@@ -4247,7 +4268,6 @@ var getObligationAccount = async (query, obligation, ownerAddress, indexer = fal
     query.queryObligation(obligation),
     query.getBorrowIncentivePools(void 0, {
       coinPrices,
-      indexer,
       marketPools: market.pools
     }),
     query.getBorrowIncentiveAccounts(obligation)
@@ -4566,6 +4586,171 @@ var getTotalValueLocked = async (query, indexer = false) => {
   };
   return tvl;
 };
+var getUserPortfolio = async (query, walletAddress, indexer = false) => {
+  const coinPrices = await query.utils.getCoinPrices();
+  const market = await query.getMarketPools(void 0, { indexer, coinPrices });
+  const [lendings, obligationAccounts, borrowIncentivePools, veScas] = await Promise.all([
+    query.getLendings(void 0, walletAddress, {
+      indexer,
+      marketPools: market.pools,
+      coinPrices
+    }),
+    query.getObligationAccounts(walletAddress, {
+      indexer,
+      market,
+      coinPrices
+    }),
+    query.getBorrowIncentivePools(void 0, {
+      marketPools: market.pools,
+      coinPrices
+    }),
+    query.getVeScas({ walletAddress, excludeEmpty: true })
+  ]);
+  const parsedLendings = Object.values(lendings).filter((t) => t.availableWithdrawCoin > 0).map((lending) => ({
+    suppliedCoin: lending.availableWithdrawCoin,
+    suppliedValue: lending.suppliedValue,
+    stakedCoin: lending.availableUnstakeCoin,
+    coinName: lending.coinName,
+    symbol: lending.symbol,
+    coinType: lending.coinType,
+    coinPrice: lending.coinPrice,
+    coinDecimals: lending.coinDecimal,
+    supplyApr: lending.supplyApr,
+    supplyApy: lending.supplyApy,
+    incentiveApr: isFinite(lending.rewardApr) ? lending.rewardApr : 0
+  }));
+  const parsedObligationAccounts = Object.values(obligationAccounts).filter(
+    (t) => !!t && t.totalBorrowedValueWithWeight > 0
+  ).map((obligationAccount) => {
+    return {
+      obligationId: obligationAccount.obligationId,
+      totalDebtsInUsd: obligationAccount.totalBorrowedValueWithWeight,
+      totalCollateralInUsd: obligationAccount.totalDepositedValue,
+      riskLevel: obligationAccount.totalRiskLevel,
+      availableCollateralInUsd: obligationAccount.totalAvailableCollateralValue,
+      totalUnhealthyCollateralInUsd: obligationAccount.totalUnhealthyCollateralValue,
+      borrowedPools: Object.values(obligationAccount.debts).filter((debt) => debt.borrowedCoin > 0).map((debt) => ({
+        coinName: debt.coinName,
+        symbol: debt.symbol,
+        coinDecimals: debt.coinDecimal,
+        coinType: debt.coinType,
+        coinPrice: debt.coinPrice,
+        borrowedCoin: debt.borrowedCoin,
+        borrowedValueInUsd: debt.borrowedValueWithWeight,
+        borrowApr: market.pools[debt.coinName]?.borrowApr,
+        borrowApy: market.pools[debt.coinName]?.borrowApy,
+        incentiveInfos: Object.values(
+          borrowIncentivePools[debt.coinName]?.points ?? {}
+        ).filter((t) => isFinite(t.rewardApr)).map((t) => ({
+          coinName: t.coinName,
+          symbol: t.symbol,
+          coinType: t.coinType,
+          incentiveApr: t.rewardApr
+        }))
+      }))
+    };
+  });
+  const pendingLendingRewards = Object.values(lendings).reduce(
+    (acc, reward) => {
+      if (reward.availableClaimCoin === 0)
+        return acc;
+      if (!acc[reward.symbol]) {
+        acc[reward.symbol] = {
+          symbol: reward.symbol,
+          coinType: normalizeStructTag5(SUI_TYPE_ARG),
+          // @TODO: for now lending reward is all in SUI
+          coinPrice: reward.coinPrice,
+          pendingRewardInCoin: reward.availableClaimCoin
+        };
+      } else {
+        acc[reward.symbol].pendingRewardInCoin += reward.availableClaimCoin;
+      }
+      return acc;
+    },
+    {}
+  );
+  const pendingBorrowIncentiveRewards = Object.values(obligationAccounts).filter((t) => !!t).reduce(
+    (acc, curr) => {
+      Object.values(curr.borrowIncentives).forEach((incentive) => {
+        incentive.rewards.forEach((reward) => {
+          if (reward.availableClaimCoin === 0)
+            return acc;
+          if (!acc[reward.coinName]) {
+            acc[reward.coinName] = {
+              symbol: reward.symbol,
+              coinType: reward.coinType,
+              coinPrice: reward.coinPrice,
+              pendingRewardInCoin: reward.availableClaimCoin
+            };
+          } else {
+            acc[reward.coinName].pendingRewardInCoin += reward.availableClaimCoin;
+          }
+        });
+      });
+      return acc;
+    },
+    {}
+  );
+  const parsedVeScas = veScas.map(
+    ({ keyId, lockedScaCoin, currentVeScaBalance, unlockAt }) => ({
+      veScaKey: keyId,
+      coinPrice: coinPrices.sca ?? 0,
+      lockedScaInCoin: lockedScaCoin,
+      lockedScaInUsd: lockedScaCoin * (coinPrices.sca ?? 0),
+      currentVeScaBalance,
+      remainingLockPeriodInDays: unlockAt - Date.now() > 0 ? (unlockAt - Date.now()) / 864e5 : 0,
+      unlockAt
+    })
+  );
+  return {
+    totalSupplyValue: parsedLendings.reduce((acc, curr) => {
+      acc += curr.suppliedValue;
+      return acc;
+    }, 0),
+    ...parsedObligationAccounts.reduce(
+      (acc, curr) => {
+        acc.totalDebtValue += curr.totalDebtsInUsd;
+        acc.totalCollateralValue += curr.totalCollateralInUsd;
+        return acc;
+      },
+      {
+        totalDebtValue: 0,
+        totalCollateralValue: 0
+      }
+    ),
+    totalLockedScaValue: parsedVeScas.reduce((acc, curr) => {
+      acc += curr.lockedScaInUsd;
+      return acc;
+    }, 0),
+    lendings: parsedLendings,
+    borrowings: parsedObligationAccounts,
+    pendingRewards: {
+      lendings: Object.entries(pendingLendingRewards).reduce(
+        (acc, [key, value]) => {
+          acc.push({
+            ...value,
+            coinName: key,
+            pendingRewardInUsd: value.coinPrice * value.pendingRewardInCoin
+          });
+          return acc;
+        },
+        []
+      ),
+      borrowIncentives: Object.entries(pendingBorrowIncentiveRewards).reduce(
+        (acc, [key, value]) => {
+          acc.push({
+            coinName: key,
+            ...value,
+            pendingRewardInUsd: value.coinPrice * value.pendingRewardInCoin
+          });
+          return acc;
+        },
+        []
+      )
+    },
+    veScas: parsedVeScas
+  };
+};
 
 // src/queries/priceQuery.ts
 import BigNumber6 from "bignumber.js";
@@ -4729,11 +4914,11 @@ var getSCoinAmount = async ({
 }, sCoinName, ownerAddress) => {
   const owner = ownerAddress || utils.suiKit.currentAddress();
   const sCoinType = utils.parseSCoinType(sCoinName);
-  const amount = await utils.cache.queryGetCoinBalance({
+  const coinBalance = await utils.cache.queryGetCoinBalance({
     owner,
     coinType: sCoinType
   });
-  return BigNumber7(amount).toNumber();
+  return BigNumber7(coinBalance?.totalBalance ?? "0").toNumber();
 };
 var isSupportStakeCoins = (value) => {
   return SUPPORT_SCOIN.includes(value);
@@ -4777,7 +4962,7 @@ var getSCoinSwapRate = async (query, fromSCoin, toSCoin, underlyingCoinPrice) =>
 };
 
 // src/queries/spoolQuery.ts
-import { normalizeStructTag as normalizeStructTag5 } from "@mysten/sui/utils";
+import { normalizeStructTag as normalizeStructTag6 } from "@mysten/sui/utils";
 var queryRequiredSpoolObjects = async (query, stakePoolCoinNames) => {
   const tasks = stakePoolCoinNames.map((t, idx) => ({
     poolCoinName: stakePoolCoinNames[idx],
@@ -5037,14 +5222,14 @@ var getStakeAccounts = async ({
         svsui: stakeAccounts.svsui,
         susdc: stakeAccounts.susdc
       };
-      const normalizedType = normalizeStructTag5(type);
+      const normalizedType = normalizeStructTag6(type);
       const stakeAccountArray = stakeMarketCoinTypeMap[reversedStakeMarketCoinTypes[normalizedType]];
       if (stakeAccountArray) {
         stakeAccountArray.push({
           id,
           type: normalizedType,
           stakePoolId,
-          stakeType: normalizeStructTag5(stakeType),
+          stakeType: normalizeStructTag6(stakeType),
           staked,
           index,
           points,
@@ -5082,13 +5267,13 @@ var getStakePool = async ({
       const lastUpdate = Number(fields.last_update);
       stakePool = {
         id,
-        type: normalizeStructTag5(type),
+        type: normalizeStructTag6(type),
         maxPoint,
         distributedPoint,
         pointPerPeriod,
         period,
         maxStake,
-        stakeType: normalizeStructTag5(stakeType),
+        stakeType: normalizeStructTag6(stakeType),
         totalStaked,
         index,
         createdAt,
@@ -5127,7 +5312,7 @@ var getStakeRewardPool = async ({
       const claimedRewards = Number(rewardPoolFields.claimed_rewards);
       stakeRewardPool = {
         id,
-        type: normalizeStructTag5(type),
+        type: normalizeStructTag6(type),
         stakePoolId,
         ratioNumerator,
         ratioDenominator,
@@ -5381,6 +5566,7 @@ var getAllAddresses = async (query) => {
         // @ts-ignore
         `spool.pools.s${coinName}.rewardPoolId`
       );
+      const sCoinType = query.address.get(`scoin.coins.s${coinName}.coinType`);
       const sCoinTreasury = query.address.get(
         // @ts-ignore
         `scoin.coins.s${coinName}.treasury`
@@ -5401,7 +5587,9 @@ var getAllAddresses = async (query) => {
         spool,
         spoolReward: rewardPool,
         sCoinTreasury,
-        coinDecimalId
+        sCoinType,
+        coinDecimalId,
+        coinType: `0x${coinType}`
       };
       await new Promise((resolve) => setTimeout(resolve, 200));
     })
@@ -5409,17 +5597,6 @@ var getAllAddresses = async (query) => {
   return results;
 };
 
-// src/models/suiKit.ts
-import { SuiKit as SuiKit2 } from "@scallop-io/sui-kit";
-var newSuiKit = (params) => {
-  return new SuiKit2({
-    ...params,
-    fullnodeUrls: Array.from(
-      /* @__PURE__ */ new Set([...params.fullnodeUrls ?? [], ...RPC_PROVIDERS])
-    )
-  });
-};
-
 // src/models/scallopUtils.ts
 var ScallopUtils = class {
   constructor(params, instance) {
@@ -5436,18 +5613,15 @@ var ScallopUtils = class {
       pythEndpoints: params.pythEndpoints ?? PYTH_ENDPOINTS["mainnet"],
       ...params
     };
-    this.suiKit = instance?.suiKit ?? instance?.address?.cache._suiKit ?? newSuiKit(params);
-    this.walletAddress = params.walletAddress ?? this.suiKit.currentAddress();
+    this.walletAddress = params.walletAddress ?? instance?.suiKit?.currentAddress() ?? "";
+    this.suiKit = instance?.suiKit ?? instance?.address?.cache.suiKit ?? newSuiKit(params);
     if (instance?.address) {
       this.address = instance.address;
       this.cache = this.address.cache;
-      this.suiKit = this.address.cache._suiKit;
     } else {
-      this.cache = new ScallopCache(
-        this.suiKit,
-        this.walletAddress,
-        DEFAULT_CACHE_OPTIONS
-      );
+      this.cache = new ScallopCache(this.params, {
+        suiKit: this.suiKit
+      });
       this.address = instance?.address ?? new ScallopAddress(
         {
           id: params?.addressesId ?? ADDRESSES_ID,
@@ -5511,7 +5685,7 @@ var ScallopUtils = class {
       throw Error(`Coin ${coinName} is not supported`);
     }
     if (coinName === "sui")
-      return normalizeStructTag6(`${coinPackageId}::sui::SUI`);
+      return normalizeStructTag7(`${coinPackageId}::sui::SUI`);
     const wormHolePackageIds = [
       this.address.get("core.coins.wusdc.id") ?? wormholeCoinIds.wusdc,
       this.address.get("core.coins.wusdt.id") ?? wormholeCoinIds.wusdt,
@@ -5615,7 +5789,7 @@ var ScallopUtils = class {
     return `${protocolObjectId}::reserve::MarketCoin<${coinType}>`;
   }
   parseCoinNameFromType(coinType) {
-    coinType = normalizeStructTag6(coinType);
+    coinType = normalizeStructTag7(coinType);
     if (sCoinTypeToName[coinType]) {
       return sCoinTypeToName[coinType];
     }
@@ -5699,8 +5873,8 @@ var ScallopUtils = class {
    * @param coinType - The coin type, default is 0x2::SUI::SUI.
    * @return The selected transaction coin arguments.
    */
-  async selectCoins(amount, coinType = SUI_TYPE_ARG, ownerAddress) {
-    ownerAddress = ownerAddress ?? this.suiKit.currentAddress();
+  async selectCoins(amount, coinType = SUI_TYPE_ARG2, ownerAddress) {
+    ownerAddress = ownerAddress ?? this.walletAddress;
     const coins = await this.suiKit.suiInteractor.selectCoins(
       ownerAddress,
       amount,
@@ -7557,11 +7731,10 @@ var newScallopTxBlock = (builder, initTxBlock) => {
 
 // src/models/scallopIndexer.ts
 import axios2 from "axios";
-import { SuiKit as SuiKit3 } from "@scallop-io/sui-kit";
 var ScallopIndexer = class {
   constructor(params, instance) {
     this.params = params;
-    this.cache = instance?.cache ?? new ScallopCache(new SuiKit3({}), void 0, DEFAULT_CACHE_OPTIONS);
+    this.cache = instance?.cache ?? new ScallopCache(this.params);
     this._requestClient = axios2.create({
       baseURL: SDK_API_BASE_URL,
       headers: {
@@ -7746,11 +7919,9 @@ var ScallopQuery = class {
       this.address = instance.utils.address;
       this.cache = this.address.cache;
     } else {
-      this.cache = new ScallopCache(
-        this.suiKit,
-        this.walletAddress,
-        DEFAULT_CACHE_OPTIONS
-      );
+      this.cache = new ScallopCache(this.params, {
+        suiKit: this.suiKit
+      });
       this.address = new ScallopAddress(
         {
           id: params?.addressesId ?? ADDRESSES_ID,
@@ -8105,7 +8276,14 @@ var ScallopQuery = class {
    * @return All lending and spool infomation.
    */
   async getLendings(poolCoinNames, ownerAddress = this.walletAddress, args) {
-    return await getLendings(this, poolCoinNames, ownerAddress, args?.indexer);
+    return await getLendings(
+      this,
+      poolCoinNames,
+      ownerAddress,
+      args?.marketPools,
+      args?.coinPrices,
+      args?.indexer
+    );
   }
   /**
    * Get user lending and spool information for specific pool.
@@ -8129,7 +8307,13 @@ var ScallopQuery = class {
    * @return All obligation accounts information.
    */
   async getObligationAccounts(ownerAddress = this.walletAddress, args) {
-    return await getObligationAccounts(this, ownerAddress, args?.indexer);
+    return await getObligationAccounts(
+      this,
+      ownerAddress,
+      args?.market,
+      args?.coinPrices,
+      args?.indexer
+    );
   }
   /**
    * Get obligation account information for specific id.
@@ -8304,12 +8488,22 @@ var ScallopQuery = class {
     return getAllCoinPrices(this, args?.marketPools, args?.coinPrices);
   }
   /**
-   * Query all address (lending pool, collateral pool, borrow dynamics, interest models) of all pool
+   * Query all address (lending pool, collateral pool, borrow dynamics, interest models, etc.) of all pool
    * @returns
    */
   async getPoolAddresses() {
     return getAllAddresses(this);
   }
+  /**
+   * Get user portfolio
+   */
+  async getUserPortfolio(args) {
+    return getUserPortfolio(
+      this,
+      args?.walletAddress ?? this.walletAddress,
+      args?.indexer ?? false
+    );
+  }
 };
 
 // src/models/scallopBuilder.ts
@@ -8326,11 +8520,9 @@ var ScallopBuilder = class {
       this.address = this.utils.address;
       this.cache = this.address.cache;
     } else {
-      this.cache = new ScallopCache(
-        this.suiKit,
-        this.walletAddress,
-        DEFAULT_CACHE_OPTIONS
-      );
+      this.cache = new ScallopCache(this.params, {
+        suiKit: this.suiKit
+      });
       this.address = new ScallopAddress(
         {
           id: params?.addressesId ?? ADDRESSES_ID,
@@ -8476,11 +8668,9 @@ var ScallopClient = class {
       this.address = this.utils.address;
       this.cache = this.address.cache;
     } else {
-      this.cache = new ScallopCache(
-        this.suiKit,
-        this.walletAddress,
-        DEFAULT_CACHE_OPTIONS
-      );
+      this.cache = new ScallopCache(this.params, {
+        suiKit: this.suiKit
+      });
       this.address = new ScallopAddress(
         {
           id: params?.addressesId ?? ADDRESSES_ID,
@@ -9154,15 +9344,18 @@ var ScallopClient = class {
 
 // src/models/scallop.ts
 var Scallop = class {
-  constructor(params, cacheOptions, tokenBucket, queryClient) {
+  constructor(params, cacheOptions, queryClient) {
     this.params = params;
     this.suiKit = newSuiKit(params);
     this.cache = new ScallopCache(
-      this.suiKit,
-      params.walletAddress,
-      cacheOptions ?? DEFAULT_CACHE_OPTIONS,
-      tokenBucket ?? new TokenBucket(DEFAULT_TOKENS_PER_INTERVAL, DEFAULT_INTERVAL_IN_MS),
-      queryClient
+      {
+        ...this.params,
+        cacheOptions
+      },
+      {
+        suiKit: this.suiKit,
+        queryClient
+      }
     );
     this.address = new ScallopAddress(
       {
@@ -9272,8 +9465,6 @@ export {
   BORROW_FEE_PROTOCOL_ID,
   COIN_GECKGO_IDS,
   DEFAULT_CACHE_OPTIONS,
-  DEFAULT_INTERVAL_IN_MS,
-  DEFAULT_TOKENS_PER_INTERVAL,
   FlashLoanFeeObjectMap,
   IS_VE_SCA_TEST,
   MAX_LOCK_DURATION,
@@ -9308,11 +9499,9 @@ export {
   ScallopQuery,
   ScallopUtils,
   TEST_ADDRESSES,
-  TokenBucket,
   UNLOCK_ROUND_DURATION,
   USE_TEST_ADDRESS,
   assetCoins,
-  callWithRateLimit,
   coinDecimals,
   coinIds,
   marketCoins,