@scallop-io/sui-scallop-sdk 1.4.1 → 1.4.2-rc.1

package/dist/index.mjs

@@ -114,18 +114,7 @@ var SUPPORT_WORMHOLE = [
   "wsol"
 ];
 var SUPPORT_SPOOLS_REWARDS = ["sui"];
-var SUPPORT_BORROW_INCENTIVE_POOLS = [
-  "sui",
-  "wusdc",
-  "wusdt",
-  "afsui",
-  "hasui",
-  "vsui",
-  "weth",
-  "sbeth",
-  "sca",
-  "usdc"
-];
+var SUPPORT_BORROW_INCENTIVE_POOLS = [...SUPPORT_POOLS];
 var SUPPORT_BORROW_INCENTIVE_REWARDS = [
   ...SUPPORT_POOLS,
   ...SUPPORT_SCOIN
@@ -341,65 +330,243 @@ var FlashLoanFeeObjectMap = {
 var POOL_ADDRESSES = {
   usdc: {
     lendingPoolAddress: "0xd3be98bf540f7603eeb550c0c0a19dbfc78822f25158b5fa84ebd9609def415f",
-    collateralPoolAddress: "0x8f0d529ba179c5b3d508213003eab813aaae31f78226099639b9a69d1aec17af"
+    collateralPoolAddress: "0x8f0d529ba179c5b3d508213003eab813aaae31f78226099639b9a69d1aec17af",
+    borrowDynamic: "0x77837ecd4f26fac9a410fff594f2c0bd3288904a15492ca77cb8a52684dbb866",
+    interestModel: "0xaae3f179d63009380cbdcb9acb12907afc9c3cb79cc3460be296a9c6d28f3ff3",
+    riskModel: "0x198b24db213bfeb8b3c80ae63dde92e32fd24984d25da8233ff777b851edd574",
+    borrowFeeKey: "0xd37c5316cfe0a5967d14264fa6b423f880518b294a1ee6581ccbb49ccc401fb8",
+    supplyLimitKey: "0x4be9ae54ac4d320f4f9c14cae78cb85c8e0e67791dd9bdba6d2db20614a28a24",
+    borrowLimitKey: "0x6b01093cba95b835181f00e3a2c31ed8dfc8d64fe3db0fb80933a09f66e1ccf1",
+    isolatedAssetKey: void 0,
+    spool: "0x0b5f5f413bd3799e4052c37311966c77f3a4545eb125d2e93e67a68478021918",
+    spoolReward: "0x85ed6ed72ea97c35dbf0cdc7ed6fbc48d8ec15de9b17c74bf4512df8a6d7f166",
+    sCoinTreasury: "0xbe6b63021f3d82e0e7e977cdd718ed7c019cf2eba374b7b546220402452f938e",
+    coinDecimalId: "0x69b7a7c3c200439c1b5f3b19d7d495d5966d5f08de66c69276152f8db3992ec6"
   },
   sbeth: {
-    lendingPoolAddress: "0x5f08c4f71d56dd3342c452cc70ffc47f2f4180146d821941b0b9c04761bb42e7",
-    collateralPoolAddress: "0xce0549a1cbe952e734f56646988e6b02bbae14667889a60e24d0d03540a6119f"
+    lendingPoolAddress: "0xaa34c938e0394e5186c7dc626ad69be96af2194b23fdc6ac1c63090e399f5ba4",
+    collateralPoolAddress: "0xce0549a1cbe952e734f56646988e6b02bbae14667889a60e24d0d03540a6119f",
+    borrowDynamic: "0x7bbe75e8b924229f2f2110838ff612ea66e670fa3766759515dee78f617b1ea3",
+    interestModel: "0x9e6cae260d05155785a1904d24e6abc98368509c5752c8a9cec15a35aabc1512",
+    riskModel: "0xcf10334cfee675ecea2d2fee37b0f7cd2835c84b8b5692a853021debe6af80ab",
+    borrowFeeKey: "0x4298c8b6afe7a42a8e3ff93773fb9769529fe6d37e085ab411acf2ba2a44a931",
+    supplyLimitKey: "0x812fe508b78d3e0817149c0b39976221ddb267b5cc9514e81679f9b9a2f3624c",
+    borrowLimitKey: "0x165c274c67eda2b0d13563124741fffd0ce7d643f4c1c4b59d7e53a83796ae25",
+    isolatedAssetKey: void 0,
+    spool: void 0,
+    spoolReward: void 0,
+    sCoinTreasury: "0xfd0f02def6358a1f266acfa1493d4707ee8387460d434fb667d63d755ff907ed",
+    coinDecimalId: "0x89b04ba87f8832d4d76e17a1c9dce72eb3e64d372cf02012b8d2de5384faeef0"
   },
   weth: {
     lendingPoolAddress: "0xc8fcdff48efc265740ae0b74aae3faccae9ec00034039a113f3339798035108c",
-    collateralPoolAddress: "0xad7ced91ed6e7f2b81805561eee27fa6f3e72fdae561077334c7248583db4dbf"
+    collateralPoolAddress: "0xad7ced91ed6e7f2b81805561eee27fa6f3e72fdae561077334c7248583db4dbf",
+    borrowDynamic: "0xd1578e1d1c9c82eb4c5bf14beece8142a67a683b2647d7276e92984119fc1445",
+    interestModel: "0xa1dc08541cd2cb7cfb4e56272292d5c6a4780e80fd210c58abffae98268b5ed9",
+    riskModel: "0x9f05a25fd33a9e8cf33962126b175d038e184f0ee1b87dc41d4cedbe6abebbe5",
+    borrowFeeKey: "0x29672ba8ab4625b8181d8ed739e5344de22a97d417748c4d1276c7379283d7a3",
+    supplyLimitKey: "0x2b957941bdc9432bbc83ab74dc194b6ebb7c927bc4c6926a5492b5503499e509",
+    borrowLimitKey: "0x51f256d87e51a7ca2b1c482923096f4b6dac6beac89d8ecf4c65b7d5764115d6",
+    isolatedAssetKey: void 0,
+    spool: "0xeec40beccb07c575bebd842eeaabb835f77cd3dab73add433477e57f583a6787",
+    spoolReward: "0x957de68a18d87817de8309b30c1ec269a4d87ae513abbeed86b5619cb9ce1077",
+    sCoinTreasury: "0x4b7f5da0e306c9d52490a0c1d4091e653d6b89778b9b4f23c877e534e4d9cd21",
+    coinDecimalId: "0x8900e4ceede3363bef086d6b50ca89d816d0e90bf6bc46efefe1f8455e08f50f"
   },
   wbtc: {
     lendingPoolAddress: "0x65cc08a5aca0a0b8d72e1993ded8d145f06dd102fd0d8f285b92934faed564ab",
-    collateralPoolAddress: "0x1aa4e5cf743cd797b4eb8bf1e614f80ae2cf556ced426cddaaf190ffcd0e59c3"
+    collateralPoolAddress: "0x1aa4e5cf743cd797b4eb8bf1e614f80ae2cf556ced426cddaaf190ffcd0e59c3",
+    borrowDynamic: "0x6f97dcf54158a5d08f359a213a41e347bc1e6316414288dc1e1b674dc008742e",
+    interestModel: "0x582b915cca0ffca9576a7cedd505d0fd7cb146e9521ccf10e7453ed93705684d",
+    riskModel: "0x1d0a242bf1682e259112239720da19d3155dd99d70b1f4b3b973eecbab858911",
+    borrowFeeKey: "0x654ab7e8ff6d9ef04da697e1f12ca21eaf72ebb495daf877e0776e65187dcb92",
+    supplyLimitKey: "0xac3b0d17df9f98aa2798c54405cf1d8d5356ef22f76f02d150cbe5195e9f3a36",
+    borrowLimitKey: "0x231e13ba6b1eb26c562f4a125778d3152f9a77e31f124bd6012e234a73012169",
+    isolatedAssetKey: void 0,
+    spool: void 0,
+    spoolReward: void 0,
+    sCoinTreasury: "0xe2883934ea42c99bc998bbe0f01dd6d27aa0e27a56455707b1b34e6a41c20baa",
+    coinDecimalId: "0x5d3c6e60eeff8a05b693b481539e7847dfe33013e7070cdcb387f5c0cac05dfd"
   },
   wusdc: {
-    lendingPoolAddress: "0x9c9077abf7a29eebce41e33addbcd6f5246a5221dd733e56ea0f00ae1b25c9e8",
-    collateralPoolAddress: "0x75aacfb7dcbf92ee0111fc1bf975b12569e4ba632e81ed7ae5ac090d40cd3acb"
+    lendingPoolAddress: "0x2f4df5e1368fbbdaa5c712d28b837b3d41c2d3872979ccededcdfdac55ff8a93",
+    collateralPoolAddress: "0x94cf69158114c5b242d2ee5d0149a335bddf3b9c9a6ba919cca58097a4814980",
+    borrowDynamic: "0x0464d117908b52fc75f7f85322a47caa078ef56f48681bcfdcb630a66f2591e6",
+    interestModel: "0xd72e2b5ba486752939d6dfb86a67b86ce9a60c83cb8fb893caac54a0f112577f",
+    riskModel: "0xb74035de8f70c1531ceb8e2e8c152d6b8db24c8a9fe7bbf6f75dbf7c6700a0a3",
+    borrowFeeKey: "0x76dcf1acbd9951fe3d1a3fe28403fec089ffe53a7c7d6c77e3ea97033a63581a",
+    supplyLimitKey: "0x7b302196907e87c5d5872f2e6f40628d110170f994e0e08bc607bded001958c3",
+    borrowLimitKey: "0x97f1502ce994db0bcb15aac1760d174def9e88e97cd2262eed54521ee2c19f81",
+    isolatedAssetKey: void 0,
+    spool: "0x4ace6648ddc64e646ba47a957c562c32c9599b3bba8f5ac1aadb2ae23a2f8ca0",
+    spoolReward: "0xf4268cc9b9413b9bfe09e8966b8de650494c9e5784bf0930759cfef4904daff8",
+    sCoinTreasury: "0x50c5cfcbcca3aaacab0984e4d7ad9a6ad034265bebb440f0d1cd688ec20b2548",
+    coinDecimalId: "0x4fbf84f3029bd0c0b77164b587963be957f853eccf834a67bb9ecba6ec80f189"
   },
   wusdt: {
     lendingPoolAddress: "0xfbc056f126dd35adc1f8fe985e2cedc8010e687e8e851e1c5b99fdf63cd1c879",
-    collateralPoolAddress: "0x2260cb5b24929dd20a1742f37a61ff3ce4fde5cdb023e2d3ce2e0ce2d90719e3"
+    collateralPoolAddress: "0x2260cb5b24929dd20a1742f37a61ff3ce4fde5cdb023e2d3ce2e0ce2d90719e3",
+    borrowDynamic: "0xb524030cc8f7cdbf13f1925a0a2b5e77cc52bab73b070f42c5e510f6083da1ba",
+    interestModel: "0x92f93c4431b4c51774d6d964da516af2def18b78f49dbbf519e58449a8ba4659",
+    riskModel: "0xdf89d66988cb506ddeff46f5dfd1d11aaece345e9a05a0c6a18a0788647de2a7",
+    borrowFeeKey: "0xda8f8b3522fc4086eae4ae7ce8844d60aa0dc3eab8ffc91fe93e922a72639b2d",
+    supplyLimitKey: "0xa9cb5ebb90ca6e808a2bd7728cca4a6fa8b565d4deeda96eb23c8322c477c24e",
+    borrowLimitKey: "0xa3278564fc613680a69c10972a0299965bf6e12e9ac171388842fc958de0f90e",
+    isolatedAssetKey: void 0,
+    spool: "0xcb328f7ffa7f9342ed85af3fdb2f22919e1a06dfb2f713c04c73543870d7548f",
+    spoolReward: "0x2c9f934d67a5baa586ceec2cc24163a2f049a6af3d5ba36b84d8ac40f25c4080",
+    sCoinTreasury: "0x1f02e2fed702b477732d4ad6044aaed04f2e8e586a169153694861a901379df0",
+    coinDecimalId: "0xfb0e3eb97dd158a5ae979dddfa24348063843c5b20eb8381dd5fa7c93699e45c"
   },
   sui: {
     lendingPoolAddress: "0x9c9077abf7a29eebce41e33addbcd6f5246a5221dd733e56ea0f00ae1b25c9e8",
-    collateralPoolAddress: "0x75aacfb7dcbf92ee0111fc1bf975b12569e4ba632e81ed7ae5ac090d40cd3acb"
+    collateralPoolAddress: "0x75aacfb7dcbf92ee0111fc1bf975b12569e4ba632e81ed7ae5ac090d40cd3acb",
+    borrowDynamic: "0xbf68e6159c99dcaf87717385f1143d2891c2d19663bd51f0bc9b6909e4bb7c27",
+    interestModel: "0x0dad9baa89b863c15a0487575de7cc428b01f1aa3998ad7a9e9752d96e83ffa9",
+    riskModel: "0xcd6675864690b5648a6e309f2f02a66914b2b2bd9c31936f4e0f7fc0f792bc86",
+    borrowFeeKey: "0xda5ede87a05c0677b17511c859b22d0a2b0229ee374d5d7a1274cb836b9fe5f8",
+    supplyLimitKey: "0x0602418e66fb7a73fa997077bd66f248ad5b090d43344a14b9f1db598ecc1d47",
+    borrowLimitKey: "0x2b33a7efdcf6a6df24f4d8a356dd52f58d75bc023c3f171d99502d4d008b53f0",
+    isolatedAssetKey: void 0,
+    spool: "0x4f0ba970d3c11db05c8f40c64a15b6a33322db3702d634ced6536960ab6f3ee4",
+    spoolReward: "0x162250ef72393a4ad3d46294c4e1bdfcb03f04c869d390e7efbfc995353a7ee9",
+    sCoinTreasury: "0x5c1678c8261ac9eec024d4d630006a9f55c80dc0b1aa38a003fcb1d425818c6b",
+    coinDecimalId: "0x9258181f5ceac8dbffb7030890243caed69a9599d2886d957a9cb7656af3bdb3"
   },
   wapt: {
     lendingPoolAddress: "0xca8c14a24e0c32b198eaf479a3317461e3cc339097ce88eaf296a15df8dcfdf5",
-    collateralPoolAddress: "0xde33f9ac5bb0ed34598da4e64b4983832716ced65f172fbf267bcfe859c4ad9c"
+    collateralPoolAddress: "0xde33f9ac5bb0ed34598da4e64b4983832716ced65f172fbf267bcfe859c4ad9c",
+    borrowDynamic: "0xadda873fb6bf68e1ba3f2dfaa51cf75d4a1bef73d9627bd36e77d2baecb1f2dc",
+    interestModel: "0xa4a29d07beecea5eb0c59745bb89d7a1380c6f206a7f1ca37046e05db6025c43",
+    riskModel: "0x7ada83b473af30aed50d187de82a0912878b53ade7ac30e11ce23953cf739d84",
+    borrowFeeKey: "0x768735df587c7e0f141dcd035fbbcbf9d2149a7b23888baed4e2baa160fa2eeb",
+    supplyLimitKey: void 0,
+    borrowLimitKey: void 0,
+    isolatedAssetKey: void 0,
+    spool: void 0,
+    spoolReward: void 0,
+    sCoinTreasury: void 0,
+    coinDecimalId: "0xc969c5251f372c0f34c32759f1d315cf1ea0ee5e4454b52aea08778eacfdd0a8"
   },
   wsol: {
     lendingPoolAddress: "0x985682c42984cdfb03f9ff7d8923344c2fe096b1ae4b82ea17721af19d22a21f",
-    collateralPoolAddress: "0xdc1cc2c371a043ae8e3c3fe2d013c35f1346960b7dbb4c072982c5b794ed144f"
+    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"
   },
   cetus: {
     lendingPoolAddress: "0xc09858f60e74a1b671635bec4e8a2c84a0ff313eb87f525fba3258e88c6b6282",
-    collateralPoolAddress: "0xe363967e29b7b9c1245d6d46d63e719de8f90b37e3358c545b55d945ea0b676a"
+    collateralPoolAddress: "0xe363967e29b7b9c1245d6d46d63e719de8f90b37e3358c545b55d945ea0b676a",
+    borrowDynamic: "0xcc725fd5d71990cdccc7e16c88a2abde6dbcd0bf6e805ccc1c0cb83a106bbf4e",
+    interestModel: "0x2f1258aab89d04d11834121599ab1317dfecb582b4246f106df399911125845a",
+    riskModel: "0x03fed312dbba624dff5edaf4736891a1c7d864445fd268e7572b42ec7381132e",
+    borrowFeeKey: "0xdf5fb0cc4ebbf5eebfae23dfa5b266f6a58c18a894a13054ae60c0eb6e79c382",
+    supplyLimitKey: "0xa5ea3d4bf663d7bc667e82b40a98923590ff3851b9ea8e7afbc26c588c7007d3",
+    borrowLimitKey: "0xf44218a5f0feb128e6fbe74b91d1e7e9ef859bd23a576ff0de151829e015a157",
+    isolatedAssetKey: void 0,
+    spool: "0xac1bb13bf4472a637c18c2415fb0e3c1227ea2bcf35242e50563c98215bd298e",
+    spoolReward: "0x6835c1224126a45086fc6406adc249e3f30df18d779ca4f4e570e38716a17f3f",
+    sCoinTreasury: "0xa283c63488773c916cb3d6c64109536160d5eb496caddc721eb39aad2977d735",
+    coinDecimalId: "0x4c0dce55eff2db5419bbd2d239d1aa22b4a400c01bbb648b058a9883989025da"
   },
   afsui: {
     lendingPoolAddress: "0x9b942a24ce390b7f5016d34a0217057bf9487b92aa6d7cc9894271dbbe62471a",
-    collateralPoolAddress: "0xe5e56f5c0e3072760b21f9d49a5cc793f37d736c412a9065c16e1265c74e6341"
+    collateralPoolAddress: "0xe5e56f5c0e3072760b21f9d49a5cc793f37d736c412a9065c16e1265c74e6341",
+    borrowDynamic: "0x1c76d4df9506154a117bbac0f5e005d8a9c0d9ca60e3fe0c9d080006f6f54e81",
+    interestModel: "0xb155c536b37c9601baaa734ad1dd0ef335b2b597aceb8d3ecee41a43f94dcd70",
+    riskModel: "0x75371b1d04b5bebc0738af548ba64ea658e74f78228ec8014336d8eebb992312",
+    borrowFeeKey: "0xabc6422db2d4ee01635ddaeaa44ba68370eebd785d2c4632515f841ae9bc47d9",
+    supplyLimitKey: "0x61a2054eb37f543c0d774da57f2c9542aad8d79a197f748ac08ef5df6cc47028",
+    borrowLimitKey: "0x4459498a043872cd107ea917493fee0baf2d37a273c7538e1d6581cc61b92af8",
+    isolatedAssetKey: void 0,
+    spool: "0xeedf438abcaa6ce4d9625ffca110920592d5867e4c5637d84ad9f466c4feb800",
+    spoolReward: "0x89255a2f86ed7fbfef35ab8b7be48cc7667015975be2685dd9a55a9a64baf76e",
+    sCoinTreasury: "0x55f4dfe9e40bc4cc11c70fcb1f3daefa2bdc330567c58d4f0792fbd9f9175a62",
+    coinDecimalId: "0x2f9217f533e51334873a39b8026a4aa6919497b47f49d0986a4f1aec66f8a34d"
   },
   hasui: {
     lendingPoolAddress: "0x7ebc607f6bdeb659fb6506cb91c5cc1d47bb365cfd5d2e637ea765346ec84ed4",
-    collateralPoolAddress: "0xad9ed40d6486e4c26cec7370dffce8dc4821eb79178250b5938a34ccafd61e6d"
+    collateralPoolAddress: "0xad9ed40d6486e4c26cec7370dffce8dc4821eb79178250b5938a34ccafd61e6d",
+    borrowDynamic: "0x13ec1220b41c6e0f11dd6113199a2aff8e4cf2223047b5bd06d7a3ed5d23e1d2",
+    interestModel: "0x987c58cbe48096618f4d9d83e0bde2ff638ce4753aba40dab7c302ac3e4b4519",
+    riskModel: "0xe42d8497d423eca0d8df89850c2d77d3644e7f54a2d28f59c315903ea5ec8dec",
+    borrowFeeKey: "0xef885c382d461c4fb14d1f3b3758c380c78a1a4b2a3d2fafe6e8649a60fdd7ab",
+    supplyLimitKey: "0xc7385b1703693cbbc9c97227fe3fd5c91d7afda00e0da69d942c3260d78e45e0",
+    borrowLimitKey: "0x65333e606eead786a999c8267bc9886b0fdbc298a8a8635a48a9c9b8838d9395",
+    isolatedAssetKey: void 0,
+    spool: "0xa6148bc1b623e936d39a952ceb5bea79e8b37228a8f595067bf1852efd3c34aa",
+    spoolReward: "0x6f3563644d3e2ef13176dbf9d865bd93479df60ccbe07b7e66db57f6309f5a66",
+    sCoinTreasury: "0x404ccc1404d74a90eb6f9c9d4b6cda6d417fb03189f80d9070a35e5dab1df0f5",
+    coinDecimalId: "0x2c5f33af93f6511df699aaaa5822d823aac6ed99d4a0de2a4a50b3afa0172e24"
   },
   vsui: {
     lendingPoolAddress: "0xda9257c0731d8822e8a438ebced13415850d705b779c79958dcf2aeb21fcb43d",
-    collateralPoolAddress: "0x4435e8b8ec2a04094d863aa52deb6ab6f8f47ed8778f4d9f1b27afc4a6e85f1e"
+    collateralPoolAddress: "0x4435e8b8ec2a04094d863aa52deb6ab6f8f47ed8778f4d9f1b27afc4a6e85f1e",
+    borrowDynamic: "0x8eae703505246f975e83f5af24780e5f1b89ef403d5a80ea15534624d6f1a503",
+    interestModel: "0xaf6a52b5eaaa5af4d9e49d83de0d504c295ae21f3a37560c3f48e0e15a1d4625",
+    riskModel: "0x1e862f27a6bd47c3041159a5cf392f549485c6605ed9aa937f16ecc951e82e65",
+    borrowFeeKey: "0x5230de0f41a5e4c05b3d1187a90a9eeab491cec97b08b71512d9785e8af36aa6",
+    supplyLimitKey: "0x1d40e34d1f365ec431fff020bd75c16b14b340b3ed6c139803cc15c2384621b2",
+    borrowLimitKey: "0x4eb206b4417642cfc1b02f80bb5f5e366af2af2f9fb4ea4f4e898ae82367f8a0",
+    isolatedAssetKey: void 0,
+    spool: "0x69ce8e537e750a95381e6040794afa5ab1758353a1a2e1de7760391b01f91670",
+    spoolReward: "0xbca914adce058ad0902c7f3cfcd698392a475f00dcfdc3f76001d0370b98777a",
+    sCoinTreasury: "0xc06688ee1af25abc286ffb1d18ce273d1d5907cd1064c25f4e8ca61ea989c1d1",
+    coinDecimalId: "0xabd84a23467b33854ab25cf862006fd97479f8f6f53e50fe732c43a274d939bd"
   },
   sca: {
     lendingPoolAddress: "0x6fc7d4211fc7018b6c75e7b908b88f2e0536443239804a3d32af547637bd28d7",
-    collateralPoolAddress: "0xff677a5d9e9dc8f08f0a8681ebfc7481d1c7d57bc441f2881974adcdd7b13c31"
+    collateralPoolAddress: "0xff677a5d9e9dc8f08f0a8681ebfc7481d1c7d57bc441f2881974adcdd7b13c31",
+    borrowDynamic: "0x4e24f52edd739dab59ca4c6353ca430b7ce57e7f333abd0957958570a7cd09ca",
+    interestModel: "0xbdcd48cf5b1a814911dc2d5c72d393a980c87820199fe5d799289ce94f4c47df",
+    riskModel: "0xc437c24b67b8e2676907700fa395af337ad6463d2c0b4f4fa2e9276414026089",
+    borrowFeeKey: "0xee55ba0f9800a62d9e7aef667f87e658258f41814d2c9fa02e25590671b4e5ad",
+    supplyLimitKey: "0x8dd938856b972a10ea27ecab2af7ed78e48fc5f6ccedaf2b2119959f747dc2e3",
+    borrowLimitKey: "0x04c7de61c5b42972f9bf6a8b1848e5fea2d037ee8deba81741ecd4a70aa80d30",
+    isolatedAssetKey: void 0,
+    spool: void 0,
+    spoolReward: void 0,
+    sCoinTreasury: "0xe04bfc95e00252bd654ee13c08edef9ac5e4b6ae4074e8390db39e9a0109c529",
+    coinDecimalId: "0x5d26a1e9a55c88147ac870bfa31b729d7f49f8804b8b3adfdf3582d301cca844"
   },
   fud: {
-    lendingPoolAddress: "0x14367ddca30e2860cb89ed4eaca20c7ece260c5d59dd9990d2c85a8321326acb"
+    lendingPoolAddress: "0xefed2cbe76b344792ac724523c8b2236740d1cea2100d46a0ed0dc760c7f4231",
+    collateralPoolAddress: void 0,
+    borrowDynamic: "0x14367ddca30e2860cb89ed4eaca20c7ece260c5d59dd9990d2c85a8321326acb",
+    interestModel: "0x2600ac100ef154eb2329ffd3aad47aca308ff9f9348de3e8e94aaeb906ec2303",
+    riskModel: void 0,
+    borrowFeeKey: "0xa87e8b26e07ff35ac9fb57adcc779be2883080fc7d12de2d9e7e16d8d8d5e529",
+    supplyLimitKey: "0xf98419aecc37a3c5de716f8ec590f8991a5be34da72ce1a2da09531ff45adf7d",
+    borrowLimitKey: "0x3d928a001c453c50004baa54e14b0a0e1b0907d9c613dfd76064fd7ed4e8beb8",
+    isolatedAssetKey: "0xfcb533e9e4e31f9c9f32d6cbf7fbb3425f1d60474e229a363a2dc7f835d587e2",
+    spool: void 0,
+    spoolReward: void 0,
+    sCoinTreasury: "0xf25212f11d182decff7a86165699a73e3d5787aced203ca539f43cfbc10db867",
+    coinDecimalId: "0x01087411ef48aaac1eb6e24803213e3a60a03b147dac930e5e341f17a85e524e"
   },
   deep: {
-    lendingPoolAddress: "0xf4a67ffb43da1e1c61c049f188f19463ea8dbbf2d5ef4722d6df854ff1b1cc03"
+    lendingPoolAddress: "0xf4a67ffb43da1e1c61c049f188f19463ea8dbbf2d5ef4722d6df854ff1b1cc03",
+    collateralPoolAddress: void 0,
+    borrowDynamic: "0x95e00d7466f97a100e70f08bd37788dc49335796f6f49fab996d40dd0681c6d3",
+    interestModel: "0x4143c298506a332d92ea8a995e6f3991ee3215f58f6fc6441752835d275b9a69",
+    riskModel: void 0,
+    borrowFeeKey: "0xb14ee43f4ad2a2c40bac8c4406a401690e93c982e289cf3802fedf74a159cab2",
+    supplyLimitKey: "0x599528fdfdc253e90dfd0acf4f4a166b391e2aac1ca6528abbff63225b548fee",
+    borrowLimitKey: "0xf4217e8ef9d9c32e8992092e910a77535a8124c19b8a762a673f227f5f765a4e",
+    isolatedAssetKey: "0x208d3a24ba369dcfc8f0387333d1512b98199eb150d2f2a69359ff708cf761e3",
+    spool: void 0,
+    spoolReward: void 0,
+    sCoinTreasury: "0xc63838fabe37b25ad897392d89876d920f5e0c6a406bf3abcb84753d2829bc88",
+    coinDecimalId: "0x6e60b051a08fa836f5a7acd7c464c8d9825bc29c44657fe170fe9b8e1e4770c0"
   }
 };
 
@@ -450,7 +617,11 @@ var queryKeys = {
         typeArgs: !typeArgs ? void 0 : JSON.stringify(typeArgs)
       }
     ],
-    getObject: (objectId, walletAddress, options) => ["rpc", "getObject", { walletAddress, options, objectId }],
+    getObject: (objectId, options) => [
+      "rpc",
+      "getObject",
+      { options, objectId }
+    ],
     getObjects: (objectIds, walletAddress, options) => [
       "rpc",
       "getObjects",
@@ -500,7 +671,10 @@ var queryKeys = {
       "rpc",
       "getAllCoinBalances",
       { owner }
-    ]
+    ],
+    getNormalizedMoveFunction: (target) => {
+      return ["rpc", "getNormalizedMoveCall", target];
+    }
   },
   oracle: {
     getPythLatestPriceFeeds: () => ["oracle", "getPythPriceIds"]
@@ -724,6 +898,32 @@ var TEST_ADDRESSES = {
             feedObject: "0x9193fd47f9a0ab99b6e365a464c8a9ae30e6150fc37ed2a89c1586631f6fc4ab"
           }
         }
