@bze/bze-ui-kit 0.2.2 → 0.3.0

package/dist/index.mjs

@@ -975,6 +975,207 @@ var getPageRequestWithLimit = (limit) => {
 // src/query/burner.ts
 import { bze as bze2 } from "@bze/bzejs";
 import { PageRequest as PageRequest2 } from "@bze/bzejs/cosmos/base/query/v1beta1/pagination";
+
+// src/constants/endpoints.ts
+function getRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL || "";
+}
+function getRpcURL() {
+  return process.env.NEXT_PUBLIC_RPC_URL || "";
+}
+function getArchwayRpcURL() {
+  return process.env.NEXT_PUBLIC_RPC_URL_ARCHWAY || "";
+}
+function getOsmosisRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_OSMOSIS || "";
+}
+function getNobleRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_NOBLE || "";
+}
+function getJackalRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_JACKAL || "";
+}
+function getOmniFlixRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_FLIX || "";
+}
+function getAtomOneRpcUrl() {
+  return process.env.NEXT_PUBLIC_RPC_URL_ATOMONE || "";
+}
+function getArchwayRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_ARCHWAY || "";
+}
+function getOsmosisRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_OSMOSIS || "";
+}
+function getNobleRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_NOBLE || "";
+}
+function getJackalRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_JACKAL || "";
+}
+function getOmniFlixRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_FLIX || "";
+}
+function getAtomOneRestURL() {
+  return process.env.NEXT_PUBLIC_REST_URL_ATOMONE || "";
+}
+var getAggregatorHost = () => {
+  var _a2;
+  return (_a2 = process.env.NEXT_PUBLIC_AGG_API_HOST) != null ? _a2 : "https://getbze.com";
+};
+
+// src/query/module.ts
+var MODULE_ADDRESS_KEY = "auth:module:address:";
+var MODULE_ADDRESS_CACHE_TTL = 60 * 60 * 48;
+function getHardcodedBurnerAddress() {
+  return "bze1v7uw4xhrcv0vk7qp8jf9lu3hm5d8uu5yjp5qun";
+}
+function getHardcodedRaffleAddress() {
+  return "bze18hsqalgwlzqavrrkfnxmrjmygwyjy8senx5tgs";
+}
+function getHardcodedLockAddress() {
+  return "bze1pc5zjcvhx3e8l305zjl72grytfa30r5mdypmw4";
+}
+function getBurnerModuleAddress() {
+  return getHardcodedBurnerAddress();
+}
+function getRaffleModuleAddress() {
+  return getHardcodedRaffleAddress();
+}
+async function getModuleAddress(module) {
+  var _a2;
+  try {
+    const cacheKey = `${MODULE_ADDRESS_KEY}${module}`;
+    const localData = getFromLocalStorage(cacheKey);
+    if (null !== localData) {
+      return localData;
+    }
+    const url = getRestURL();
+    const response = await fetch(`${url}/cosmos/auth/v1beta1/module_accounts/${module}`);
+    if (!response.ok) {
+      return "";
+    }
+    const parsed = await response.json();
+    const addy = (_a2 = parsed.account.base_account) == null ? void 0 : _a2.address;
+    if (addy === void 0) {
+      return "";
+    }
+    setInLocalStorage(cacheKey, addy, MODULE_ADDRESS_CACHE_TTL);
+    return addy;
+  } catch (e) {
+    console.error(e);
+    return "";
+  }
+}
+
+// src/query/bank.ts
+async function getAddressBalances(address) {
+  try {
+    const client = await getRestClient();
+    const response = await client.cosmos.bank.v1beta1.spendableBalances({ address });
+    return response.balances;
+  } catch (e) {
+    console.error("failed to get balances", e);
+    return [];
+  }
+}
+async function getLockedBalances() {
+  try {
+    const lockerAddress = getLockerAddress();
+    if (!lockerAddress) {
+      console.warn("Locker address not configured");
+      return [];
+    }
+    return await getAddressBalances(lockerAddress);
+  } catch (e) {
+    console.error("failed to get locked balances", e);
+    return [];
+  }
+}
+
+// src/query/epoch.ts
+var EPOCH_HOUR = "hour";
+var EPOCH_DAY = "day";
+var EPOCH_WEEK = "week";
+var EPOCHS_INFO_CACHE_KEY = "epochs:info";
+var EPOCHS_INFO_CACHE_TTL = 60 * 60;
+async function getEpochsInfo() {
+  try {
+    const cachedData = getFromLocalStorage(EPOCHS_INFO_CACHE_KEY);
+    let shouldFetchFromEndpoint = false;
+    if (cachedData !== null) {
+      const cached = JSON.parse(cachedData);
+      const now = (/* @__PURE__ */ new Date()).getTime();
+      for (const epoch of cached.epochs) {
+        if (epoch.current_epoch_start_time) {
+          const startTime = new Date(epoch.current_epoch_start_time).getTime();
+          const duration = getEpochDurationByIdentifier(epoch.identifier);
+          const epochEndTime = startTime + duration - 15 * 1e3;
+          if (now >= epochEndTime) {
+            shouldFetchFromEndpoint = true;
+            break;
+          }
+        }
+      }
+      if (!shouldFetchFromEndpoint) {
+        return cached;
+      }
+    }
+    const client = await getRestClient();
+    const response = await client.bze.epochs.epochInfos();
+    setInLocalStorage(EPOCHS_INFO_CACHE_KEY, JSON.stringify(response), EPOCHS_INFO_CACHE_TTL);
+    return response;
+  } catch (e) {
+    console.error(e);
+    return { epochs: [] };
+  }
+}
+async function getCurrentEpoch(identifier) {
+  const all = await getEpochsInfo();
+  return all.epochs.find((item) => item.identifier === identifier);
+}
+async function getHourEpochInfo() {
+  return getCurrentEpoch(EPOCH_HOUR);
+}
+async function getWeekEpochInfo() {
+  return getCurrentEpoch(EPOCH_WEEK);
+}
+async function getCurrentWeekEpochEndTime() {
+  return getPeriodicEpochEndTime(EPOCH_WEEK);
+}
+async function getPeriodicWeekEpochEndTime(modWeek = 1) {
+  return getPeriodicEpochEndTime(EPOCH_WEEK, modWeek);
+}
+async function getPeriodicEpochEndTime(identifier, mod = 1) {
+  const epoch = await getCurrentEpoch(identifier);
+  if (!epoch || !epoch.current_epoch_start_time) {
+    return void 0;
+  }
+  const current = toBigNumber(epoch.current_epoch);
+  let remainingEpochs = mod - current.toNumber() % mod;
+  if (remainingEpochs === mod) {
+    remainingEpochs = 0;
+  }
+  const startAt = new Date(epoch.current_epoch_start_time);
+  const duration = getEpochDurationByIdentifier(identifier);
+  startAt.setTime(startAt.getTime() + duration + duration * remainingEpochs);
+  return startAt;
+}
+function getEpochDurationByIdentifier(identifier) {
+  const hourMs = 60 * 60 * 1e3;
+  switch (identifier) {
+    case EPOCH_HOUR:
+      return hourMs;
+    case EPOCH_DAY:
+      return hourMs * 24;
+    case EPOCH_WEEK:
+      return hourMs * 24 * 7;
+    default:
+      return hourMs;
+  }
+}
+
+// src/query/burner.ts
 var BURNED_KEY = "burner:all_burned_coins";
 var LOCAL_CACHE_TTL = 60 * 60 * 4;
 var { fromPartial: QueryAllBurnedCoinsRequestFromPartial } = bze2.burner.QueryAllBurnedCoinsRequest;