+      },
+      deep: {
+        id: "0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270",
+        metaData: "0x6e60b051a08fa836f5a7acd7c464c8d9825bc29c44657fe170fe9b8e1e4770c0",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "29bdd5248234e33bd93d3b81100b5fa32eaa5997843847e2c2cb16d7c6d9f7ff",
+            feedObject: "0x8c7f3a322b94cc69db2a2ac575cbd94bf5766113324c3a3eceac91e3e88a51ed"
+          }
+        }
+      },
+      fud: {
+        id: "0x76cb819b01abed502bee8a702b4c2d547532c12f25001c9dea795a5e631c26f1",
+        metaData: "0x01087411ef48aaac1eb6e24803213e3a60a03b147dac930e5e341f17a85e524e",
+        treasury: "",
+        oracle: {
+          supra: "",
+          switchboard: "",
+          pyth: {
+            feed: "6a4090703da959247727f2b490eb21aea95c8684ecfac675f432008830890c75",
+            feedObject: "0x4531c3ed0d22f21f5fce882905372006c9aafa30f01db03b789e95a6c50de7b2"
+          }
+        }
       }
     },
     oracles: {
@@ -943,14 +1143,22 @@ var TEST_ADDRESSES = {
       ssbeth: {
         coinType: "0xb14f82d8506d139eacef109688d1b71e7236bcce9b2c0ad526abcd6aa5be7de0::scallop_sb_eth::SCALLOP_SB_ETH",
         treasury: "0xfd0f02def6358a1f266acfa1493d4707ee8387460d434fb667d63d755ff907ed"
+      },
+      sdeep: {
+        coinType: "0xeb7a05a3224837c5e5503575aed0be73c091d1ce5e43aa3c3e716e0ae614608f::scallop_deep::SCALLOP_DEEP",
+        treasury: "0xc63838fabe37b25ad897392d89876d920f5e0c6a406bf3abcb84753d2829bc88"
+      },
+      sfud: {
+        coinType: "0xe56d5167f427cbe597da9e8150ef5c337839aaf46891d62468dcf80bdd8e10d1::scallop_fud::SCALLOP_FUD",
+        treasury: "0xf25212f11d182decff7a86165699a73e3d5787aced203ca539f43cfbc10db867"
       }
     }
   }
 };
 
 // src/constants/tokenBucket.ts
-var DEFAULT_TOKENS_PER_INTERVAL = 50;
-var DEFAULT_INTERVAL_IN_MS = 100;
+var DEFAULT_TOKENS_PER_INTERVAL = 10;
+var DEFAULT_INTERVAL_IN_MS = 250;
 
 // src/constants/vesca.ts
 var UNLOCK_ROUND_DURATION = 60 * 60 * 24;
@@ -966,7 +1174,8 @@ import { SuiKit } from "@scallop-io/sui-kit";
 import { QueryClient } from "@tanstack/query-core";
 import {
   SuiTxBlock,
-  normalizeStructTag as normalizeStructTag2
+  normalizeStructTag as normalizeStructTag2,
+  parseStructTag as parseStructTag2
 } from "@scallop-io/sui-kit";
 
 // src/utils/builder.ts
@@ -1097,7 +1306,10 @@ var parseOriginMarketPoolData = (originMarketPoolData) => {
     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)
+    minBorrowAmount: Number(originMarketPoolData.minBorrowAmount),
+    isIsolated: originMarketPoolData.isIsolated,
+    supplyLimit: Number(originMarketPoolData.supplyLimit),
+    borrowLimit: Number(originMarketPoolData.borrowLimit)
   };
 };
 var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
@@ -1149,6 +1361,7 @@ var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
     borrowApyOnHighKink: utils.parseAprToApy(borrowAprOnHighKink),
     borrowAprOnMidKink,
     borrowApyOnMidKink: utils.parseAprToApy(borrowAprOnMidKink),
+    coinDecimal,
     maxBorrowApr,
     maxBorrowApy: utils.parseAprToApy(maxBorrowApr),
     borrowApr: Math.min(borrowApr, maxBorrowApr),
@@ -1167,17 +1380,21 @@ var calculateMarketPoolData = (utils, parsedMarketPoolData) => {
     utilizationRate: utilizationRate.toNumber(),
     supplyApr: supplyApr.toNumber(),
     supplyApy: utils.parseAprToApy(supplyApr.toNumber()),
-    conversionRate: conversionRate.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,
-    liquidationPanelty: Number(originMarketCollateralData.liquidationPanelty.value) / divisor,
+    liquidationPenalty: Number(originMarketCollateralData.liquidationPenalty.value) / divisor,
     liquidationReserveFactor: Number(originMarketCollateralData.liquidationReserveFactor.value) / divisor,
     maxCollateralAmount: Number(originMarketCollateralData.maxCollateralAmount),
     totalCollateralAmount: Number(
@@ -1197,6 +1414,8 @@ var calculateMarketCollateralData = (utils, parsedMarketCollateralData) => {
     parsedMarketCollateralData.totalCollateralAmount
   ).shiftedBy(-1 * coinDecimal);
   return {
+    coinDecimal,
+    isIsolated: parsedMarketCollateralData.isIsolated,
     maxDepositAmount: parsedMarketCollateralData.maxCollateralAmount,
     maxDepositCoin: maxCollateralCoin.toNumber(),
     depositAmount: parsedMarketCollateralData.totalCollateralAmount,
@@ -1329,7 +1548,7 @@ var parseOriginBorrowIncentivesPoolPointData = (originBorrowIncentivePoolPointDa
     createdAt: Number(originBorrowIncentivePoolPointData.created_at)
   };
 };
-var parseOriginBorrowIncentivePoolData = (originBorrowIncentivePoolData) => {
+var parseOriginBorrowIncentivePoolData = (utils, originBorrowIncentivePoolData) => {
   return {
     poolType: normalizeStructTag(originBorrowIncentivePoolData.pool_type.name),
     minStakes: Number(originBorrowIncentivePoolData.min_stakes),
@@ -1338,9 +1557,9 @@ var parseOriginBorrowIncentivePoolData = (originBorrowIncentivePoolData) => {
     poolPoints: originBorrowIncentivePoolData.points.reduce(
       (acc, point) => {
         const parsed = parseOriginBorrowIncentivesPoolPointData(point);
-        const name = parseStructTag(
-          parsed.pointType
-        ).name.toLowerCase();
+        const name = utils.parseSCoinTypeNameToMarketCoinName(
+          parseStructTag(parsed.pointType).name.toLowerCase()
+        );
         acc[name] = parsed;
         return acc;
       },
@@ -1527,6 +1746,13 @@ var findClosestUnlockRound = (unlockAtInSecondTimestamp) => {
   }
   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 {
@@ -1539,10 +1765,10 @@ var TokenBucket = class {
   refill() {
     const now = Date.now();
     const elapsed = now - this.lastRefill;
-    if (elapsed > this.interval) {
+    if (elapsed >= this.interval) {
       const tokensToAdd = Math.floor(elapsed / this.interval) * this.tokensPerInterval;
       this.tokens = Math.min(this.tokens + tokensToAdd, this.tokensPerInterval);
-      this.lastRefill = now;
+      this.lastRefill += Math.floor(elapsed / this.interval) * this.interval;
     }
   }
   removeTokens(count) {
@@ -1554,27 +1780,12 @@ var TokenBucket = class {
     return false;
   }
 };
-var callWithRateLimit = async (tokenBucket, fn, retryDelayInMs = DEFAULT_INTERVAL_IN_MS, maxRetries = 15, backoffFactor = 2) => {
+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)) {
-      try {
-        const result = await fn();
-        if (result && result.status === 429) {
-          throw new Error("Unexpected status code: 429");
-        }
-        return result;
-      } catch (error) {
-        if (error.message === "Unexpected status code: 429" && retries < maxRetries) {
-          retries++;
-          const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          return tryRequest();
-        } else {
-          console.error("An error occurred:", error.message);
-          return null;
-        }
-      }
+      const result = await fn();
+      return result;
     } else if (retries < maxRetries) {
       retries++;
       const delay = retryDelayInMs * Math.pow(backoffFactor, retries);
@@ -1613,6 +1824,22 @@ function withIndexerFallback(method) {
   };
 }
 
+// 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) {
@@ -1647,6 +1874,13 @@ var ScallopCache = class {
       })
     );
   }
+  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
@@ -1659,18 +1893,64 @@ var ScallopCache = class {
     typeArgs
   }) {
     const txBlock = new SuiTxBlock();
-    txBlock.moveCall(queryTarget, args, typeArgs);
+    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,
-          () => this.suiKit.inspectTxn(txBlock)
+          async () => await this.suiKit.inspectTxn(txBlock)
         );
       }
     });
     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
+          })
+        );
+      }
+    });
+  }
   /**
    * @description Provides cache for getObject of the SuiKit.
    * @param objectId
@@ -1678,12 +1958,19 @@ var ScallopCache = class {
    * @returns Promise<SuiObjectResponse>
    */
   async queryGetObject(objectId, options) {
+    options = {
+      ...options,
+      showOwner: true,
+      showContent: true
+    };
     return this.queryClient.fetchQuery({
-      queryKey: queryKeys.rpc.getObject(objectId, this.walletAddress, options),
+      retry: this.retryFn,
+      retryDelay: 1e3,
+      queryKey: queryKeys.rpc.getObject(objectId, options),
       queryFn: async () => {
         return await callWithRateLimit(
           this.tokenBucket,
-          () => this.client.getObject({
+          async () => await this.client.getObject({
             id: objectId,
             options
           })
@@ -1702,16 +1989,36 @@ var ScallopCache = class {
     if (objectIds.length === 0)
       return [];
     return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
       queryKey: queryKeys.rpc.getObjects(
         objectIds,
         this.walletAddress,
         options
       ),
       queryFn: async () => {
-        return await callWithRateLimit(
+        const results = await callWithRateLimit(
           this.tokenBucket,
-          () => this.suiKit.getObjects(objectIds, options)
+          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;
       }
     });
   }
@@ -1722,44 +2029,94 @@ var ScallopCache = class {
    */
   async queryGetOwnedObjects(input) {
     return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
       queryKey: queryKeys.rpc.getOwnedObjects(input),
       queryFn: async () => {
-        return await callWithRateLimit(
+        const results = await callWithRateLimit(
           this.tokenBucket,
-          () => this.client.getOwnedObjects(input)
+          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;
       }
     });
   }
   async queryGetDynamicFields(input) {
     return this.queryClient.fetchQuery({
+      retry: this.retryFn,
+      retryDelay: 1e3,
       queryKey: queryKeys.rpc.getDynamicFields(input),
       queryFn: async () => {
         return await callWithRateLimit(
           this.tokenBucket,
-          () => this.client.getDynamicFields(input)
+          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 () => {
-        return await callWithRateLimit(
+        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;
       }
     });
   }
   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,
-          () => this.client.getAllBalances({ owner })
+          async () => await this.client.getAllBalances({ owner })
         );
         if (!allBalances)
           return {};
@@ -2472,7 +2829,7 @@ var getBorrowIncentivePools = async (query, borrowIncentiveCoinNames = [
   ...SUPPORT_BORROW_INCENTIVE_POOLS
 ], indexer = false, marketPools, coinPrices) => {
   const borrowIncentivePools = {};
-  marketPools = marketPools ?? await query.getMarketPools(void 0, { coinPrices, indexer });
+  marketPools = marketPools ?? (await query.getMarketPools(void 0, { coinPrices, indexer })).pools;
   coinPrices = coinPrices ?? await query.getAllCoinPrices({ marketPools });
   if (indexer) {
     const borrowIncentivePoolsIndexer = await query.indexer.getBorrowIncentivePools();
@@ -2497,7 +2854,10 @@ var getBorrowIncentivePools = async (query, borrowIncentiveCoinNames = [
   );
   for (const pool of borrowIncentivePoolsQueryData?.incentive_pools ?? []) {
     const borrowIncentivePoolPoints = {};
-    const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(pool);
+    const parsedBorrowIncentivePoolData = parseOriginBorrowIncentivePoolData(
+      query.utils,
+      pool
+    );
     const poolCoinType = normalizeStructTag3(pool.pool_type.name);
     const poolCoinName = query.utils.parseCoinNameFromType(
       poolCoinType
@@ -2511,12 +2871,9 @@ var getBorrowIncentivePools = async (query, borrowIncentiveCoinNames = [
       parsedBorrowIncentivePoolData.poolPoints
     )) {
       const rewardCoinType = poolPoint.pointType;
-      let rewardCoinName = query.utils.parseCoinNameFromType(
+      const rewardCoinName = query.utils.parseCoinNameFromType(
         rewardCoinType
       );
-      if (sCoinRawNameToName[rewardCoinName]) {
-        rewardCoinName = sCoinRawNameToName[rewardCoinName];
-      }
       const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
       const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
       const symbol = query.utils.parseSymbol(rewardCoinName);
@@ -2705,9 +3062,14 @@ var isolatedAssetZod = zod2.object({
   })
 });
 var isolatedAssetKeyType = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::IsolatedAssetKey`;
-var getIsolatedAssets = async (address) => {
+var getIsolatedAssets = async (query) => {
+  if (SUPPORT_POOLS.every((t) => !!POOL_ADDRESSES[t])) {
+    return SUPPORT_POOLS.filter(
+      (t) => !!POOL_ADDRESSES[t]?.isolatedAssetKey && !!POOL_ADDRESSES[t]?.coinType
+    ).map((t) => POOL_ADDRESSES[t]?.coinType);
+  }
   try {
-    const marketObject = address.get("core.market");
+    const marketObject = query.address.get("core.market");
     const isolatedAssets = [];
     if (!marketObject)
       return isolatedAssets;
@@ -2717,7 +3079,7 @@ var getIsolatedAssets = async (address) => {
       return dynamicField.name.type === isolatedAssetKeyType;
     };
     do {
-      const response = await address.cache.queryGetDynamicFields({
+      const response = await query.cache.queryGetDynamicFields({
         parentId: marketObject,
         cursor: nextCursor,
         limit: 10
@@ -2740,32 +3102,30 @@ var getIsolatedAssets = async (address) => {
   }
 };
 var isIsolatedAsset = async (utils, coinName) => {
-  try {
-    const marketObject = utils.address.get("core.market");
-    const cachedData = utils.address.cache.queryClient.getQueryData([
-      "getDynamicFields",
-      marketObject
-    ]);
-    if (cachedData) {
-      const coinType2 = utils.parseCoinType(coinName);
-      return cachedData.includes(coinType2);
+  if (POOL_ADDRESSES[coinName]) {
+    return !!POOL_ADDRESSES[coinName].isolatedAssetKey;
+  }
+  const marketObject = utils.address.get("core.market");
+  const cachedData = utils.address.cache.queryClient.getQueryData([
+    "getDynamicFields",
+    marketObject
+  ]);
+  if (cachedData) {
+    const coinType2 = utils.parseCoinType(coinName);
+    return cachedData.includes(coinType2);
+  }
+  const coinType = utils.parseCoinType(coinName).slice(2);
+  const object = await utils.cache.queryGetDynamicFieldObject({
+    parentId: marketObject,
+    name: {
+      type: isolatedAssetKeyType,
+      value: coinType
     }
-    const coinType = utils.parseCoinType(coinName).slice(2);
-    const object = await utils.cache.queryGetDynamicFieldObject({
-      parentId: marketObject,
-      name: {
-        type: isolatedAssetKeyType,
-        value: coinType
-      }
-    });
-    const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
-    if (!parsedData.success)
-      return false;
-    return parsedData.data.fields.value;
-  } catch (e) {
-    console.error(e);
+  });
+  const parsedData = isolatedAssetZod.safeParse(object?.data?.content);
+  if (!parsedData.success)
     return false;
-  }
+  return parsedData.data.fields.value;
 };
 
 // src/queries/borrowLimitQuery.ts
@@ -2808,6 +3168,17 @@ var getBorrowLimit = async (utils, poolName) => {
   }
 };
 
+// src/queries/objectsQuery.ts
+var queryMultipleObjects = async (cache, objectIds, options, partitionSize = 50) => {
+  const objectIdsPartition = partitionArray(objectIds, partitionSize);
+  const objects = [];
+  for (const objectIds2 of objectIdsPartition) {
+    const result = await cache.queryGetObjects(objectIds2, options);
+    objects.push(...result);
+  }
+  return objects;
+};
+
 // src/queries/coreQuery.ts
 var queryMarket = async (query, indexer = false, coinPrices) => {
   coinPrices = coinPrices ?? await query.utils.getCoinPrices() ?? {};
@@ -2864,19 +3235,15 @@ var queryMarket = async (query, indexer = false, coinPrices) => {
       borrowRateOnMidKink: pool.borrowRateOnMidKink,
       highKink: pool.highKink,
       midKink: pool.midKink,
-      minBorrowAmount: pool.minBorrowAmount
+      minBorrowAmount: pool.minBorrowAmount,
+      isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
+      supplyLimit: await getSupplyLimit(query.utils, poolCoinName) ?? "0",
+      borrowLimit: await getBorrowLimit(query.utils, poolCoinName) ?? "0"
     });
     const calculatedMarketPoolData = calculateMarketPoolData(
       query.utils,
       parsedMarketPoolData
     );
-    const coinDecimal = query.utils.getCoinDecimal(poolCoinName);
-    const maxSupplyCoin = BigNumber3(
-      await getSupplyLimit(query.utils, poolCoinName) ?? "0"
-    ).shiftedBy(-coinDecimal).toNumber();
-    const maxBorrowCoin = BigNumber3(
-      await getBorrowLimit(query.utils, poolCoinName) ?? "0"
-    ).shiftedBy(-coinDecimal).toNumber();
     pools[poolCoinName] = {
       coinName: poolCoinName,
       symbol: query.utils.parseSymbol(poolCoinName),
@@ -2886,7 +3253,6 @@ var queryMarket = async (query, indexer = false, coinPrices) => {
         query.utils.parseMarketCoinName(poolCoinName)
       ),
       coinWrappedType: query.utils.getCoinWrappedType(poolCoinName),
-      coinDecimal,
       coinPrice,
       highKink: parsedMarketPoolData.highKink,
       midKink: parsedMarketPoolData.midKink,
@@ -2895,10 +3261,6 @@ var queryMarket = async (query, indexer = false, coinPrices) => {
       borrowFee: parsedMarketPoolData.borrowFee,
       marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
       minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
-      isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
-      // isIsolated: false,
-      maxSupplyCoin,
-      maxBorrowCoin,
       ...calculatedMarketPoolData
     };
   }
@@ -2914,10 +3276,11 @@ var queryMarket = async (query, indexer = false, coinPrices) => {
       collateralFactor: collateral.collateralFactor,
       liquidationFactor: collateral.liquidationFactor,
       liquidationDiscount: collateral.liquidationDiscount,
-      liquidationPanelty: collateral.liquidationPanelty,
+      liquidationPenalty: collateral.liquidationPanelty,
       liquidationReserveFactor: collateral.liquidationReserveFactor,
       maxCollateralAmount: collateral.maxCollateralAmount,
-      totalCollateralAmount: collateral.totalCollateralAmount
+      totalCollateralAmount: collateral.totalCollateralAmount,
+      isIsolated: await isIsolatedAsset(query.utils, collateralCoinName)
     });
     const calculatedMarketCollateralData = calculateMarketCollateralData(
       query.utils,
@@ -2929,14 +3292,12 @@ var queryMarket = async (query, indexer = false, coinPrices) => {
       coinType,
       marketCoinType: query.utils.parseMarketCoinType(collateralCoinName),
       coinWrappedType: query.utils.getCoinWrappedType(collateralCoinName),
-      coinDecimal: query.utils.getCoinDecimal(collateralCoinName),
       coinPrice,
       collateralFactor: parsedMarketCollateralData.collateralFactor,
       liquidationFactor: parsedMarketCollateralData.liquidationFactor,
       liquidationDiscount: parsedMarketCollateralData.liquidationDiscount,
-      liquidationPanelty: parsedMarketCollateralData.liquidationPanelty,
+      liquidationPenalty: parsedMarketCollateralData.liquidationPenalty,
       liquidationReserveFactor: parsedMarketCollateralData.liquidationReserveFactor,
-      isIsolated: await isIsolatedAsset(query.utils, collateralCoinName),
       ...calculatedMarketCollateralData
     };
   }
@@ -2946,44 +3307,216 @@ var queryMarket = async (query, indexer = false, coinPrices) => {
     // data: marketData,
   };
 };
-var getMarketPools = async (query, poolCoinNames = [...SUPPORT_POOLS], indexer = false, coinPrices) => {
-  const marketId = query.address.get("core.market");
-  const marketObjectResponse = await query.cache.queryGetObject(marketId, {
-    showContent: true
-  });
+var queryRequiredMarketObjects = async (query, poolCoinNames) => {
+  const tasks = poolCoinNames.map((t) => ({
+    poolCoinName: t,
+    balanceSheet: POOL_ADDRESSES[t]?.lendingPoolAddress,
+    collateralStat: POOL_ADDRESSES[t]?.collateralPoolAddress,
+    borrowDynamic: POOL_ADDRESSES[t]?.borrowDynamic,
+    interestModel: POOL_ADDRESSES[t]?.interestModel,
+    riskModel: POOL_ADDRESSES[t]?.riskModel,
+    borrowFeeKey: POOL_ADDRESSES[t]?.borrowFeeKey,
+    supplyLimitKey: POOL_ADDRESSES[t]?.supplyLimitKey,
+    borrowLimitKey: POOL_ADDRESSES[t]?.borrowLimitKey,
+    isolatedAssetKey: POOL_ADDRESSES[t]?.isolatedAssetKey
+  }));
+  const [
+    balanceSheetObjects,
+    collateralStatObjects,
+    borrowDynamicObjects,
+    interestModelObjects,
+    riskModelObjects,
+    borrowFeeObjects,
+    supplyLimitObjects,
+    borrowLimitObjects,
+    isolatedAssetObjects
+  ] = await Promise.all([
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.balanceSheet).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.collateralStat).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.borrowDynamic).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.interestModel).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.riskModel).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.borrowFeeKey).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.supplyLimitKey).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.borrowLimitKey).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.isolatedAssetKey).filter((t) => !!t)
+    )
+  ]);
+  const mapObjects = (tasks2, fetchedObjects) => {
+    const resultMap = {};
+    let fetchedIndex = 0;
+    for (const task of tasks2) {
+      const key = task[Object.keys(task)[1]];
+      if (key) {
+        resultMap[task.poolCoinName] = fetchedObjects[fetchedIndex];
+        fetchedIndex++;
+      }
+    }
+    return resultMap;
+  };
+  const balanceSheetMap = mapObjects(tasks, balanceSheetObjects);
+  const collateralStatMap = mapObjects(tasks, collateralStatObjects);
+  const borrowDynamicMap = mapObjects(tasks, borrowDynamicObjects);
+  const interestModelMap = mapObjects(tasks, interestModelObjects);
+  const riskModelMap = mapObjects(tasks, riskModelObjects);
+  const borrowFeeMap = mapObjects(tasks, borrowFeeObjects);
+  const supplyLimitMap = mapObjects(tasks, supplyLimitObjects);
+  const borrowLimitMap = mapObjects(tasks, borrowLimitObjects);
+  const isolatedAssetMap = mapObjects(tasks, isolatedAssetObjects);
+  return poolCoinNames.reduce(
+    (acc, name) => {
+      acc[name] = {
+        balanceSheet: balanceSheetMap[name],
+        collateralStat: collateralStatMap[name],
+        borrowDynamic: borrowDynamicMap[name],
+        interestModel: interestModelMap[name],
+        riskModel: riskModelMap[name],
+        borrowFeeKey: borrowFeeMap[name],
+        supplyLimitKey: supplyLimitMap[name],
+        borrowLimitKey: borrowLimitMap[name],
+        isolatedAssetKey: isolatedAssetMap[name]
+      };
+      return acc;
+    },
+    {}
+  );
+};
+var getMarketPools = async (query, poolCoinNames, indexer = false, coinPrices) => {
   coinPrices = coinPrices ?? await query.utils.getCoinPrices();
-  const marketPools = {};
+  const pools = {};
+  const collaterals = {};
   if (indexer) {
-    const marketPoolsIndexer = await query.indexer.getMarketPools();
-    const updateMarketPool = (marketPool) => {
-      if (!poolCoinNames.includes(marketPool.coinName))
-        return;
-      marketPool.coinPrice = coinPrices[marketPool.coinName] ?? marketPool.coinPrice;
-      marketPool.coinWrappedType = query.utils.getCoinWrappedType(
-        marketPool.coinName
-      );
-      marketPools[marketPool.coinName] = marketPool;
+    const marketIndexer = await query.indexer.getMarket();
+    const updatePools = (item) => {
+      item.coinPrice = coinPrices[item.coinName] ?? item.coinPrice;
+      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
+      pools[item.coinName] = item;
+    };
+    const updateCollaterals = (item) => {
+      item.coinPrice = coinPrices[item.coinName] ?? item.coinPrice;
+      item.coinWrappedType = query.utils.getCoinWrappedType(item.coinName);
+      collaterals[item.coinName] = item;
+    };
+    Object.values(marketIndexer.pools).forEach(updatePools);
+    Object.values(marketIndexer.collaterals).forEach(updateCollaterals);
+    return {
+      pools,
+      collaterals
     };
-    Object.values(marketPoolsIndexer).forEach(updateMarketPool);
-    return marketPools;
   }
+  const requiredObjects = await queryRequiredMarketObjects(
+    query,
+    poolCoinNames
+  );
   await Promise.allSettled(
     poolCoinNames.map(async (poolCoinName) => {
-      const marketPool = await getMarketPool(
-        query,
-        poolCoinName,
-        indexer,
-        marketObjectResponse?.data,
-        coinPrices?.[poolCoinName]
-      );
-      if (marketPool) {
-        marketPools[poolCoinName] = marketPool;
+      try {
+        const result = await getMarketPool(
+          query,
+          poolCoinName,
+          indexer,
+          coinPrices?.[poolCoinName] ?? 0,
+          requiredObjects[poolCoinName]
+        );
+        if (result?.marketPool) {
+          pools[poolCoinName] = result?.marketPool;
+        }
+        if (result?.collateral) {
+          collaterals[poolCoinName] = result.collateral;
+        }
+      } catch (e) {
+        console.error(e);
       }
     })
   );
-  return marketPools;
+  return {
+    pools,
+    collaterals
+  };
 };
-var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, coinPrice) => {
+var parseMarketPoolObjects = ({
+  balanceSheet,
+  borrowDynamic,
+  collateralStat,
+  interestModel,
+  riskModel,
+  borrowFeeKey,
+  supplyLimitKey,
+  borrowLimitKey,
+  isolatedAssetKey
+}) => {
+  const _balanceSheet = parseObjectAs(balanceSheet);
+  const _interestModel = parseObjectAs(interestModel);
+  const _borrowDynamic = parseObjectAs(borrowDynamic);
+  const _borrowFee = parseObjectAs(borrowFeeKey);
+  const _supplyLimit = supplyLimitKey ? parseObjectAs(supplyLimitKey) : "0";
+  const _borrowLimit = borrowLimitKey ? parseObjectAs(borrowLimitKey) : "0";
+  const _riskModel = riskModel ? parseObjectAs(riskModel) : void 0;
+  const _collateralStat = collateralStat ? parseObjectAs(collateralStat) : void 0;
+  const parsedOriginMarketCollateral = _riskModel && _collateralStat ? {
+    type: _interestModel.type.fields,
+    isIsolated: !!isolatedAssetKey,
+    collateralFactor: _riskModel.collateral_factor.fields,
+    liquidationFactor: _riskModel.liquidation_factor.fields,
+    liquidationPenalty: _riskModel.liquidation_penalty.fields,
+    liquidationDiscount: _riskModel.liquidation_discount.fields,
+    liquidationReserveFactor: _riskModel.liquidation_revenue_factor.fields,
+    maxCollateralAmount: _riskModel.max_collateral_amount,
+    totalCollateralAmount: _collateralStat.amount
+  } : void 0;
+  return {
+    type: _interestModel.type.fields,
+    maxBorrowRate: _interestModel.max_borrow_rate.fields,
+    interestRate: _borrowDynamic.interest_rate.fields,
+    interestRateScale: _borrowDynamic.interest_rate_scale,
+    borrowIndex: _borrowDynamic.borrow_index,
+    lastUpdated: _borrowDynamic.last_updated,
+    cash: _balanceSheet.cash,
+    debt: _balanceSheet.debt,
+    marketCoinSupply: _balanceSheet.market_coin_supply,
+    reserve: _balanceSheet.revenue,
+    reserveFactor: _interestModel.revenue_factor.fields,
+    borrowWeight: _interestModel.borrow_weight.fields,
+    borrowFeeRate: _borrowFee,
+    baseBorrowRatePerSec: _interestModel.base_borrow_rate_per_sec.fields,
+    borrowRateOnHighKink: _interestModel.borrow_rate_on_high_kink.fields,
+    borrowRateOnMidKink: _interestModel.borrow_rate_on_mid_kink.fields,
+    highKink: _interestModel.high_kink.fields,
+    midKink: _interestModel.mid_kink.fields,
+    minBorrowAmount: _interestModel.min_borrow_amount,
+    isIsolated: !!isolatedAssetKey,
+    supplyLimit: _supplyLimit,
+    borrowLimit: _borrowLimit,
+    parsedOriginMarketCollateral
+  };
+};
+var getMarketPool = async (query, poolCoinName, indexer = false, coinPrice, requiredObjects) => {
   coinPrice = coinPrice ?? (await query.utils.getCoinPrices())?.[poolCoinName];
   if (indexer) {
     const marketPoolIndexer = await query.indexer.getMarketPool(poolCoinName);
@@ -2994,135 +3527,70 @@ var getMarketPool = async (query, poolCoinName, indexer = false, marketObject, c
     marketPoolIndexer.coinWrappedType = query.utils.getCoinWrappedType(
       marketPoolIndexer.coinName
     );
-    return marketPoolIndexer;
-  }
-  const marketId = query.address.get("core.market");
-  marketObject = marketObject || (await query.cache.queryGetObject(marketId, {
-    showContent: true
-  }))?.data;
-  if (!(marketObject && marketObject.content?.dataType === "moveObject"))
-    throw new Error(`Failed to fetch marketObject`);
-  const fields = marketObject.content.fields;
-  const coinType = query.utils.parseCoinType(poolCoinName);
-  const balanceSheetParentId = fields.vault.fields.balance_sheets.fields.table.fields.id.id;
-  const balanceSheetDynamicFieldObjectResponse = await query.cache.queryGetDynamicFieldObject({
-    parentId: balanceSheetParentId,
-    name: {
-      type: "0x1::type_name::TypeName",
-      value: {
-        name: coinType.substring(2)
-      }
-    }
-  });
-  const balanceSheetDynamicFieldObject = balanceSheetDynamicFieldObjectResponse?.data;
-  if (!(balanceSheetDynamicFieldObject && balanceSheetDynamicFieldObject.content && "fields" in balanceSheetDynamicFieldObject.content))
-    throw new Error(
-      `Failed to fetch balanceSheetDynamicFieldObject for ${poolCoinName}: ${balanceSheetDynamicFieldObjectResponse?.error?.code.toString()}`
-    );
-  const balanceSheet = balanceSheetDynamicFieldObject.content.fields.value.fields;
-  const borrowIndexParentId = fields.borrow_dynamics.fields.table.fields.id.id;
-  const borrowIndexDynamicFieldObjectResponse = await query.cache.queryGetDynamicFieldObject({
-    parentId: borrowIndexParentId,
-    name: {
-      type: "0x1::type_name::TypeName",
-      value: {
-        name: coinType.substring(2)
-      }
-    }
-  });
-  const borrowIndexDynamicFieldObject = borrowIndexDynamicFieldObjectResponse?.data;
-  if (!(borrowIndexDynamicFieldObject && borrowIndexDynamicFieldObject.content && "fields" in borrowIndexDynamicFieldObject.content))
-    throw new Error(
-      `Failed to fetch borrowIndexDynamicFieldObject for ${poolCoinName}`
-    );
-  const borrowIndex = borrowIndexDynamicFieldObject.content.fields.value.fields;
-  const interestModelParentId = fields.interest_models.fields.table.fields.id.id;
-  const interestModelDynamicFieldObjectResponse = await query.cache.queryGetDynamicFieldObject({
-    parentId: interestModelParentId,
-    name: {
-      type: "0x1::type_name::TypeName",
-      value: {
-        name: coinType.substring(2)
-      }
+    let marketCollateralIndexer = void 0;
+    if (SUPPORT_COLLATERALS.includes(poolCoinName)) {
+      marketCollateralIndexer = await query.indexer.getMarketCollateral(
+        poolCoinName
+      );
+      marketCollateralIndexer.coinPrice = coinPrice ?? marketCollateralIndexer.coinPrice;
+      marketCollateralIndexer.coinWrappedType = query.utils.getCoinWrappedType(
+        marketCollateralIndexer.coinName
+      );
     }
-  });
-  const interestModelDynamicFieldObject = interestModelDynamicFieldObjectResponse?.data;
-  if (!(interestModelDynamicFieldObject && interestModelDynamicFieldObject.content && "fields" in interestModelDynamicFieldObject.content))
-    throw new Error(
-      `Failed to fetch interestModelDynamicFieldObject for ${poolCoinName}: ${interestModelDynamicFieldObject}`
-    );
-  const interestModel = interestModelDynamicFieldObject.content.fields.value.fields;
-  const getBorrowFee = async () => {
-    const borrowFeeDynamicFieldObjectResponse = await query.cache.queryGetDynamicFieldObject({
-      parentId: marketId,
-      name: {
-        type: `${BORROW_FEE_PROTOCOL_ID}::market_dynamic_keys::BorrowFeeKey`,
-        value: {
-          type: {
-            name: coinType.substring(2)
-          }
-        }
-      }
-    });
-    const borrowFeeDynamicFieldObject = borrowFeeDynamicFieldObjectResponse?.data;
-    if (!(borrowFeeDynamicFieldObject && borrowFeeDynamicFieldObject.content && "fields" in borrowFeeDynamicFieldObject.content))
-      return { value: "0" };
-    return borrowFeeDynamicFieldObject.content.fields.value.fields;
-  };
-  const parsedMarketPoolData = parseOriginMarketPoolData({
-    type: interestModel.type.fields,
-    maxBorrowRate: interestModel.max_borrow_rate.fields,
-    interestRate: borrowIndex.interest_rate.fields,
-    interestRateScale: borrowIndex.interest_rate_scale,
-    borrowIndex: borrowIndex.borrow_index,
-    lastUpdated: borrowIndex.last_updated,
-    cash: balanceSheet.cash,
-    debt: balanceSheet.debt,
-    marketCoinSupply: balanceSheet.market_coin_supply,
-    reserve: balanceSheet.revenue,
-    reserveFactor: interestModel.revenue_factor.fields,
-    borrowWeight: interestModel.borrow_weight.fields,
-    borrowFeeRate: await getBorrowFee(),
-    baseBorrowRatePerSec: interestModel.base_borrow_rate_per_sec.fields,
-    borrowRateOnHighKink: interestModel.borrow_rate_on_high_kink.fields,
-    borrowRateOnMidKink: interestModel.borrow_rate_on_mid_kink.fields,
-    highKink: interestModel.high_kink.fields,
-    midKink: interestModel.mid_kink.fields,
-    minBorrowAmount: interestModel.min_borrow_amount
-  });
+    return {
+      marketPool: marketPoolIndexer,
+      collateral: marketCollateralIndexer
+    };
+  }
+  requiredObjects ?? (requiredObjects = (await queryRequiredMarketObjects(query, [poolCoinName]))[poolCoinName]);
+  const parsedMarketPoolObjects = parseMarketPoolObjects(requiredObjects);
+  const parsedMarketPoolData = parseOriginMarketPoolData(
+    parsedMarketPoolObjects
+  );
   const calculatedMarketPoolData = calculateMarketPoolData(
     query.utils,
     parsedMarketPoolData
   );
-  const coinDecimal = query.utils.getCoinDecimal(poolCoinName);
-  const maxSupplyCoin = BigNumber3(
-    await getSupplyLimit(query.utils, poolCoinName) ?? "0"
-  ).shiftedBy(-coinDecimal).toNumber();
-  const maxBorrowCoin = BigNumber3(
-    await getBorrowLimit(query.utils, poolCoinName) ?? "0"
-  ).shiftedBy(-coinDecimal).toNumber();
-  return {
+  const parsedMarketCollateralData = parsedMarketPoolObjects.parsedOriginMarketCollateral ? parseOriginMarketCollateralData(
+    parsedMarketPoolObjects.parsedOriginMarketCollateral
+  ) : void 0;
+  const basePoolData = () => ({
     coinName: poolCoinName,
     symbol: query.utils.parseSymbol(poolCoinName),
-    coinType: query.utils.parseCoinType(poolCoinName),
     marketCoinType: query.utils.parseMarketCoinType(poolCoinName),
-    sCoinType: query.utils.parseSCoinType(
-      query.utils.parseMarketCoinName(poolCoinName)
-    ),
-    coinWrappedType: query.utils.getCoinWrappedType(poolCoinName),
-    coinDecimal,
-    coinPrice: coinPrice ?? 0,
-    highKink: parsedMarketPoolData.highKink,
-    midKink: parsedMarketPoolData.midKink,
-    reserveFactor: parsedMarketPoolData.reserveFactor,
-    borrowWeight: parsedMarketPoolData.borrowWeight,
-    borrowFee: parsedMarketPoolData.borrowFee,
-    marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
-    minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
-    maxSupplyCoin,
-    maxBorrowCoin,
-    isIsolated: await isIsolatedAsset(query.utils, poolCoinName),
-    ...calculatedMarketPoolData
+    coinType: query.utils.parseCoinType(poolCoinName)
+  });
+  return {
+    marketPool: {
+      ...basePoolData(),
+      sCoinType: query.utils.parseSCoinType(
+        query.utils.parseMarketCoinName(poolCoinName)
+      ),
+      coinWrappedType: query.utils.getCoinWrappedType(poolCoinName),
+      coinPrice: coinPrice ?? 0,
+      highKink: parsedMarketPoolData.highKink,
+      midKink: parsedMarketPoolData.midKink,
+      reserveFactor: parsedMarketPoolData.reserveFactor,
+      borrowWeight: parsedMarketPoolData.borrowWeight,
+      borrowFee: parsedMarketPoolData.borrowFee,
+      marketCoinSupplyAmount: parsedMarketPoolData.marketCoinSupplyAmount,
+      minBorrowAmount: parsedMarketPoolData.minBorrowAmount,
+      ...calculatedMarketPoolData
+    },
+    collateral: parsedMarketCollateralData ? {
+      ...basePoolData(),
+      coinWrappedType: query.utils.getCoinWrappedType(poolCoinName),
+      coinPrice,
+      collateralFactor: parsedMarketCollateralData.collateralFactor,
+      liquidationFactor: parsedMarketCollateralData.liquidationFactor,
+      liquidationDiscount: parsedMarketCollateralData.liquidationDiscount,
+      liquidationPenalty: parsedMarketCollateralData.liquidationPenalty,
+      liquidationReserveFactor: parsedMarketCollateralData.liquidationReserveFactor,
+      ...calculateMarketCollateralData(
+        query.utils,
+        parsedMarketCollateralData
+      )
+    } : void 0
   };
 };
 var getMarketCollaterals = async (query, collateralCoinNames = [...SUPPORT_COLLATERALS], indexer = false) => {
@@ -3217,10 +3685,11 @@ var getMarketCollateral = async (query, collateralCoinName, indexer = false, mar
     collateralFactor: riskModel.collateral_factor.fields,
     liquidationFactor: riskModel.liquidation_factor.fields,
     liquidationDiscount: riskModel.liquidation_discount.fields,
-    liquidationPanelty: riskModel.liquidation_penalty.fields,
+    liquidationPenalty: riskModel.liquidation_penalty.fields,
     liquidationReserveFactor: riskModel.liquidation_revenue_factor.fields,
     maxCollateralAmount: riskModel.max_collateral_amount,
-    totalCollateralAmount: collateralStat.amount
+    totalCollateralAmount: collateralStat.amount,
+    isIsolated: await isIsolatedAsset(query.utils, collateralCoinName)
   });
   const calculatedMarketCollateralData = calculateMarketCollateralData(
     query.utils,
@@ -3232,14 +3701,12 @@ var getMarketCollateral = async (query, collateralCoinName, indexer = false, mar
     coinType: query.utils.parseCoinType(collateralCoinName),
     marketCoinType: query.utils.parseMarketCoinType(collateralCoinName),
     coinWrappedType: query.utils.getCoinWrappedType(collateralCoinName),
-    coinDecimal: query.utils.getCoinDecimal(collateralCoinName),
     coinPrice: coinPrice ?? 0,
     collateralFactor: parsedMarketCollateralData.collateralFactor,
     liquidationFactor: parsedMarketCollateralData.liquidationFactor,
     liquidationDiscount: parsedMarketCollateralData.liquidationDiscount,
-    liquidationPanelty: parsedMarketCollateralData.liquidationPanelty,
+    liquidationPenalty: parsedMarketCollateralData.liquidationPenalty,
     liquidationReserveFactor: parsedMarketCollateralData.liquidationReserveFactor,
-    isIsolated: await isIsolatedAsset(query.utils, collateralCoinName),
     ...calculatedMarketCollateralData
   };
 };
@@ -3275,14 +3742,26 @@ var getObligations = async ({
   } while (hasNextPage);
   const keyObjects = keyObjectsResponse.filter((ref) => !!ref.data);
   const obligations = [];
+  const obligationsObjects = await queryMultipleObjects(
+    address.cache,
+    keyObjects.map((ref) => ref.data?.content).filter(
+      (content) => content?.dataType === "moveObject"
+    ).map((content) => content.fields.ownership.fields.of),
+    {
+      showContent: true
+    }
+  );
   await Promise.allSettled(
-    keyObjects.map(async ({ data }) => {
+    keyObjects.map(async ({ data }, idx) => {
       const keyId = data?.objectId;
       const content = data?.content;
       if (keyId && content && "fields" in content) {
         const fields = content.fields;
         const obligationId = String(fields.ownership.fields.of);
-        const locked = await getObligationLocked(address.cache, obligationId);
+        const locked = await getObligationLocked(
+          address.cache,
+          obligationsObjects[idx]
+        );
         obligations.push({ id: obligationId, keyId, locked });
       }
     })
@@ -3290,14 +3769,12 @@ var getObligations = async ({
   return obligations;
 };
 var getObligationLocked = async (cache, obligation) => {
-  const obligationObjectResponse = typeof obligation === "string" ? (await cache.queryGetObject(obligation, {
+  const obligationObjectData = typeof obligation === "string" ? (await cache.queryGetObject(obligation, {
     showContent: true
   }))?.data : obligation;
   let obligationLocked = false;
-  if (obligationObjectResponse && obligationObjectResponse?.content?.dataType === "moveObject" && "lock_key" in obligationObjectResponse.content.fields) {
-    obligationLocked = Boolean(
-      obligationObjectResponse.content.fields.lock_key
-    );
+  if (obligationObjectData && obligationObjectData?.content?.dataType === "moveObject" && "lock_key" in obligationObjectData.content.fields) {
+    obligationLocked = Boolean(obligationObjectData.content.fields.lock_key);
   }
   return obligationLocked;
 };
@@ -3480,10 +3957,10 @@ var getLendings = async (query, poolCoinNames = [...SUPPORT_POOLS], ownerAddress
     (marketCoinName) => SUPPORT_SPOOLS.includes(marketCoinName)
   );
   const coinPrices = await query.utils.getCoinPrices();
-  const marketPools = await query.getMarketPools(poolCoinNames, {
+  const marketPools = (await query.getMarketPools(poolCoinNames, {
     indexer,
     coinPrices
-  });
+  })).pools;
   const spools = await query.getSpools(stakeMarketCoinNames, {
     indexer,
     marketPools,
@@ -3651,8 +4128,10 @@ var getLending = async (query, poolCoinName, ownerAddress, indexer = false, mark
   return lending;
 };
 var getObligationAccounts = async (query, ownerAddress, indexer = false) => {
-  const coinPrices = await query.utils.getCoinPrices();
-  const market = await query.queryMarket({ indexer, coinPrices });
+  const market = await query.queryMarket({ indexer });
+  const coinPrices = await query.getAllCoinPrices({
+    marketPools: market.pools
+  });
   const [coinAmounts, obligations] = await Promise.all([
     query.getCoinAmounts(void 0, ownerAddress),
     query.getObligations(ownerAddress)
@@ -3674,17 +4153,21 @@ var getObligationAccounts = async (query, ownerAddress, indexer = false) => {
   return obligationAccounts;
 };
 var getObligationAccount = async (query, obligationId, ownerAddress, indexer = false, market, coinPrices, coinAmounts) => {
+  const coinNames = Array.from(
+    /* @__PURE__ */ new Set([...SUPPORT_POOLS, ...SUPPORT_COLLATERALS])
+  );
   const collateralAssetCoinNames = [
     ...SUPPORT_COLLATERALS
   ];
-  market = market ?? await query.queryMarket({ indexer });
+  market = market ?? await query.getMarketPools(void 0, { indexer });
   coinPrices = coinPrices ?? await query.getAllCoinPrices({ marketPools: market.pools });
-  coinAmounts = coinAmounts || await query.getCoinAmounts(collateralAssetCoinNames, ownerAddress);
+  coinAmounts = coinAmounts ?? await query.getCoinAmounts(coinNames, ownerAddress);
   const [obligationQuery, borrowIncentivePools, borrowIncentiveAccounts] = await Promise.all([
     query.queryObligation(obligationId),
     query.getBorrowIncentivePools(void 0, {
       coinPrices,
-      indexer
+      indexer,
+      marketPools: market.pools
     }),
     query.getBorrowIncentiveAccounts(obligationId)
   ]);
@@ -3822,7 +4305,7 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
       const rewards = [];
       Object.entries(borrowIncentiveAccount.pointList).forEach(
         ([key, accountPoint]) => {
-          const poolPoint = borrowIncentivePool.points[key];
+          const poolPoint = borrowIncentivePool.points[query.utils.parseSCoinTypeNameToMarketCoinName(key)];
           if (accountPoint && poolPoint) {
             let availableClaimAmount = BigNumber5(0);
             let availableClaimCoin = BigNumber5(0);
@@ -3967,7 +4450,7 @@ var getObligationAccount = async (query, obligationId, ownerAddress, indexer = f
   return obligationAccount;
 };
 var getTotalValueLocked = async (query, indexer = false) => {
-  const market = await query.queryMarket({ indexer });
+  const market = await query.getMarketPools(void 0, { indexer });
   let supplyValue = BigNumber5(0);
   let borrowValue = BigNumber5(0);
   if (indexer) {
@@ -4088,7 +4571,7 @@ var getPythPrices = async ({
 };
 var getAllCoinPrices = async (query, marketPools, coinPrices) => {
   coinPrices = coinPrices ?? await query.utils.getCoinPrices();
-  marketPools = marketPools ?? await query.getMarketPools(void 0, { coinPrices });
+  marketPools = marketPools ?? (await query.getMarketPools(void 0, { coinPrices })).pools;
   if (!marketPools) {
     throw new Error(`Failed to fetch market pool for getAllCoinPrices`);
   }
@@ -4214,12 +4697,80 @@ var getSCoinSwapRate = async (query, fromSCoin, toSCoin, underlyingCoinPrice) =>
 
 // src/queries/spoolQuery.ts
 import { normalizeStructTag as normalizeStructTag5 } from "@mysten/sui/utils";
+var queryRequiredSpoolObjects = async (query, stakePoolCoinNames) => {
+  const tasks = stakePoolCoinNames.map((t, idx) => ({
+    poolCoinName: stakePoolCoinNames[idx],
+    spool: POOL_ADDRESSES[t]?.spool,
+    spoolReward: POOL_ADDRESSES[t]?.spoolReward,
+    sCoinTreasury: POOL_ADDRESSES[t]?.sCoinTreasury
+  }));
+  const [spoolObjects, spoolRewardObjects, sCoinTreasuryObjects] = await Promise.all([
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.spool).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.spoolReward).filter((t) => !!t)
+    ),
+    queryMultipleObjects(
+      query.cache,
+      tasks.map((task) => task.sCoinTreasury).filter((t) => !!t)
+    )
+  ]);
+  const mapObjects = (tasks2, fetchedObjects) => {
+    const resultMap = {};
+    let fetchedIndex = 0;
+    for (const task of tasks2) {
+      const key = task[Object.keys(task)[1]];
+      if (key) {
+        resultMap[task.poolCoinName] = fetchedObjects[fetchedIndex];
+        fetchedIndex++;
+      }
+    }
+    return resultMap;
+  };
+  const spoolMap = mapObjects(tasks, spoolObjects);
+  const spoolRewardMap = mapObjects(tasks, spoolRewardObjects);
+  const sCoinTreasuryMap = mapObjects(tasks, sCoinTreasuryObjects);
+  return stakePoolCoinNames.reduce(
+    (acc, name) => {
+      acc[name] = {
+        spool: spoolMap[name],
+        spoolReward: spoolRewardMap[name],
+        sCoinTreasury: sCoinTreasuryMap[name]
+      };
+      return acc;
+    },
+    {}
+  );
+};
+var parseSpoolObjects = ({
+  spool,
+  spoolReward
+}) => {
+  const _spool = parseObjectAs(spool);
+  const _spoolReward = parseObjectAs(spoolReward);
+  return {
+    stakeType: _spool.stake_type,
+    maxDistributedPoint: _spool.max_distributed_point,
+    distributedPoint: _spool.distributed_point,
+    distributedPointPerPeriod: _spool.distributed_point_per_period,
+    pointDistributionTime: _spool.point_distribution_time,
+    maxStake: _spool.max_stakes,
+    stakes: _spool.stakes,
+    index: _spool.index,
+    createdAt: _spool.created_at,
+    lastUpdate: _spool.last_update,
+    ..._spoolReward
+  };
+};
 var getSpools = async (query, stakeMarketCoinNames = [...SUPPORT_SPOOLS], indexer = false, marketPools, coinPrices) => {
   const stakeCoinNames = stakeMarketCoinNames.map(
     (stakeMarketCoinName) => query.utils.parseCoinName(stakeMarketCoinName)
   );
-  coinPrices = coinPrices ?? await query.utils.getCoinPrices() ?? {};
-  marketPools = marketPools ?? await query.getMarketPools(stakeCoinNames, { indexer });
+  marketPools = marketPools ?? (await query.getMarketPools(stakeCoinNames, { indexer })).pools;
+  coinPrices = coinPrices ?? await query.getAllCoinPrices({ marketPools }) ?? {};
   if (!marketPools)
     throw new Error(`Fail to fetch marketPools for ${stakeCoinNames}`);
   const spools = {};
@@ -4234,126 +4785,93 @@ var getSpools = async (query, stakeMarketCoinNames = [...SUPPORT_SPOOLS], indexe
       const rewardCoinName = query.utils.getSpoolRewardCoinName(
         spool.marketCoinName
       );
-      const marketPool = marketPools[coinName];
       spool.coinPrice = coinPrices[coinName] ?? spool.coinPrice;
-      spool.marketCoinPrice = coinPrices[coinName] ? (coinPrices[coinName] ?? 0) * (marketPool ? marketPool.conversionRate : 0) : spool.marketCoinPrice;
+      spool.marketCoinPrice = coinPrices[spool.marketCoinName] ?? spool.marketCoinPrice;
       spool.rewardCoinPrice = coinPrices[rewardCoinName] ?? spool.rewardCoinPrice;
       spools[spool.marketCoinName] = spool;
     };
     Object.values(spoolsIndexer).forEach(updateSpools);
     return spools;
   }
-  for (const stakeMarketCoinName of stakeMarketCoinNames) {
-    const stakeCoinName = query.utils.parseCoinName(stakeMarketCoinName);
-    const spool = await getSpool(
-      query,
-      stakeMarketCoinName,
-      indexer,
-      marketPools[stakeCoinName],
-      coinPrices
-    );
-    if (spool) {
-      spools[stakeMarketCoinName] = spool;
-    }
-  }
+  const requiredObjects = await queryRequiredSpoolObjects(
+    query,
+    stakeCoinNames
+  );
+  await Promise.allSettled(
+    stakeMarketCoinNames.map(async (stakeMarketCoinName, idx) => {
+      try {
+        const stakeCoinName = stakeCoinNames[idx];
+        const spool = await getSpool(
+          query,
+          stakeMarketCoinName,
+          indexer,
+          coinPrices,
+          requiredObjects[stakeCoinName]
+        );
+        if (spool) {
+          spools[stakeMarketCoinName] = spool;
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    })
+  );
   return spools;
 };
-var getSpool = async (query, marketCoinName, indexer = false, marketPool, coinPrices) => {
+var getSpool = async (query, marketCoinName, indexer = false, coinPrices, requiredObjects) => {
   const coinName = query.utils.parseCoinName(marketCoinName);
-  marketPool = marketPool || await query.getMarketPool(coinName, { indexer });
-  if (!marketPool) {
-    throw new Error(`Failed to fetch marketPool for ${marketCoinName}`);
-  }
-  const poolId = query.address.get(`spool.pools.${marketCoinName}.id`);
-  const rewardPoolId = query.address.get(
-    `spool.pools.${marketCoinName}.rewardPoolId`
-  );
-  let spool = void 0;
-  coinPrices = coinPrices || await query.utils.getCoinPrices();
+  coinPrices = coinPrices || await query.getAllCoinPrices();
   if (indexer) {
     const spoolIndexer = await query.indexer.getSpool(marketCoinName);
     const coinName2 = query.utils.parseCoinName(marketCoinName);
     const rewardCoinName2 = query.utils.getSpoolRewardCoinName(marketCoinName);
-    spoolIndexer.coinPrice = coinPrices?.[coinName2] || spoolIndexer.coinPrice;
-    spoolIndexer.marketCoinPrice = (coinPrices?.[coinName2] ?? 0) * (marketPool ? marketPool.conversionRate : 0) || spoolIndexer.marketCoinPrice;
-    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName2] || spoolIndexer.rewardCoinPrice;
+    spoolIndexer.coinPrice = coinPrices?.[coinName2] ?? spoolIndexer.coinPrice;
+    spoolIndexer.marketCoinPrice = coinPrices?.[marketCoinName] ?? spoolIndexer.marketCoinPrice;
+    spoolIndexer.rewardCoinPrice = coinPrices?.[rewardCoinName2] ?? spoolIndexer.rewardCoinPrice;
     return spoolIndexer;
   }
-  const spoolObjectResponse = await query.cache.queryGetObjects(
-    [poolId, rewardPoolId],
-    {
-      showContent: true
-    }
-  );
-  if (!(spoolObjectResponse[0] && spoolObjectResponse[1])) {
-    throw new Error("Fail to fetch spoolObjectResponse!");
-  }
+  requiredObjects ?? (requiredObjects = (await queryRequiredSpoolObjects(query, [coinName]))[coinName]);
   const rewardCoinName = query.utils.getSpoolRewardCoinName(marketCoinName);
   coinPrices = coinPrices || await query.utils.getCoinPrices();
-  const spoolObject = spoolObjectResponse[0];
-  const rewardPoolObject = spoolObjectResponse[1];
-  if (spoolObject.content && "fields" in spoolObject.content) {
-    const spoolFields = spoolObject.content.fields;
-    const parsedSpoolData = parseOriginSpoolData({
-      stakeType: spoolFields.stake_type,
-      maxDistributedPoint: spoolFields.max_distributed_point,
-      distributedPoint: spoolFields.distributed_point,
-      distributedPointPerPeriod: spoolFields.distributed_point_per_period,
-      pointDistributionTime: spoolFields.point_distribution_time,
-      maxStake: spoolFields.max_stakes,
-      stakes: spoolFields.stakes,
-      index: spoolFields.index,
-      createdAt: spoolFields.created_at,
-      lastUpdate: spoolFields.last_update
-    });
-    const marketCoinPrice = (coinPrices?.[coinName] ?? 0) * marketPool.conversionRate;
-    const marketCoinDecimal = query.utils.getCoinDecimal(marketCoinName);
-    const calculatedSpoolData = calculateSpoolData(
-      parsedSpoolData,
-      marketCoinPrice,
-      marketCoinDecimal
-    );
-    if (rewardPoolObject.content && "fields" in rewardPoolObject.content) {
-      const rewardPoolFields = rewardPoolObject.content.fields;
-      const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData({
-        claimed_rewards: rewardPoolFields.claimed_rewards,
-        exchange_rate_numerator: rewardPoolFields.exchange_rate_numerator,
-        exchange_rate_denominator: rewardPoolFields.exchange_rate_denominator,
-        rewards: rewardPoolFields.rewards,
-        spool_id: rewardPoolFields.spool_id
-      });
-      const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
-      const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
-      const calculatedRewardPoolData = calculateSpoolRewardPoolData(
-        parsedSpoolData,
-        parsedSpoolRewardPoolData,
-        calculatedSpoolData,
-        rewardCoinPrice,
-        rewardCoinDecimal
-      );
-      spool = {
-        marketCoinName,
-        symbol: query.utils.parseSymbol(marketCoinName),
-        coinType: query.utils.parseCoinType(coinName),
-        marketCoinType: query.utils.parseMarketCoinType(coinName),
-        rewardCoinType: isMarketCoin(rewardCoinName) ? query.utils.parseMarketCoinType(rewardCoinName) : query.utils.parseCoinType(rewardCoinName),
-        sCoinType: marketPool.sCoinType,
-        coinDecimal: query.utils.getCoinDecimal(coinName),
-        rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
-        coinPrice: coinPrices?.[coinName] ?? 0,
-        marketCoinPrice,
-        rewardCoinPrice,
-        maxPoint: parsedSpoolData.maxPoint,
-        distributedPoint: parsedSpoolData.distributedPoint,
-        maxStake: parsedSpoolData.maxStake,
-        ...calculatedSpoolData,
-        exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
-        exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
-        ...calculatedRewardPoolData
-      };
-    }
-  }
-  return spool;
+  const parsedSpoolObjects = parseSpoolObjects(requiredObjects);
+  const parsedSpoolData = parseOriginSpoolData(parsedSpoolObjects);
+  const marketCoinPrice = coinPrices?.[marketCoinName] ?? 0;
+  const marketCoinDecimal = query.utils.getCoinDecimal(marketCoinName);
+  const calculatedSpoolData = calculateSpoolData(
+    parsedSpoolData,
+    marketCoinPrice,
+    marketCoinDecimal
+  );
+  const parsedSpoolRewardPoolData = parseOriginSpoolRewardPoolData(parsedSpoolObjects);
+  const rewardCoinPrice = coinPrices?.[rewardCoinName] ?? 0;
+  const rewardCoinDecimal = query.utils.getCoinDecimal(rewardCoinName);
+  const calculatedRewardPoolData = calculateSpoolRewardPoolData(
+    parsedSpoolData,
+    parsedSpoolRewardPoolData,
+    calculatedSpoolData,
+    rewardCoinPrice,
+    rewardCoinDecimal
+  );
+  return {
+    marketCoinName,
+    symbol: query.utils.parseSymbol(marketCoinName),
+    coinType: query.utils.parseCoinType(coinName),
+    marketCoinType: query.utils.parseMarketCoinType(coinName),
+    rewardCoinType: isMarketCoin(rewardCoinName) ? query.utils.parseMarketCoinType(rewardCoinName) : query.utils.parseCoinType(rewardCoinName),
+    sCoinType: query.utils.parseSCoinType(marketCoinName),
+    coinDecimal: query.utils.getCoinDecimal(coinName),
+    rewardCoinDecimal: query.utils.getCoinDecimal(rewardCoinName),
+    coinPrice: coinPrices?.[coinName] ?? 0,
+    marketCoinPrice,
+    rewardCoinPrice,
+    maxPoint: parsedSpoolData.maxPoint,
+    distributedPoint: parsedSpoolData.distributedPoint,
+    maxStake: parsedSpoolData.maxStake,
+    ...calculatedSpoolData,
+    exchangeRateNumerator: parsedSpoolRewardPoolData.exchangeRateNumerator,
+    exchangeRateDenominator: parsedSpoolRewardPoolData.exchangeRateDenominator,
+    ...calculatedRewardPoolData
+  };
 };
 var getStakeAccounts = async ({
   utils
@@ -4703,6 +5221,105 @@ var getVeScaTreasuryInfo = async (utils) => {
   };
 };
 
+// src/queries/poolAddressesQuery.ts
+var getAllAddresses = async (query) => {
+  const results = {};
+  const marketId = query.address.get("core.market");
+  const marketObject = (await query.cache.queryGetObject(marketId, {
+    showContent: true
+  }))?.data;
+  if (!(marketObject && marketObject.content?.dataType === "moveObject"))
+    throw new Error(`Failed to fetch marketObject`);
+  const fields = marketObject.content.fields;
+  const coinTypesPairs = SUPPORT_POOLS.reduce(
+    (acc, pool) => {
+      acc.push([pool, query.utils.parseCoinType(pool).substring(2)]);
+      return acc;
+    },
+    []
+  );
+  const balanceSheetParentId = fields.vault.fields.balance_sheets.fields.table.fields.id.id;
+  const collateralStatsParentId = fields.collateral_stats.fields.table.fields.id.id;
+  const borrowDynamicsParentid = fields.borrow_dynamics.fields.table.fields.id.id;
+  const interestModelParentId = fields.interest_models.fields.table.fields.id.id;
+  const riskModelParentId = fields.risk_models.fields.table.fields.id.id;
+  const ADDRESS_TYPE = `0x1::type_name::TypeName`;
+  const BORROW_FEE_TYPE = `0xc38f849e81cfe46d4e4320f508ea7dda42934a329d5a6571bb4c3cb6ea63f5da::market_dynamic_keys::BorrowFeeKey`;
+  const SUPPLY_LIMIT_TYPE = `0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::market_dynamic_keys::SupplyLimitKey`;
+  const BORROW_LIMIT_TYPE = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::BorrowLimitKey`;
+  const ISOLATED_ASSET_KEY = `0xe7dbb371a9595631f7964b7ece42255ad0e738cc85fe6da26c7221b220f01af6::market_dynamic_keys::IsolatedAssetKey`;
+  const fetchDynamicObject = async (parentId, type, value) => {
+    try {
+      return (await query.cache.queryGetDynamicFieldObject({
+        parentId,
+        name: {
+          type,
+          value
+        }
+      }))?.data?.objectId;
+    } catch (_e) {
+      return void 0;
+    }
+  };
+  await Promise.all(
+    coinTypesPairs.map(async ([coinName, coinType]) => {
+      const addresses = await Promise.all([
+        fetchDynamicObject(balanceSheetParentId, ADDRESS_TYPE, {
+          name: coinType
+        }),
+        fetchDynamicObject(collateralStatsParentId, ADDRESS_TYPE, {
+          name: coinType
+        }),
+        fetchDynamicObject(borrowDynamicsParentid, ADDRESS_TYPE, {
+          name: coinType
+        }),
+        fetchDynamicObject(interestModelParentId, ADDRESS_TYPE, {
+          name: coinType
+        }),
+        fetchDynamicObject(riskModelParentId, ADDRESS_TYPE, {
+          name: coinType
+        }),
+        fetchDynamicObject(marketId, BORROW_FEE_TYPE, coinType),
+        fetchDynamicObject(marketId, SUPPLY_LIMIT_TYPE, coinType),
+        fetchDynamicObject(marketId, BORROW_LIMIT_TYPE, coinType),
+        fetchDynamicObject(marketId, ISOLATED_ASSET_KEY, coinType)
+      ]);
+      const spool = query.address.get(
+        // @ts-ignore
+        `spool.pools.s${coinName}.id`
+      );
+      const rewardPool = query.address.get(
+        // @ts-ignore
+        `spool.pools.s${coinName}.rewardPoolId`
+      );
+      const sCoinTreasury = query.address.get(
+        // @ts-ignore
+        `scoin.coins.s${coinName}.treasury`
+      );
+      const coinDecimalId = query.address.get(
+        `core.coins.${coinName}.metaData`
+      );
+      results[coinName] = {
+        lendingPoolAddress: addresses[0],
+        collateralPoolAddress: addresses[1],
+        borrowDynamic: addresses[2],
+        interestModel: addresses[3],
+        riskModel: addresses[4],
+        borrowFeeKey: addresses[5],
+        supplyLimitKey: addresses[6],
+        borrowLimitKey: addresses[7],
+        isolatedAssetKey: addresses[8],
+        spool,
+        spoolReward: rewardPool,
+        sCoinTreasury,
+        coinDecimalId
+      };
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    })
+  );
+  return results;
+};
+
 // src/models/suiKit.ts
 import { SuiKit as SuiKit2 } from "@scallop-io/sui-kit";
 var newSuiKit = (params) => {
@@ -4854,13 +5471,14 @@ var ScallopUtils = class {
     }
   }
   /**
-   * Convert sCoin name to coin name.
+   * Convert sCoin name to market coin name.
    * This function will parse new sCoin name `scallop_...` to its old market coin name which is shorter
    * e.g: `scallop_sui -> ssui
+   * if no `scallop_...` is encountered, return coinName
    * @return sCoin name
    */
-  parseCoinNameFromSCoinName(coinName) {
-    return sCoinRawNameToName[coinName];
+  parseSCoinTypeNameToMarketCoinName(coinName) {
+    return sCoinRawNameToName[coinName] ?? coinName;
   }
   /**
    * Convert sCoin name into sCoin type
@@ -4909,6 +5527,9 @@ var ScallopUtils = class {
   }
   parseCoinNameFromType(coinType) {
     coinType = normalizeStructTag6(coinType);
+    if (sCoinTypeToName[coinType]) {
+      return sCoinTypeToName[coinType];
+    }
     const coinTypeRegex = new RegExp(`((0x[^:]+::[^:]+::[^<>]+))(?![^<>]*<)`);
     const coinTypeMatch = coinType.match(coinTypeRegex);
     const isMarketCoinType = coinType.includes("reserve::MarketCoin");
@@ -5078,7 +5699,7 @@ var ScallopUtils = class {
       );
       const priceIds = priceIdPairs.map(([_2, priceId]) => priceId);
       const pythConnection = new SuiPriceServiceConnection(endpoint, {
-        timeout: 2e3
+        timeout: 4e3
       });
       try {
         const feeds = await this.cache.queryClient.fetchQuery({
@@ -5370,32 +5991,41 @@ var generateCoreNormalMethod = ({
   const referralPkgId = builder.address.get("referral.id");
   const referralWitnessType = `${referralPkgId}::scallop_referral_program::REFERRAL_WITNESS`;
   return {
-    openObligation: () => {
-      const [obligation, obligationKey, obligationHotPotato] = txBlock.moveCall(
+    openObligation: async () => {
+      const [obligation, obligationKey, obligationHotPotato] = await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::open_obligation::open_obligation`,
         [coreIds.version]
       );
       return [obligation, obligationKey, obligationHotPotato];
     },
-    returnObligation: (obligation, obligationHotPotato) => txBlock.moveCall(
-      `${coreIds.protocolPkg}::open_obligation::return_obligation`,
-      [coreIds.version, obligation, obligationHotPotato]
-    ),
-    openObligationEntry: () => txBlock.moveCall(
-      `${coreIds.protocolPkg}::open_obligation::open_obligation_entry`,
-      [coreIds.version]
-    ),
-    addCollateral: (obligation, coin, collateralCoinName) => {
+    returnObligation: async (obligation, obligationHotPotato) => {
+      await builder.moveCall(
+        txBlock,
+        `${coreIds.protocolPkg}::open_obligation::return_obligation`,
+        [coreIds.version, obligation, obligationHotPotato]
+      );
+    },
+    openObligationEntry: async () => {
+      await builder.moveCall(
+        txBlock,
+        `${coreIds.protocolPkg}::open_obligation::open_obligation_entry`,
+        [coreIds.version]
+      );
+    },
+    addCollateral: async (obligation, coin, collateralCoinName) => {
       const coinType = builder.utils.parseCoinType(collateralCoinName);
-      return txBlock.moveCall(
+      await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::deposit_collateral::deposit_collateral`,
         [coreIds.version, obligation, coreIds.market, coin],
         [coinType]
       );
     },
-    takeCollateral: (obligation, obligationKey, amount, collateralCoinName) => {
+    takeCollateral: async (obligation, obligationKey, amount, collateralCoinName) => {
       const coinType = builder.utils.parseCoinType(collateralCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::withdraw_collateral::withdraw_collateral`,
         [
           coreIds.version,
@@ -5410,41 +6040,46 @@ var generateCoreNormalMethod = ({
         [coinType]
       );
     },
-    deposit: (coin, poolCoinName) => {
+    deposit: async (coin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::mint::mint`,
         [coreIds.version, coreIds.market, coin, SUI_CLOCK_OBJECT_ID3],
         [coinType]
       );
     },
-    depositEntry: (coin, poolCoinName) => {
+    depositEntry: async (coin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::mint::mint_entry`,
         [coreIds.version, coreIds.market, coin, SUI_CLOCK_OBJECT_ID3],
         [coinType]
       );
     },
-    withdraw: (marketCoin, poolCoinName) => {
+    withdraw: async (marketCoin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::redeem::redeem`,
         [coreIds.version, coreIds.market, marketCoin, SUI_CLOCK_OBJECT_ID3],
         [coinType]
       );
     },
-    withdrawEntry: (marketCoin, poolCoinName) => {
+    withdrawEntry: async (marketCoin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::redeem::redeem_entry`,
         [coreIds.version, coreIds.market, marketCoin, SUI_CLOCK_OBJECT_ID3],
         [coinType]
       );
     },
-    borrow: (obligation, obligationKey, amount, poolCoinName) => {
+    borrow: async (obligation, obligationKey, amount, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::borrow::borrow`,
         [
           coreIds.version,
@@ -5459,9 +6094,10 @@ var generateCoreNormalMethod = ({
         [coinType]
       );
     },
-    borrowWithReferral: (obligation, obligationKey, borrowReferral, amount, poolCoinName) => {
+    borrowWithReferral: async (obligation, obligationKey, borrowReferral, amount, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::borrow::borrow_with_referral`,
         [
           coreIds.version,
@@ -5470,16 +6106,17 @@ var generateCoreNormalMethod = ({
           coreIds.market,
           coreIds.coinDecimalsRegistry,
           borrowReferral,
-          txBlock.pure.u64(amount),
+          typeof amount === "number" ? txBlock.pure.u64(amount) : amount,
           coreIds.xOracle,
           SUI_CLOCK_OBJECT_ID3
         ],
         [coinType, referralWitnessType]
       );
     },
-    borrowEntry: (obligation, obligationKey, amount, poolCoinName) => {
+    borrowEntry: async (obligation, obligationKey, amount, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::borrow::borrow_entry`,
         [
           coreIds.version,
@@ -5494,9 +6131,10 @@ var generateCoreNormalMethod = ({
         [coinType]
       );
     },
-    repay: (obligation, coin, poolCoinName) => {
+    repay: async (obligation, coin, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::repay::repay`,
         [
           coreIds.version,
@@ -5508,17 +6146,19 @@ var generateCoreNormalMethod = ({
         [coinType]
       );
     },
-    borrowFlashLoan: (amount, poolCoinName) => {
+    borrowFlashLoan: async (amount, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::flash_loan::borrow_flash_loan`,
         [coreIds.version, coreIds.market, amount],
         [coinType]
       );
     },
-    repayFlashLoan: (coin, loan, poolCoinName) => {
+    repayFlashLoan: async (coin, loan, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      await builder.moveCall(
+        txBlock,
         `${coreIds.protocolPkg}::flash_loan::repay_flash_loan`,
         [coreIds.version, coreIds.market, coin, loan],
         [coinType]
@@ -5540,7 +6180,7 @@ var generateCoreQuickMethod = ({
       );
       if (collateralCoinName === "sui") {
         const [suiCoin] = txBlock.splitSUIFromGas([amount]);
-        txBlock.addCollateral(obligationArg, suiCoin, collateralCoinName);
+        await txBlock.addCollateral(obligationArg, suiCoin, collateralCoinName);
       } else {
         const { leftCoin, takeCoin } = await builder.selectCoin(
           txBlock,
@@ -5548,7 +6188,11 @@ var generateCoreQuickMethod = ({
           amount,
           sender
         );
-        txBlock.addCollateral(obligationArg, takeCoin, collateralCoinName);
+        await txBlock.addCollateral(
+          obligationArg,
+          takeCoin,
+          collateralCoinName
+        );
         txBlock.transferObjects([leftCoin], sender);
       }
     },
@@ -5563,7 +6207,7 @@ var generateCoreQuickMethod = ({
         obligationInfo.obligationId
       );
       await updateOracles(builder, txBlock, updateCoinNames);
-      return txBlock.takeCollateral(
+      return await txBlock.takeCollateral(
         obligationInfo.obligationId,
         obligationInfo.obligationKey,
         amount,
@@ -5575,7 +6219,7 @@ var generateCoreQuickMethod = ({
       let marketCoinDeposit;
       if (poolCoinName === "sui") {
         const [suiCoin] = txBlock.splitSUIFromGas([amount]);
-        marketCoinDeposit = txBlock.deposit(suiCoin, poolCoinName);
+        marketCoinDeposit = await txBlock.deposit(suiCoin, poolCoinName);
       } else {
         const { leftCoin, takeCoin } = await builder.selectCoin(
           txBlock,
@@ -5584,9 +6228,9 @@ var generateCoreQuickMethod = ({
           sender
         );
         txBlock.transferObjects([leftCoin], sender);
-        marketCoinDeposit = txBlock.deposit(takeCoin, poolCoinName);
+        marketCoinDeposit = await txBlock.deposit(takeCoin, poolCoinName);
       }
-      return returnSCoin ? txBlock.mintSCoin(
+      return returnSCoin ? await txBlock.mintSCoin(
         builder.utils.parseMarketCoinName(poolCoinName),
         marketCoinDeposit
       ) : marketCoinDeposit;
@@ -5604,7 +6248,7 @@ var generateCoreQuickMethod = ({
           totalAmount
         } = await builder.selectSCoin(txBlock, sCoinName, amount, sender);
         txBlock.transferObjects([leftCoin], sender);
-        const marketCoins2 = txBlock.burnSCoin(sCoinName, sCoins2);
+        const marketCoins2 = await txBlock.burnSCoin(sCoinName, sCoins2);
         amount -= totalAmount;
         try {
           if (amount > 0) {
@@ -5628,7 +6272,7 @@ var generateCoreQuickMethod = ({
           sender
         );
         txBlock.transferObjects([leftCoin], sender);
-        return txBlock.withdraw(walletMarketCoins, poolCoinName);
+        return await txBlock.withdraw(walletMarketCoins, poolCoinName);
       }
     },
     borrowQuick: async (amount, poolCoinName, obligationId, obligationKey) => {
@@ -5643,7 +6287,7 @@ var generateCoreQuickMethod = ({
       ) ?? [];
       const updateCoinNames = [...obligationCoinNames, poolCoinName];
       await updateOracles(builder, txBlock, updateCoinNames);
-      return txBlock.borrow(
+      return await txBlock.borrow(
         obligationInfo.obligationId,
         obligationInfo.obligationKey,
         amount,
@@ -5662,7 +6306,7 @@ var generateCoreQuickMethod = ({
       ) ?? [];
       const updateCoinNames = [...obligationCoinNames, poolCoinName];
       await updateOracles(builder, txBlock, updateCoinNames);
-      return txBlock.borrowWithReferral(
+      return await txBlock.borrowWithReferral(
         obligationInfo.obligationId,
         obligationInfo.obligationKey,
         borrowReferral,
@@ -5679,7 +6323,7 @@ var generateCoreQuickMethod = ({
       );
       if (poolCoinName === "sui") {
         const [suiCoin] = txBlock.splitSUIFromGas([amount]);
-        return txBlock.repay(
+        return await txBlock.repay(
           obligationInfo.obligationId,
           suiCoin,
           poolCoinName
@@ -5692,7 +6336,7 @@ var generateCoreQuickMethod = ({
           sender
         );
         txBlock.transferObjects([leftCoin], sender);
-        return txBlock.repay(
+        return await txBlock.repay(
           obligationInfo.obligationId,
           takeCoin,
           poolCoinName
@@ -5700,7 +6344,7 @@ var generateCoreQuickMethod = ({
       }
     },
     updateAssetPricesQuick: async (assetCoinNames) => {
-      return updateOracles(builder, txBlock, assetCoinNames);
+      return await updateOracles(builder, txBlock, assetCoinNames);
     }
   };
 };
@@ -5763,10 +6407,10 @@ var stakeHelper = async (builder, txBlock, stakeAccount, coinName, amount, sende
   try {
     const { takeCoin, leftCoin, totalAmount } = isSCoin ? await builder.selectSCoin(txBlock, coinName, amount, sender) : await builder.selectMarketCoin(txBlock, coinName, amount, sender);
     if (isSCoin) {
-      const marketCoin = txBlock.burnSCoin(coinName, takeCoin);
-      txBlock.stake(stakeAccount, marketCoin, coinName);
+      const marketCoin = await txBlock.burnSCoin(coinName, takeCoin);
+      await txBlock.stake(stakeAccount, marketCoin, coinName);
     } else {
-      txBlock.stake(stakeAccount, takeCoin, coinName);
+      await txBlock.stake(stakeAccount, takeCoin, coinName);
     }
     txBlock.transferObjects([leftCoin], sender);
     return totalAmount;
@@ -5782,40 +6426,43 @@ var generateSpoolNormalMethod = ({
     spoolPkg: builder.address.get("spool.id")
   };
   return {
-    createStakeAccount: (stakeMarketCoinName) => {
+    createStakeAccount: async (stakeMarketCoinName) => {
       const marketCoinType = builder.utils.parseMarketCoinType(stakeMarketCoinName);
       const stakePoolId = builder.address.get(
         `spool.pools.${stakeMarketCoinName}.id`
       );
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${spoolIds.spoolPkg}::user::new_spool_account`,
         [stakePoolId, SUI_CLOCK_OBJECT_ID4],
         [marketCoinType]
       );
     },
-    stake: (stakeAccount, coin, stakeMarketCoinName) => {
+    stake: async (stakeAccount, coin, stakeMarketCoinName) => {
       const marketCoinType = builder.utils.parseMarketCoinType(stakeMarketCoinName);
       const stakePoolId = builder.address.get(
         `spool.pools.${stakeMarketCoinName}.id`
       );
-      txBlock.moveCall(
+      await builder.moveCall(
+        txBlock,
         `${spoolIds.spoolPkg}::user::stake`,
         [stakePoolId, stakeAccount, coin, SUI_CLOCK_OBJECT_ID4],
         [marketCoinType]
       );
     },
-    unstake: (stakeAccount, amount, stakeMarketCoinName) => {
+    unstake: async (stakeAccount, amount, stakeMarketCoinName) => {
       const marketCoinType = builder.utils.parseMarketCoinType(stakeMarketCoinName);
       const stakePoolId = builder.address.get(
         `spool.pools.${stakeMarketCoinName}.id`
       );
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${spoolIds.spoolPkg}::user::unstake`,
         [stakePoolId, stakeAccount, amount, SUI_CLOCK_OBJECT_ID4],
         [marketCoinType]
       );
     },
-    claim: (stakeAccount, stakeMarketCoinName) => {
+    claim: async (stakeAccount, stakeMarketCoinName) => {
       const stakePoolId = builder.address.get(
         `spool.pools.${stakeMarketCoinName}.id`
       );
@@ -5825,7 +6472,8 @@ var generateSpoolNormalMethod = ({
       const marketCoinType = builder.utils.parseMarketCoinType(stakeMarketCoinName);
       const rewardCoinName = spoolRewardCoins[stakeMarketCoinName];
       const rewardCoinType = builder.utils.parseCoinType(rewardCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${spoolIds.spoolPkg}::user::redeem_rewards`,
         [stakePoolId, rewardPoolId, stakeAccount, SUI_CLOCK_OBJECT_ID4],
         [marketCoinType, rewardCoinType]
@@ -5890,13 +6538,16 @@ var generateSpoolQuickMethod = ({
         if (account.staked === 0)
           continue;
         const amountToUnstake = Math.min(amount, account.staked);
-        const marketCoin = txBlock.unstake(
+        const marketCoin = await txBlock.unstake(
           account.id,
           amountToUnstake,
           stakeMarketCoinName
         );
         if (returnSCoin) {
-          const sCoin = txBlock.mintSCoin(stakeMarketCoinName, marketCoin);
+          const sCoin = await txBlock.mintSCoin(
+            stakeMarketCoinName,
+            marketCoin
+          );
           toTransfer.push(sCoin);
         } else {
           toTransfer.push(marketCoin);
@@ -5922,7 +6573,7 @@ var generateSpoolQuickMethod = ({
       );
       const rewardCoins = [];
       for (const accountId of stakeAccountIds) {
-        const rewardCoin = txBlock.claim(accountId, stakeMarketCoinName);
+        const rewardCoin = await txBlock.claim(accountId, stakeMarketCoinName);
         rewardCoins.push(rewardCoin);
       }
       return rewardCoins;
@@ -6001,8 +6652,9 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
     config: builder.address.get("vesca.config")
   };
   return {
-    stakeObligation: (obligationId, obligationKey) => {
-      txBlock.moveCall(
+    stakeObligation: async (obligationId, obligationKey) => {
+      await builder.moveCall(
+        txBlock,
         `${borrowIncentiveIds.borrowIncentivePkg}::user::stake`,
         [
           borrowIncentiveIds.config,
@@ -6015,8 +6667,9 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
         ]
       );
     },
-    stakeObligationWithVesca: (obligationId, obligationKey, veScaKey) => {
-      txBlock.moveCall(
+    stakeObligationWithVesca: async (obligationId, obligationKey, veScaKey) => {
+      await builder.moveCall(
+        txBlock,
         `${borrowIncentiveIds.borrowIncentivePkg}::user::stake_with_ve_sca`,
         [
           borrowIncentiveIds.config,
@@ -6034,8 +6687,9 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
         []
       );
     },
-    unstakeObligation: (obligationId, obligationKey) => {
-      txBlock.moveCall(
+    unstakeObligation: async (obligationId, obligationKey) => {
+      await builder.moveCall(
+        txBlock,
         `${borrowIncentiveIds.borrowIncentivePkg}::user::unstake`,
         [
           borrowIncentiveIds.config,
@@ -6047,9 +6701,10 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
         ]
       );
     },
-    claimBorrowIncentive: (obligationId, obligationKey, rewardCoinName) => {
+    claimBorrowIncentive: async (obligationId, obligationKey, rewardCoinName) => {
       const rewardType = builder.utils.parseCoinType(rewardCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${borrowIncentiveIds.borrowIncentivePkg}::user::redeem_rewards`,
         [
           borrowIncentiveIds.config,
@@ -6062,8 +6717,9 @@ var generateBorrowIncentiveNormalMethod = ({ builder, txBlock }) => {
         [rewardType]
       );
     },
-    deactivateBoost: (obligation, veScaKey) => {
-      return txBlock.moveCall(
+    deactivateBoost: async (obligation, veScaKey) => {
+      await builder.moveCall(
+        txBlock,
         `${borrowIncentiveIds.borrowIncentivePkg}::user::deactivate_boost`,
         [
           borrowIncentiveIds.config,
@@ -6094,7 +6750,7 @@ var generateBorrowIncentiveQuickMethod = ({ builder, txBlock }) => {
         (txn) => txn.kind === "MoveCall" && (txn.target === `${OLD_BORROW_INCENTIVE_PROTOCOL_ID}::user::unstake` || txn.target === `${builder.address.get("borrowIncentive.id")}::user::unstake`)
       );
       if (!obligationLocked || unstakeObligationBeforeStake) {
-        txBlock.stakeObligation(obligationArg, obligationKeyArg);
+        await txBlock.stakeObligation(obligationArg, obligationKeyArg);
       }
     },
     stakeObligationWithVeScaQuick: async (obligation, obligationKey, veScaKey) => {
@@ -6115,9 +6771,9 @@ var generateBorrowIncentiveQuickMethod = ({ builder, txBlock }) => {
         const bindedVeScaKey = await builder.query.getBindedVeScaKey(obligationArg);
         const _veScaKey = bindedVeScaKey ?? veScaKey;
         if (!_veScaKey) {
-          txBlock.stakeObligation(obligationArg, obligationKeyArg);
+          await txBlock.stakeObligation(obligationArg, obligationKeyArg);
         } else {
-          txBlock.stakeObligationWithVesca(
+          await txBlock.stakeObligationWithVesca(
             obligationArg,
             obligationKeyArg,
             _veScaKey
@@ -6137,7 +6793,7 @@ var generateBorrowIncentiveQuickMethod = ({ builder, txBlock }) => {
         obligationKey
       );
       if (obligationLocked) {
-        txBlock.unstakeObligation(obligationArg, obligationKeyArg);
+        await txBlock.unstakeObligation(obligationArg, obligationKeyArg);
       }
     },
     claimBorrowIncentiveQuick: async (rewardCoinName, obligation, obligationKey) => {
@@ -6147,7 +6803,7 @@ var generateBorrowIncentiveQuickMethod = ({ builder, txBlock }) => {
         obligation,
         obligationKey
       );
-      return txBlock.claimBorrowIncentive(
+      return await txBlock.claimBorrowIncentive(
         obligationArg,
         obligationKeyArg,
         rewardCoinName
@@ -6216,8 +6872,9 @@ var generateNormalVeScaMethod = ({
     config: builder.address.get("vesca.config")
   };
   return {
-    lockSca: (scaCoin, unlockAtInSecondTimestamp) => {
-      return txBlock.moveCall(
+    lockSca: async (scaCoin, unlockAtInSecondTimestamp) => {
+      return await builder.moveCall(
+        txBlock,
         `${veScaIds.pkgId}::ve_sca::mint_ve_sca_key`,
         [
           veScaIds.config,
@@ -6230,8 +6887,9 @@ var generateNormalVeScaMethod = ({
         []
       );
     },
-    extendLockPeriod: (veScaKey, newUnlockAtInSecondTimestamp) => {
-      txBlock.moveCall(
+    extendLockPeriod: async (veScaKey, newUnlockAtInSecondTimestamp) => {
+      await builder.moveCall(
+        txBlock,
         `${veScaIds.pkgId}::ve_sca::extend_lock_period`,
         [
           veScaIds.config,
@@ -6244,8 +6902,9 @@ var generateNormalVeScaMethod = ({
         []
       );
     },
-    extendLockAmount: (veScaKey, scaCoin) => {
-      txBlock.moveCall(
+    extendLockAmount: async (veScaKey, scaCoin) => {
+      await builder.moveCall(
+        txBlock,
         `${veScaIds.pkgId}::ve_sca::lock_more_sca`,
         [
           veScaIds.config,
@@ -6258,8 +6917,9 @@ var generateNormalVeScaMethod = ({
         []
       );
     },
-    renewExpiredVeSca: (veScaKey, scaCoin, newUnlockAtInSecondTimestamp) => {
-      txBlock.moveCall(
+    renewExpiredVeSca: async (veScaKey, scaCoin, newUnlockAtInSecondTimestamp) => {
+      await builder.moveCall(
+        txBlock,
         `${veScaIds.pkgId}::ve_sca::renew_expired_ve_sca`,
         [
           veScaIds.config,
@@ -6273,8 +6933,9 @@ var generateNormalVeScaMethod = ({
         []
       );
     },
-    redeemSca: (veScaKey) => {
-      return txBlock.moveCall(
+    redeemSca: async (veScaKey) => {
+      return await builder.moveCall(
+        txBlock,
         `${veScaIds.pkgId}::ve_sca::redeem`,
         [
           veScaIds.config,
@@ -6286,8 +6947,9 @@ var generateNormalVeScaMethod = ({
         []
       );
     },
-    mintEmptyVeSca: () => {
-      return txBlock.moveCall(
+    mintEmptyVeSca: async () => {
+      return await builder.moveCall(
+        txBlock,
         `${veScaIds.pkgId}::ve_sca::mint_ve_sca_placeholder_key`,
         [veScaIds.config, veScaIds.table],
         []
@@ -6425,7 +7087,7 @@ var generateQuickVeScaMethod = ({
       const veSca = await requireVeSca(builder, txBlock, veScaKey);
       checkVesca(veSca?.unlockAt);
       if (veSca) {
-        const sca = txBlock.redeemSca(veSca.keyId);
+        const sca = await txBlock.redeemSca(veSca.keyId);
         if (transferSca) {
           txBlock.transferObjects([sca], sender);
           return;
@@ -6485,8 +7147,9 @@ var generateReferralNormalMethod = ({
   };
   const veScaTable = builder.address.get("vesca.table");
   return {
-    bindToReferral: (veScaKeyId) => {
-      return txBlock.moveCall(
+    bindToReferral: async (veScaKeyId) => {
+      await builder.moveCall(
+        txBlock,
         `${referralIds.referralPgkId}::referral_bindings::bind_ve_sca_referrer`,
         [
           referralIds.referralBindings,
@@ -6497,9 +7160,10 @@ var generateReferralNormalMethod = ({
         []
       );
     },
-    claimReferralTicket: (poolCoinName) => {
+    claimReferralTicket: async (poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${referralIds.referralPgkId}::scallop_referral_program::claim_ve_sca_referral_ticket`,
         [
           referralIds.version,
@@ -6512,9 +7176,10 @@ var generateReferralNormalMethod = ({
         [coinType]
       );
     },
-    burnReferralTicket: (ticket, poolCoinName) => {
+    burnReferralTicket: async (ticket, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      await builder.moveCall(
+        txBlock,
         `${referralIds.referralPgkId}::scallop_referral_program::burn_ve_sca_referral_ticket`,
         [
           referralIds.version,
@@ -6525,9 +7190,10 @@ var generateReferralNormalMethod = ({
         [coinType]
       );
     },
-    claimReferralRevenue: (veScaKey, poolCoinName) => {
+    claimReferralRevenue: async (veScaKey, poolCoinName) => {
       const coinType = builder.utils.parseCoinType(poolCoinName);
-      return txBlock.moveCall(
+      return await builder.moveCall(
+        txBlock,
         `${referralIds.referralPgkId}::referral_revenue_pool::claim_revenue_with_ve_sca_key`,
         [
           referralIds.version,
@@ -6550,10 +7216,16 @@ var generateReferralQuickMethod = ({
       const objToTransfer = [];
       for (const coinName of coinNames) {
         if (coinName === "sui") {
-          const rewardCoin = txBlock.claimReferralRevenue(veScaKey, coinName);
+          const rewardCoin = await txBlock.claimReferralRevenue(
+            veScaKey,
+            coinName
+          );
           objToTransfer.push(rewardCoin);
         } else {
-          const rewardCoin = txBlock.claimReferralRevenue(veScaKey, coinName);
+          const rewardCoin = await txBlock.claimReferralRevenue(
+            veScaKey,
+            coinName
+          );
           try {
             const coins = await builder.suiKit.suiInteractor.selectCoins(
               sender,
@@ -6613,8 +7285,9 @@ var generateLoyaltyProgramNormalMethod = ({ builder, txBlock }) => {
     )
   };
   return {
-    claimLoyaltyRevenue: (veScaKey) => {
-      return txBlock.moveCall(
+    claimLoyaltyRevenue: async (veScaKey) => {
+      return await builder.moveCall(
+        txBlock,
         `${loyaltyProgramIds.loyaltyProgramPkgId}::reward_pool::redeem_reward`,
         [loyaltyProgramIds.rewardPool, veScaKey]
       );
@@ -6631,7 +7304,7 @@ var generateLoyaltyProgramQuickMethod = ({
       const sender = requireSender(txBlock);
       if (!veScaKey)
         throw new Error(`No veScaKey found for user ${sender}`);
-      const rewardCoin = txBlock.claimLoyaltyRevenue(veScaKey);
+      const rewardCoin = await txBlock.claimLoyaltyRevenue(veScaKey);
       await builder.utils.mergeSimilarCoins(
         txBlock,
         rewardCoin,
@@ -6680,8 +7353,9 @@ var generateSCoinNormalMethod = ({
     pkgId: builder.address.get("scoin.id")
   };
   return {
-    mintSCoin: (marketCoinName, marketCoin) => {
-      return txBlock.moveCall(
+    mintSCoin: async (marketCoinName, marketCoin) => {
+      return await builder.moveCall(
+        txBlock,
         `${sCoinPkgIds.pkgId}::s_coin_converter::mint_s_coin`,
         [builder.utils.getSCoinTreasury(marketCoinName), marketCoin],
         [
@@ -6690,8 +7364,9 @@ var generateSCoinNormalMethod = ({
         ]
       );
     },
-    burnSCoin: (sCoinName, sCoin) => {
-      return txBlock.moveCall(
+    burnSCoin: async (sCoinName, sCoin) => {
+      return await builder.moveCall(
+        txBlock,
         `${sCoinPkgIds.pkgId}::s_coin_converter::burn_s_coin`,
         [builder.utils.getSCoinTreasury(sCoinName), sCoin],
         [
@@ -6716,7 +7391,7 @@ var generateSCoinQuickMethod = ({
         sender
       );
       txBlock.transferObjects([leftCoin], sender);
-      return txBlock.mintSCoin(marketCoinName, takeCoin);
+      return await txBlock.mintSCoin(marketCoinName, takeCoin);
     },
     burnSCoinQuick: async (sCoinName, amount) => {
       const sender = requireSender(txBlock);
@@ -6727,7 +7402,7 @@ var generateSCoinQuickMethod = ({
         sender
       );
       txBlock.transferObjects([leftCoin], sender);
-      return txBlock.burnSCoin(sCoinName, takeCoin);
+      return await txBlock.burnSCoin(sCoinName, takeCoin);
     }
   };
 };
@@ -7049,6 +7724,7 @@ var ScallopQuery = class {
   }
   /* ==================== Core Query Methods ==================== */
   /**
+   * @deprecated use getMarketPools
    * Query market data.
    * @param indexer - Whether to use indexer.
    * @return Market data.
@@ -7067,7 +7743,7 @@ var ScallopQuery = class {
    * @param indexer - Whether to use indexer.
    * @return Market pools data.
    */
-  async getMarketPools(poolCoinNames, args) {
+  async getMarketPools(poolCoinNames = [...SUPPORT_POOLS], args) {
     return await getMarketPools(
       this,
       poolCoinNames,
@@ -7083,13 +7759,8 @@ var ScallopQuery = class {
    * @return Market pool data.
    */
   async getMarketPool(poolCoinName, args) {
-    return await getMarketPool(
-      this,
-      poolCoinName,
-      args?.indexer,
-      args?.marketObject,
-      args?.coinPrice
-    );
+    const marketPools = await this.getMarketPools(void 0, args);
+    return marketPools.pools[poolCoinName];
   }
   /**
    * Get market collaterals.
@@ -7216,13 +7887,8 @@ var ScallopQuery = class {
    * @return Spool data.
    */
   async getSpool(stakeMarketCoinName, args) {
-    return await getSpool(
-      this,
-      stakeMarketCoinName,
-      args?.indexer,
-      args?.marketPool,
-      args?.coinPrices
-    );
+    const spools = await this.getSpools(void 0, args);
+    return spools[stakeMarketCoinName];
   }
   /**
    * Get stake accounts data for all stake pools (spools).
@@ -7388,11 +8054,9 @@ var ScallopQuery = class {
    * @return Borrowing and collateral information.
    */
   async getObligationAccount(obligationId, ownerAddress = this.walletAddress, args) {
-    return await getObligationAccount(
-      this,
-      obligationId,
-      ownerAddress,
-      args?.indexer
+    const results = await this.getObligationAccounts(ownerAddress, args);
+    return Object.values(results).find(
+      (obligation) => obligation?.obligationId === obligationId
     );
   }
   /**
@@ -7527,7 +8191,7 @@ var ScallopQuery = class {
    * Get list of isolated assets
    */
   async getIsolatedAssets() {
-    return await getIsolatedAssets(this.address);
+    return await getIsolatedAssets(this);
   }
   /**
    * Check if asset is an isolated asset
@@ -7550,6 +8214,13 @@ var ScallopQuery = class {
   async getAllCoinPrices(args) {
     return getAllCoinPrices(this, args?.marketPools, args?.coinPrices);
   }
+  /**
+   * Query all address (lending pool, collateral pool, borrow dynamics, interest models) of all pool
+   * @returns
+   */
+  async getPoolAddresses() {
+    return getAllAddresses(this);
+  }
 };
 
 // src/models/scallopBuilder.ts
@@ -7608,7 +8279,6 @@ var ScallopBuilder = class {
       await this.address.read();
     }
     await this.query.init(force, this.address);
-    await this.utils.init(force, this.address);
   }
   /**
    * Create a scallop txBlock instance that enhances transaction block.
@@ -7697,6 +8367,9 @@ var ScallopBuilder = class {
       txBlock
     );
   }
+  moveCall(txb, target, args, typeArgs) {
+    return txb.moveCall(target, args, typeArgs);
+  }
 };
 
 // src/models/scallopClient.ts
@@ -7843,7 +8516,7 @@ var ScallopClient = class {
   }
   async openObligation(sign = true) {
     const txBlock = this.builder.createTxBlock();
-    txBlock.openObligationEntry();
+    await txBlock.openObligationEntry();
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock
@@ -7865,9 +8538,9 @@ var ScallopClient = class {
         specificObligationId
       );
     } else {
-      const [obligation, obligationKey, hotPotato] = txBlock.openObligation();
+      const [obligation, obligationKey, hotPotato] = await txBlock.openObligation();
       await txBlock.addCollateralQuick(amount, collateralCoinName, obligation);
-      txBlock.returnObligation(obligation, hotPotato);
+      await txBlock.returnObligation(obligation, hotPotato);
       txBlock.transferObjects([obligationKey], sender);
     }
     if (sign) {
@@ -7937,7 +8610,7 @@ var ScallopClient = class {
         targetStakeAccount
       );
     } else {
-      const account = txBlock.createStakeAccount(stakeMarketCoinName);
+      const account = await txBlock.createStakeAccount(stakeMarketCoinName);
       await txBlock.stakeQuick(marketCoin, stakeMarketCoinName, account);
       txBlock.transferObjects([account], sender);
     }
@@ -8034,8 +8707,12 @@ var ScallopClient = class {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress ?? this.walletAddress;
     txBlock.setSender(sender);
-    const [coin, loan] = txBlock.borrowFlashLoan(amount, poolCoinName);
-    txBlock.repayFlashLoan(await callback(txBlock, coin), loan, poolCoinName);
+    const [coin, loan] = await txBlock.borrowFlashLoan(amount, poolCoinName);
+    await txBlock.repayFlashLoan(
+      await callback(txBlock, coin),
+      loan,
+      poolCoinName
+    );
     if (sign) {
       return await this.suiKit.signAndSendTxn(
         txBlock
@@ -8048,7 +8725,7 @@ var ScallopClient = class {
     const txBlock = this.builder.createTxBlock();
     const sender = walletAddress ?? this.walletAddress;
     txBlock.setSender(sender);
-    const stakeAccount = txBlock.createStakeAccount(marketCoinName);
+    const stakeAccount = await txBlock.createStakeAccount(marketCoinName);
     txBlock.transferObjects([stakeAccount], sender);
     if (sign) {
       return await this.suiKit.signAndSendTxn(
@@ -8067,7 +8744,7 @@ var ScallopClient = class {
     if (targetStakeAccount) {
       await txBlock.stakeQuick(amount, stakeMarketCoinName, targetStakeAccount);
     } else {
-      const account = txBlock.createStakeAccount(stakeMarketCoinName);
+      const account = await txBlock.createStakeAccount(stakeMarketCoinName);
       await txBlock.stakeQuick(amount, stakeMarketCoinName, account);
       txBlock.transferObjects([account], sender);
     }
@@ -8117,7 +8794,7 @@ var ScallopClient = class {
     );
     const stakeCoinName = this.utils.parseCoinName(stakeMarketCoinName);
     if (stakeMarketCoin) {
-      const coin = txBlock.withdraw(stakeMarketCoin, stakeCoinName);
+      const coin = await txBlock.withdraw(stakeMarketCoin, stakeCoinName);
       await this.utils.mergeSimilarCoins(
         txBlock,
         coin,
@@ -8214,6 +8891,8 @@ var ScallopClient = class {
     txBlock.setSender(sender);
     const rewardCoinsCollection = {};
     const obligationAccount = await this.query.getObligationAccount(obligationId);
+    if (!obligationAccount)
+      throw new Error("Obligation not found");
     const rewardCoinNames = Object.values(obligationAccount.borrowIncentives).flatMap(
       ({ rewards }) => rewards.filter(({ availableClaimAmount }) => availableClaimAmount > 0)
     ).flatMap(({ coinName }) => coinName);
@@ -8276,7 +8955,7 @@ var ScallopClient = class {
             throw e;
         }
         if (toDestroyMarketCoin) {
-          const sCoin = txBlock.mintSCoin(
+          const sCoin = await txBlock.mintSCoin(
             sCoinName,
             toDestroyMarketCoin
           );
@@ -8544,9 +9223,11 @@ export {
   ScallopQuery,
   ScallopUtils,
   TEST_ADDRESSES,
+  TokenBucket,
   UNLOCK_ROUND_DURATION,
   USE_TEST_ADDRESS,
   assetCoins,
+  callWithRateLimit,
   coinDecimals,
   coinIds,
   marketCoins,