@@ -1020,6 +1221,33 @@ async function getAllBurnedCoins() {
     };
   }
 }
+var BURN_EPOCH_COUNT = 4;
+async function getNextBurning() {
+  const address = getBurnerModuleAddress();
+  if (address === "") {
+    return void 0;
+  }
+  const balances = await getAddressBalances(address);
+  if (balances.length === 0) {
+    return void 0;
+  }
+  const timeFromEpoch = await getBurningTimeFromEpoch();
+  if (!timeFromEpoch) {
+    return void 0;
+  }
+  return {
+    coins: balances,
+    date: timeFromEpoch
+  };
+}
+async function getBurningTimeFromEpoch() {
+  const params = await getBurnerParams();
+  let defaultBurningMod = BURN_EPOCH_COUNT;
+  if (params) {
+    defaultBurningMod = toBigNumber(params.periodic_burning_weeks).toNumber();
+  }
+  return await getPeriodicWeekEpochEndTime(defaultBurningMod);
+}
 
 // src/utils/validation.ts
 function isValidUrl(urlString) {
@@ -1140,54 +1368,6 @@ var isPoolSupportedByValidator = (baseDenom, quoteDenom) => {
   return supportedDenoms.includes(baseDenom) || supportedDenoms.includes(quoteDenom);
 };
 
-// src/constants/endpoints.ts
-function getRestURL() {
-  return process.env.NEXT_PUBLIC_REST_URL || "";
-}
-function getRpcURL() {
-  return process.env.NEXT_PUBLIC_RPC_URL || "";
-}
-function getArchwayRpcURL() {
-  return process.env.NEXT_PUBLIC_RPC_URL_ARCHWAY || "";
-}
-function getOsmosisRpcUrl() {
-  return process.env.NEXT_PUBLIC_RPC_URL_OSMOSIS || "";
-}
-function getNobleRpcUrl() {
-  return process.env.NEXT_PUBLIC_RPC_URL_NOBLE || "";
-}
-function getJackalRpcUrl() {
-  return process.env.NEXT_PUBLIC_RPC_URL_JACKAL || "";
-}
-function getOmniFlixRpcUrl() {
-  return process.env.NEXT_PUBLIC_RPC_URL_FLIX || "";
-}
-function getAtomOneRpcUrl() {
-  return process.env.NEXT_PUBLIC_RPC_URL_ATOMONE || "";
-}
-function getArchwayRestURL() {
-  return process.env.NEXT_PUBLIC_REST_URL_ARCHWAY || "";
-}
-function getOsmosisRestURL() {
-  return process.env.NEXT_PUBLIC_REST_URL_OSMOSIS || "";
-}
-function getNobleRestURL() {
-  return process.env.NEXT_PUBLIC_REST_URL_NOBLE || "";
-}
-function getJackalRestURL() {
-  return process.env.NEXT_PUBLIC_REST_URL_JACKAL || "";
-}
-function getOmniFlixRestURL() {
-  return process.env.NEXT_PUBLIC_REST_URL_FLIX || "";
-}
-function getAtomOneRestURL() {
-  return process.env.NEXT_PUBLIC_REST_URL_ATOMONE || "";
-}
-var getAggregatorHost = () => {
-  var _a2;
-  return (_a2 = process.env.NEXT_PUBLIC_AGG_API_HOST) != null ? _a2 : "https://getbze.com";
-};
-
 // src/constants/market.ts
 var EXCLUDED_MARKETS = {
   "factory/bze1f0qgels0eu96ev6a67znu70q7rquy9eragn8nw/ucorey/factory/bze13gzq40che93tgfm9kzmkpjamah5nj0j73pyhqk/uvdl": true,
@@ -2001,111 +2181,125 @@ async function keplrSuggestChain(chainId) {
   return await ((_a2 = window.keplr) == null ? void 0 : _a2.experimentalSuggestChain(await getKeplrChainInfo(chainId)));
 }
 
-// src/query/bank.ts
-async function getAddressBalances(address) {
+// src/query/block.ts
+var FAILOVER_BLOCKTIMES = {
+  "9334084": "2023-12-07T14:30:55.034845214Z",
+  "4423602": "2023-01-18T07:51:31.391193017Z",
+  "4827583": "2023-02-14T03:34:27.791387761Z",
+  "5149043": "2023-03-07T11:41:10.455072975Z",
+  "10855457": "2024-03-17T19:41:34.031980836Z"
+};
+var BLOCK_KEY = "tendermint:block:";
+async function getBlockDetailsByHeight(height) {
   try {
+    const cacheKey = `${BLOCK_KEY}${height}`;
+    const localData = getFromLocalStorage(cacheKey);
+    if (null !== localData) {
+      const parsed = JSON.parse(localData);
+      if (parsed) {
+        return parsed;
+      }
+    }
     const client = await getRestClient();
-    const response = await client.cosmos.bank.v1beta1.spendableBalances({ address });
-    return response.balances;
+    const response = await client.cosmos.base.tendermint.v1beta1.getBlockByHeight({ height: BigInt(height.toFixed(0)) });
+    setInLocalStorage(cacheKey, JSON.stringify(response), 0);
+    return response;
   } catch (e) {
-    console.error("failed to get balances", e);
-    return [];
+    console.error(e);
+    return {};
   }
 }
-async function getLockedBalances() {
-  try {
-    const lockerAddress = getLockerAddress();
-    if (!lockerAddress) {
-      console.warn("Locker address not configured");
-      return [];
+async function getBlockTimeByHeight(height) {
+  var _a2, _b2;
+  const details = await getBlockDetailsByHeight(height);
+  if (details.block_id === void 0) {
+    if (height.toFixed(0) in FAILOVER_BLOCKTIMES) {
+      return new Date(FAILOVER_BLOCKTIMES[height.toFixed(0)]);
     }
-    return await getAddressBalances(lockerAddress);
-  } catch (e) {
-    console.error("failed to get locked balances", e);
-    return [];
   }
+  return (_b2 = (_a2 = details.block) == null ? void 0 : _a2.header) == null ? void 0 : _b2.time;
 }
-
-// src/query/epoch.ts
-var EPOCH_HOUR = "hour";
-var EPOCH_DAY = "day";
-var EPOCH_WEEK = "week";
-var EPOCHS_INFO_CACHE_KEY = "epochs:info";
-var EPOCHS_INFO_CACHE_TTL = 60 * 60;
-async function getEpochsInfo() {
+async function getBlockResults(height) {
+  const settings = getSettings();
+  const rpcUrl = settings.endpoints.rpcEndpoint.replace("wss", "https");
+  const url = `${rpcUrl}/block_results?height=${height}`;
   try {
-    const cachedData = getFromLocalStorage(EPOCHS_INFO_CACHE_KEY);
-    let shouldFetchFromEndpoint = false;
-    if (cachedData !== null) {
-      const cached = JSON.parse(cachedData);
-      const now = (/* @__PURE__ */ new Date()).getTime();
-      for (const epoch of cached.epochs) {
-        if (epoch.current_epoch_start_time) {
-          const startTime = new Date(epoch.current_epoch_start_time).getTime();
-          const duration = getEpochDurationByIdentifier(epoch.identifier);
-          const epochEndTime = startTime + duration - 15 * 1e3;
-          if (now >= epochEndTime) {
-            shouldFetchFromEndpoint = true;
-            break;
-          }
-        }
-      }
-      if (!shouldFetchFromEndpoint) {
-        return cached;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
       }
+    });
+    if (!response.ok) {
+      console.log("not ok response from RPC: ", response);
+      return void 0;
     }
+    return await response.json();
+  } catch (error) {
+    console.error("Failed to fetch block results:", error);
+    throw error;
+  }
+}
+
+// src/query/raffle.ts
+async function getRaffles() {
+  try {
     const client = await getRestClient();
-    const response = await client.bze.epochs.epochInfos();
-    setInLocalStorage(EPOCHS_INFO_CACHE_KEY, JSON.stringify(response), EPOCHS_INFO_CACHE_TTL);
-    return response;
+    const response = await client.bze.burner.raffles();
+    return response.list;
   } catch (e) {
     console.error(e);
-    return { epochs: [] };
+    return [];
   }
 }
-async function getCurrentEpoch(identifier) {
-  const all = await getEpochsInfo();
-  return all.epochs.find((item) => item.identifier === identifier);
-}
-async function getHourEpochInfo() {
-  return getCurrentEpoch(EPOCH_HOUR);
-}
-async function getWeekEpochInfo() {
-  return getCurrentEpoch(EPOCH_WEEK);
-}
-async function getCurrentWeekEpochEndTime() {
-  return getPeriodicEpochEndTime(EPOCH_WEEK);
-}
-async function getPeriodicWeekEpochEndTime(modWeek = 1) {
-  return getPeriodicEpochEndTime(EPOCH_WEEK, modWeek);
+async function getRaffleWinners(denom) {
+  try {
+    const client = await getRestClient();
+    const response = await client.bze.burner.raffleWinners({ denom });
+    return response.list;
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
 }
-async function getPeriodicEpochEndTime(identifier, mod = 1) {
-  const epoch = await getCurrentEpoch(identifier);
-  if (!epoch || !epoch.current_epoch_start_time) {
+async function checkAddressWonRaffle(address, denom, height) {
+  var _a2;
+  const response = {
+    hasWon: false,
+    amount: "0",
+    denom,
+    address
+  };
+  if (address == "" || height <= 0) {
     return void 0;
   }
-  const current = toBigNumber(epoch.current_epoch);
-  let remainingEpochs = mod - current.toNumber() % mod;
-  if (remainingEpochs === mod) {
-    remainingEpochs = 0;
+  const blockResults = await getBlockResults(height);
+  if (!blockResults) {
+    return void 0;
   }
-  const startAt = new Date(epoch.current_epoch_start_time);
-  const duration = getEpochDurationByIdentifier(identifier);
-  startAt.setTime(startAt.getTime() + duration + duration * remainingEpochs);
-  return startAt;
-}
-function getEpochDurationByIdentifier(identifier) {
-  const hourMs = 60 * 60 * 1e3;
-  switch (identifier) {
-    case EPOCH_HOUR:
-      return hourMs;
-    case EPOCH_DAY:
-      return hourMs * 24;
-    case EPOCH_WEEK:
-      return hourMs * 24 * 7;
-    default:
-      return hourMs;
+  if (!((_a2 = blockResults.result) == null ? void 0 : _a2.finalize_block_events)) {
+    return void 0;
+  }
+  if (blockResults.result.finalize_block_events.length === 0) {
+    return void 0;
+  }
+  const raffleEvents = blockResults.result.finalize_block_events.filter((ev) => ev.type.includes("Raffle"));
+  if (!raffleEvents || raffleEvents.length === 0) {
+    return void 0;
+  }
+  for (let i = 0; i < raffleEvents.length; i++) {
+    const ev = raffleEvents[i];
+    const converted = mapEventAttributes(ev.attributes);
+    if ("participant" in converted && ev.type.includes("RaffleLostEvent") && converted["participant"] === address) {
+      return response;
+    }
+    if ("winner" in converted && ev.type.includes("RaffleWinnerEvent") && converted["winner"] === address && converted["denom"] === denom) {
+      response.hasWon = true;
+      response.amount = converted["amount"];
+      return response;
+    }
   }
+  return response;
 }
 
 // src/query/factory.ts
@@ -4736,6 +4930,7 @@ export {
   canDepositFromIBC,
   canSendToIBC,
   cancelDebounce,
+  checkAddressWonRaffle,
   convertToWebSocketUrl,
   counterpartyChainForChannel,
   createMarketId,
@@ -4772,6 +4967,10 @@ export {
   getAtomOneRestURL,
   getAtomOneRpcUrl,
   getBZEUSDPrice,
+  getBlockDetailsByHeight,
+  getBlockResults,
+  getBlockTimeByHeight,
+  getBurnerModuleAddress,
   getBurnerParams,
   getBurnerParamsWithClient,
   getChainAddressPrefix,
@@ -4795,6 +4994,7 @@ export {
   getEpochsInfo,
   getFactoryDenomAdminAddress,
   getFromLocalStorage,
+  getHardcodedLockAddress,
   getHashIBCTrace,
   getHourEpochInfo,
   getIBCAssetList,
@@ -4817,6 +5017,8 @@ export {
   getMarketSellOrders,
   getMarkets,
   getMinAmount,
+  getModuleAddress,
+  getNextBurning,
   getNoOfIntervalsNeeded,
   getNobleRestURL,
   getNobleRpcUrl,
@@ -4828,6 +5030,9 @@ export {
   getPendingUnlockParticipants,
   getPeriodicEpochEndTime,
   getPeriodicWeekEpochEndTime,
+  getRaffleModuleAddress,
+  getRaffleWinners,
+  getRaffles,
   getRestClient,
   getRestURL,
   getRpcURL,