@basedone/core 0.0.1 → 0.0.6

package/dist/index.mjs

@@ -0,0 +1,1027 @@
+import {
+  __glob
+} from "./chunk-4UEJOM6W.mjs";
+
+// lib/cloid/encoder.ts
+var mask = (bits) => (1n << bits) - 1n;
+function getEncodingLength(nbits, alphabet) {
+  return Math.floor(Number(nbits) / Math.log2(Number(alphabet.length)));
+}
+function encodeValue(value, nbits, alphabet) {
+  const encodingLength = getEncodingLength(nbits, alphabet);
+  if (value.length > encodingLength) {
+    value = value.slice(0, encodingLength);
+  }
+  if (value.length < encodingLength) {
+    value = value.padEnd(encodingLength, alphabet[alphabet.length - 1]);
+  }
+  const base = BigInt(alphabet.length);
+  let encoded = 0n;
+  for (const ch of value) {
+    const idx = alphabet.indexOf(ch);
+    if (idx === -1) throw new Error(`Invalid slug character: ${ch}`);
+    encoded = encoded * base + BigInt(idx);
+  }
+  if (encoded > Number(mask(nbits))) {
+    throw new Error(`Encoded value exceeds ${nbits} bits`);
+  }
+  return encoded;
+}
+function decodeValue(value, nbits, alphabet) {
+  if (value < 0 || value > Number(mask(nbits))) {
+    throw new Error(`Slug value out of range (must fit in ${nbits} bits)`);
+  }
+  const base = BigInt(alphabet.length);
+  let decoded = "";
+  for (let i = 0; i < getEncodingLength(nbits, alphabet); i++) {
+    const idx = value % base;
+    decoded = alphabet[Number(idx)] + decoded;
+    value = value / base;
+  }
+  return decoded.trim();
+}
+
+// lib/cloid/cloid.ts
+var LEGACY_CLOID = "0x62baee7262baee7262baee7262baee72";
+var BASED_VERSION = 1;
+var DEFAULT_TENANT_CODE = "BASED";
+var DEFAULT_OID = 0xba5ed10000ba5ed1n;
+var BASED_HEX_PREFIX = 12213969;
+var BASED_HEX_PREFIX_STR = "0xba5ed1";
+var PREFIX_BITS = 24n;
+var VERSION_BITS = 4n;
+var SLUG_BITS = 26n;
+var CLIENT_BITS = 5n;
+var IS_MINI_APP_BITS = 1n;
+var MINI_APP_TRIGGERED_BITS = 1n;
+var WIDGET_TYPE_BITS = 3n;
+var OID_BITS = 64n;
+var TOTAL_BITS = 128n;
+var SLUG_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+var OID_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789|_- ";
+var mask2 = (bits) => (1n << bits) - 1n;
+function encodeSlug(slug) {
+  if (!slug) slug = DEFAULT_TENANT_CODE;
+  return encodeValue(slug, SLUG_BITS, SLUG_ALPHABET);
+}
+function decodeSlug(value) {
+  return decodeValue(value, SLUG_BITS, SLUG_ALPHABET);
+}
+function buildCloid(version, slug, clientId, oid, options) {
+  if (version > 15) version = BASED_VERSION;
+  if (clientId > Number(mask2(CLIENT_BITS))) {
+    clientId = CloidClientCode.Unset;
+  }
+  const isMiniApp = options?.isMiniApp ? 1 : 0;
+  const miniAppTriggered = options?.miniAppTriggered ? 1 : 0;
+  const widgetType = typeof options?.widgetType === "number" ? options.widgetType : WidgetType[options?.widgetType ?? "Unset"];
+  if (widgetType > Number(mask2(WIDGET_TYPE_BITS))) {
+    throw new Error(
+      `Component ID ${widgetType} exceeds maximum value ${Number(mask2(WIDGET_TYPE_BITS))}`
+    );
+  }
+  let oidBigInt;
+  if (typeof oid === "string") {
+    if (oid.startsWith("0x") || !isNaN(Number(oid))) {
+      oidBigInt = BigInt(oid);
+    } else {
+      oidBigInt = encodeValue(oid.toLowerCase(), OID_BITS, OID_ALPHABET);
+    }
+  } else {
+    oidBigInt = oid;
+  }
+  if (oidBigInt > mask2(OID_BITS)) {
+    oidBigInt = DEFAULT_OID;
+  }
+  const slugVal = encodeSlug(slug.toUpperCase());
+  let cloid = BigInt(BASED_HEX_PREFIX) << TOTAL_BITS - PREFIX_BITS;
+  cloid |= BigInt(version & 15) << TOTAL_BITS - PREFIX_BITS - VERSION_BITS;
+  cloid |= BigInt(slugVal) << TOTAL_BITS - PREFIX_BITS - VERSION_BITS - SLUG_BITS;
+  cloid |= BigInt(clientId) << OID_BITS;
+  cloid |= BigInt(isMiniApp) << OID_BITS + CLIENT_BITS;
+  cloid |= BigInt(miniAppTriggered) << OID_BITS + CLIENT_BITS + IS_MINI_APP_BITS;
+  cloid |= BigInt(widgetType) << OID_BITS + CLIENT_BITS + IS_MINI_APP_BITS + MINI_APP_TRIGGERED_BITS;
+  cloid |= oidBigInt & mask2(OID_BITS);
+  return `0x${cloid.toString(16)}`;
+}
+function parseCloid(cloidHex) {
+  if (cloidHex === LEGACY_CLOID) {
+    return {
+      prefix: LEGACY_CLOID,
+      version: 0,
+      slug: "BASED",
+      clientId: CloidClientCode.Unset,
+      isMiniApp: false,
+      miniAppTriggered: false,
+      widgetTypeId: WidgetType.Unset,
+      oid: 0xba5ed10000ba5ed1n,
+      decodedOid: decodeValue(0xba5ed10000ba5ed1n, OID_BITS, OID_ALPHABET),
+      clientName: "Unset",
+      widgetTypeName: "Unset"
+    };
+  }
+  try {
+    const cloid = BigInt(cloidHex);
+    const prefix = Number(cloid >> TOTAL_BITS - PREFIX_BITS);
+    const version = Number(
+      cloid >> TOTAL_BITS - PREFIX_BITS - VERSION_BITS & mask2(VERSION_BITS)
+    );
+    const slugVal = Number(
+      cloid >> OID_BITS + WIDGET_TYPE_BITS + MINI_APP_TRIGGERED_BITS + IS_MINI_APP_BITS + CLIENT_BITS & mask2(SLUG_BITS)
+    );
+    const clientId = Number(cloid >> OID_BITS & mask2(CLIENT_BITS));
+    const isMiniApp = Number(cloid >> OID_BITS + CLIENT_BITS & mask2(IS_MINI_APP_BITS)) === 1;
+    const miniAppTriggered = Number(
+      cloid >> OID_BITS + CLIENT_BITS + IS_MINI_APP_BITS & mask2(MINI_APP_TRIGGERED_BITS)
+    ) === 1;
+    const widgetType = Number(
+      cloid >> OID_BITS + CLIENT_BITS + IS_MINI_APP_BITS + MINI_APP_TRIGGERED_BITS & mask2(WIDGET_TYPE_BITS)
+    );
+    const oid = cloid & mask2(OID_BITS);
+    return {
+      prefix: `0x${prefix.toString(16)}`,
+      // should equal 0xBA5ED1
+      version,
+      slug: decodeSlug(BigInt(slugVal)),
+      clientId,
+      isMiniApp,
+      miniAppTriggered,
+      widgetTypeId: widgetType,
+      oid,
+      decodedOid: decodeValue(oid, OID_BITS, OID_ALPHABET),
+      clientName: getClientCodeNameById(clientId),
+      widgetTypeName: getWidgetTypeById(widgetType)
+    };
+  } catch (error) {
+    console.error("Invalid cloid", { cloidHex });
+    return null;
+  }
+}
+function isBasedCloid(cloidHex) {
+  if (!cloidHex) return false;
+  if (cloidHex === LEGACY_CLOID) return true;
+  return cloidHex.toLowerCase().startsWith(BASED_HEX_PREFIX_STR);
+}
+function isTenantCloid(tenantTrackingSlug, cloidHex) {
+  if (!cloidHex || !isBasedCloid(cloidHex)) return false;
+  const cloidData = parseCloid(cloidHex);
+  if (!cloidData) return false;
+  const { slug } = cloidData;
+  if (tenantTrackingSlug.length > 5) {
+    tenantTrackingSlug = tenantTrackingSlug.slice(0, 5);
+  }
+  const normalisedSlug = decodeSlug(encodeSlug(tenantTrackingSlug));
+  return slug === normalisedSlug;
+}
+function isTrackingIdCloid(trackingId, cloidHex) {
+  if (!cloidHex || !isBasedCloid(cloidHex)) return false;
+  const cloidData = parseCloid(cloidHex);
+  if (!cloidData) return false;
+  if (typeof trackingId === "string") {
+    const encodedTrackingId = normaliseTrackingId(trackingId);
+    return encodedTrackingId === cloidData.decodedOid;
+  } else {
+    const { oid } = cloidData;
+    return oid === trackingId;
+  }
+}
+function normaliseSlug(slug) {
+  if (!slug) return "";
+  return decodeSlug(encodeSlug(slug.toUpperCase()));
+}
+function normaliseTrackingId(trackingId) {
+  if (!trackingId) return "";
+  return decodeValue(
+    encodeValue(trackingId.toLowerCase(), OID_BITS, OID_ALPHABET),
+    OID_BITS,
+    OID_ALPHABET
+  );
+}
+var CloidClientCode = {
+  Unset: 0,
+  // 0x00
+  Web: 1,
+  App: 2,
+  TgBot: 3,
+  TSL: 4,
+  // Trailing Stop Loss
+  Grid: 5,
+  Chase: 6,
+  Desktop: 7,
+  API: 8
+};
+var CloidClientCodeNameById = {
+  [CloidClientCode.Unset]: "Unset",
+  [CloidClientCode.Web]: "Web",
+  [CloidClientCode.App]: "App",
+  [CloidClientCode.TgBot]: "TgBot",
+  [CloidClientCode.TSL]: "TSL",
+  [CloidClientCode.Grid]: "Grid",
+  [CloidClientCode.Chase]: "Chase",
+  [CloidClientCode.Desktop]: "Desktop",
+  [CloidClientCode.API]: "API"
+};
+function getClientCodeNameById(id) {
+  return CloidClientCodeNameById[id] ?? `client_${id}`;
+}
+var WidgetType = {
+  Unset: 0,
+  // 0x00
+  SidePanel: 1,
+  Widget: 2,
+  FloatingWidget: 3
+};
+var WidgetTypeById = {
+  [WidgetType.Unset]: "Unset",
+  [WidgetType.SidePanel]: "SidePanel",
+  [WidgetType.Widget]: "Widget",
+  [WidgetType.FloatingWidget]: "FloatingWidget"
+};
+function getWidgetTypeById(id) {
+  return WidgetTypeById[id] ?? `widget_${id}`;
+}
+function getCloid(tenantCode, clientCode, oid, attribution) {
+  try {
+    const clientIdx = typeof clientCode === "number" ? clientCode : CloidClientCode[clientCode ?? "Unset"];
+    return buildCloid(
+      BASED_VERSION,
+      tenantCode ?? DEFAULT_TENANT_CODE,
+      clientIdx,
+      oid ?? DEFAULT_OID,
+      attribution
+    );
+  } catch (error) {
+    console.error(
+      "Invalid cloid parameters, defaulting to legacy cloid",
+      error,
+      { tenantCode, clientCode, oid, options: attribution }
+    );
+    return LEGACY_CLOID;
+  }
+}
+function isClientCode(clientCode, cloidHex) {
+  const cloidData = parseCloid(cloidHex);
+  if (!cloidData) return false;
+  return cloidData.clientId === clientCode;
+}
+function isWidgetType(widgetType, cloidHex) {
+  const cloidData = parseCloid(cloidHex);
+  if (!cloidData) return false;
+  return cloidData.widgetTypeId === widgetType;
+}
+function isMiniAppCloid(cloidHex) {
+  const cloidData = parseCloid(cloidHex);
+  if (!cloidData) return false;
+  return cloidData.isMiniApp;
+}
+function isMiniAppTriggeredCloid(cloidHex) {
+  const cloidData = parseCloid(cloidHex);
+  if (!cloidData) return false;
+  return cloidData.miniAppTriggered;
+}
+
+// lib/constants/fee.ts
+var BASED_FEE_WALLET = "0x1924b8561eeF20e70Ede628A296175D358BE80e5";
+var BASED_REFERRAL_CODE = "SHIFU";
+
+// lib/fee.ts
+var TARGET_SPOT_BUILDER_FEE = 100;
+var TARGET_FUTURES_BUILDER_FEE = 25;
+var TARGET_APPROVED_MAX_BUILDER_FEE = Math.max(
+  TARGET_SPOT_BUILDER_FEE,
+  TARGET_FUTURES_BUILDER_FEE
+);
+var TARGET_APPROVED_MAX_BUILDER_FEE_PERCENT = `0.1%`;
+var getApprovalAmount = ({
+  customFeeEnabled,
+  perpetualTradingFee,
+  spotTradingFee
+}) => {
+  if (!customFeeEnabled) {
+    return {
+      approvalAmount: TARGET_APPROVED_MAX_BUILDER_FEE,
+      perpFee: TARGET_FUTURES_BUILDER_FEE,
+      spotFee: TARGET_SPOT_BUILDER_FEE,
+      approvalPercent: TARGET_APPROVED_MAX_BUILDER_FEE_PERCENT,
+      builder: BASED_FEE_WALLET,
+      referralCode: BASED_REFERRAL_CODE
+    };
+  }
+  let validatedPerpFeePct = perpetualTradingFee;
+  if (validatedPerpFeePct === void 0) {
+    validatedPerpFeePct = TARGET_FUTURES_BUILDER_FEE / 1e3;
+  }
+  if (validatedPerpFeePct > 0 && validatedPerpFeePct < 0.01) {
+    console.warn("Perp fee is less than 0.01%, setting to 0.01%");
+    validatedPerpFeePct = 0.01;
+  }
+  if (validatedPerpFeePct < 0) {
+    console.warn("Perp fee is less than 0, setting to 0");
+    validatedPerpFeePct = 0;
+  }
+  if (validatedPerpFeePct > 0.1) {
+    console.warn("Perp fee is greater than 0.1%, setting to 0.1%");
+    validatedPerpFeePct = 0.1;
+  }
+  let validatedSpotFeePct = spotTradingFee;
+  if (validatedSpotFeePct === void 0) {
+    validatedSpotFeePct = TARGET_SPOT_BUILDER_FEE / 1e3;
+  }
+  if (validatedSpotFeePct > 0 && validatedSpotFeePct < 0.025) {
+    console.warn("Spot fee is less than 0.025%, setting to 0.025%");
+    validatedSpotFeePct = 0.025;
+  }
+  if (validatedSpotFeePct < 0) {
+    console.warn("Spot fee is less than 0, setting to 0");
+    validatedSpotFeePct = 0;
+  }
+  if (validatedSpotFeePct > 1) {
+    console.warn("Spot fee is greater than 1%, setting to 1%");
+    validatedSpotFeePct = 1;
+  }
+  const perpFee = Math.floor(validatedPerpFeePct * 1e3);
+  const spotFee = Math.floor(validatedSpotFeePct * 1e3);
+  const requiredPercent = validatedPerpFeePct > validatedSpotFeePct ? validatedPerpFeePct : validatedSpotFeePct;
+  const requiredAmount = Math.max(Math.floor(requiredPercent * 1e3), 1);
+  const requiredPercentString = `${requiredAmount / 1e3}%`;
+  return {
+    approvalAmount: requiredAmount,
+    approvalPercent: requiredPercentString,
+    perpFee,
+    spotFee,
+    builder: BASED_FEE_WALLET,
+    referralCode: BASED_REFERRAL_CODE
+  };
+};
+
+// lib/pup/types.ts
+var PUP_TOKEN_ADDRESS = "0x876e7f2f30935118a654fc0e1f807afc49efe500";
+var PUP_TOKEN_THRESHOLDS = {
+  AIRDROP_70_PERCENT: 0.7,
+  AIRDROP_35_PERCENT: 0.35,
+  AIRDROP_110_PERCENT: 1.1,
+  NON_AIRDROP_TOKENS: 2e6
+};
+var XP_BOOST_PERCENTAGES = {
+  NO_BOOST: 0,
+  TIER_1: 25,
+  TIER_2: 50,
+  TIER_3: 60
+};
+
+// lib/pup/calculator.ts
+function calculateTotalPupAmount(positions) {
+  let totalPupAmount = 0;
+  const pupAddress = PUP_TOKEN_ADDRESS.toLowerCase();
+  for (const position of positions) {
+    try {
+      if (position.version === "erc20" && position.pair === "PUP") {
+        const amount = parseFloat(position.amount) / 1e18;
+        totalPupAmount += amount;
+        console.log(`Found pure PUP position: ${amount} PUP`);
+      } else if (position.version === "v3" && position.v3LPTokenInfo) {
+        const { token0, token1 } = position.v3LPTokenInfo;
+        if (token0.address.toLowerCase() === pupAddress || token0.symbol === "PUP") {
+          totalPupAmount += token0.amount;
+          console.log(`Found V3 LP position with PUP as token0: ${token0.amount} PUP`);
+        } else if (token1.address.toLowerCase() === pupAddress || token1.symbol === "PUP") {
+          totalPupAmount += token1.amount;
+          console.log(`Found V3 LP position with PUP as token1: ${token1.amount} PUP`);
+        }
+      }
+    } catch (error) {
+      console.error(`Error processing position ${position.pair}:`, error);
+    }
+  }
+  console.log(`Total PUP amount calculated: ${totalPupAmount}`);
+  return totalPupAmount;
+}
+function calculateBoostPercentage(pupTokenAmount, normalizedAirDropAmount, isAirdropRecipient) {
+  if (isAirdropRecipient && normalizedAirDropAmount > 0) {
+    const retentionRatio = pupTokenAmount / normalizedAirDropAmount;
+    if (retentionRatio >= PUP_TOKEN_THRESHOLDS.AIRDROP_110_PERCENT) {
+      return XP_BOOST_PERCENTAGES.TIER_3;
+    }
+    if (retentionRatio >= PUP_TOKEN_THRESHOLDS.AIRDROP_70_PERCENT) {
+      return XP_BOOST_PERCENTAGES.TIER_2;
+    }
+    if (retentionRatio >= PUP_TOKEN_THRESHOLDS.AIRDROP_35_PERCENT) {
+      return XP_BOOST_PERCENTAGES.TIER_1;
+    }
+    return XP_BOOST_PERCENTAGES.NO_BOOST;
+  } else {
+    if (pupTokenAmount >= PUP_TOKEN_THRESHOLDS.NON_AIRDROP_TOKENS) {
+      return XP_BOOST_PERCENTAGES.TIER_1;
+    }
+    return XP_BOOST_PERCENTAGES.NO_BOOST;
+  }
+}
+function normalizeAirdropAmount(amount) {
+  if (!amount) return 0;
+  if (typeof amount === "bigint") {
+    return Number(amount) / 1e18;
+  } else if (amount && typeof amount.div === "function") {
+    return amount.div(1e18).toNumber();
+  }
+  return 0;
+}
+function getNextTierInfo(pupTokenAmount, normalizedAirDropAmount, isAirdropRecipient) {
+  const currentBoost = calculateBoostPercentage(pupTokenAmount, normalizedAirDropAmount, isAirdropRecipient);
+  let currentTier = 0;
+  if (currentBoost === XP_BOOST_PERCENTAGES.TIER_3) currentTier = 3;
+  else if (currentBoost === XP_BOOST_PERCENTAGES.TIER_2) currentTier = 2;
+  else if (currentBoost === XP_BOOST_PERCENTAGES.TIER_1) currentTier = 1;
+  if (isAirdropRecipient && normalizedAirDropAmount > 0) {
+    const retentionRatio = pupTokenAmount / normalizedAirDropAmount;
+    if (currentTier === 0) {
+      const threshold = normalizedAirDropAmount * PUP_TOKEN_THRESHOLDS.AIRDROP_35_PERCENT;
+      return {
+        currentTier: 0,
+        currentBoost: XP_BOOST_PERCENTAGES.NO_BOOST,
+        nextTier: 1,
+        nextBoost: XP_BOOST_PERCENTAGES.TIER_1,
+        amountToNextTier: Math.max(0, threshold - pupTokenAmount),
+        nextTierThreshold: threshold,
+        progressPercentage: Math.min(100, pupTokenAmount / threshold * 100)
+      };
+    } else if (currentTier === 1) {
+      const threshold = normalizedAirDropAmount * PUP_TOKEN_THRESHOLDS.AIRDROP_70_PERCENT;
+      return {
+        currentTier: 1,
+        currentBoost: XP_BOOST_PERCENTAGES.TIER_1,
+        nextTier: 2,
+        nextBoost: XP_BOOST_PERCENTAGES.TIER_2,
+        amountToNextTier: Math.max(0, threshold - pupTokenAmount),
+        nextTierThreshold: threshold,
+        progressPercentage: Math.min(100, (pupTokenAmount - normalizedAirDropAmount * PUP_TOKEN_THRESHOLDS.AIRDROP_35_PERCENT) / (threshold - normalizedAirDropAmount * PUP_TOKEN_THRESHOLDS.AIRDROP_35_PERCENT) * 100)
+      };
+    } else if (currentTier === 2) {
+      const threshold = normalizedAirDropAmount * PUP_TOKEN_THRESHOLDS.AIRDROP_110_PERCENT;
+      return {
+        currentTier: 2,
+        currentBoost: XP_BOOST_PERCENTAGES.TIER_2,
+        nextTier: 3,
+        nextBoost: XP_BOOST_PERCENTAGES.TIER_3,
+        amountToNextTier: Math.max(0, threshold - pupTokenAmount),
+        nextTierThreshold: threshold,
+        progressPercentage: Math.min(100, (pupTokenAmount - normalizedAirDropAmount * PUP_TOKEN_THRESHOLDS.AIRDROP_70_PERCENT) / (threshold - normalizedAirDropAmount * PUP_TOKEN_THRESHOLDS.AIRDROP_70_PERCENT) * 100)
+      };
+    } else {
+      return {
+        currentTier: 3,
+        currentBoost: XP_BOOST_PERCENTAGES.TIER_3,
+        nextTier: null,
+        nextBoost: null,
+        amountToNextTier: null,
+        nextTierThreshold: null,
+        progressPercentage: 100
+      };
+    }
+  } else {
+    const threshold = PUP_TOKEN_THRESHOLDS.NON_AIRDROP_TOKENS;
+    if (currentTier === 0) {
+      return {
+        currentTier: 0,
+        currentBoost: XP_BOOST_PERCENTAGES.NO_BOOST,
+        nextTier: 1,
+        nextBoost: XP_BOOST_PERCENTAGES.TIER_1,
+        amountToNextTier: Math.max(0, threshold - pupTokenAmount),
+        nextTierThreshold: threshold,
+        progressPercentage: Math.min(100, pupTokenAmount / threshold * 100)
+      };
+    } else {
+      return {
+        currentTier: 1,
+        currentBoost: XP_BOOST_PERCENTAGES.TIER_1,
+        nextTier: null,
+        nextBoost: null,
+        amountToNextTier: null,
+        nextTierThreshold: null,
+        progressPercentage: 100
+      };
+    }
+  }
+}
+
+// lib/constants/tokens.ts
+var USDC_SPOT_TOKEN = {
+  name: "USDC",
+  szDecimals: 8,
+  weiDecimals: 8,
+  index: 0,
+  tokenId: "0x6d1e7cde53ba9467b783cb7c530ce054",
+  isCanonical: true,
+  evmContract: null,
+  fullName: null,
+  deployerTradingFeeShare: "0.0"
+};
+var TESTNET_USDC_SPOT_TOKEN = {
+  name: "USDC",
+  szDecimals: 8,
+  weiDecimals: 8,
+  index: 0,
+  tokenId: "0xeb62eee3685fc4c43992febcd9e75443",
+  isCanonical: true,
+  evmContract: {
+    address: "0xd9cbec81df392a88aeff575e962d149d57f4d6bc",
+    evm_extra_wei_decimals: 0
+  },
+  fullName: null,
+  deployerTradingFeeShare: "0.0"
+};
+
+// lib/meta/metadata.ts
+import {
+  HttpTransport,
+  InfoClient
+} from "@nktkas/hyperliquid";
+
+// lib/hip3/utils.ts
+function isHip3Symbol(symbol) {
+  if (!symbol) return false;
+  return symbol.includes(":");
+}
+
+// import("./data/**/*/spotMeta.json") in lib/meta/metadata.ts
+var globImport_data_spotMeta_json = __glob({
+  "./data/mainnet/spotMeta.json": () => import("./spotMeta-7IJT3W6H.mjs"),
+  "./data/testnet/spotMeta.json": () => import("./spotMeta-ZVBZNUUE.mjs")
+});
+
+// import("./data/**/*/meta.json") in lib/meta/metadata.ts
+var globImport_data_meta_json = __glob({
+  "./data/mainnet/meta.json": () => import("./meta-52Q5UUQ4.mjs"),
+  "./data/testnet/meta.json": () => import("./meta-UUXKK7IB.mjs")
+});
+
+// import("./data/**/*/perpDexs.json") in lib/meta/metadata.ts
+var globImport_data_perpDexs_json = __glob({
+  "./data/mainnet/perpDexs.json": () => import("./perpDexs-S3TK25EU.mjs"),
+  "./data/testnet/perpDexs.json": () => import("./perpDexs-TZIQ57IW.mjs")
+});
+
+// lib/meta/metadata.ts
+var MetadataClient = class {
+  constructor(config = {}) {
+    // Core metadata
+    this.spotMeta = null;
+    this.perpsMeta = null;
+    this.perpDexs = [];
+    // HIP-3 metadata cache
+    this.hip3DexsMeta = /* @__PURE__ */ new Map();
+    // Pre-computed lookup maps (populated on initialize)
+    this.perpsSymbolToIndex = /* @__PURE__ */ new Map();
+    this.spotTokenNameToIndex = /* @__PURE__ */ new Map();
+    this.spotPairToMarket = /* @__PURE__ */ new Map();
+    this.baseTokenToMarkets = /* @__PURE__ */ new Map();
+    this.quoteAssets = [];
+    // Unified symbol lookup (used by getMarketBySymbol for O(1) access)
+    // Maps symbol to MarketInfo for quick lookups
+    this.coinToMarket = /* @__PURE__ */ new Map();
+    // HIP-3 optimized lookups
+    // Maps "dex:coin" symbol to MarketInfo
+    this.hip3SymbolToMarket = /* @__PURE__ */ new Map();
+    // Maps dex name to dex index for quick lookups
+    this.dexNameToIndex = /* @__PURE__ */ new Map();
+    // Lazy init flag
+    this.initialized = false;
+    const transport = new HttpTransport({
+      isTestnet: config.isTestnet ?? false
+    });
+    this.infoClient = new InfoClient({ transport });
+    this.config = {
+      ...config,
+      useStaticFallback: config.useStaticFallback ?? true
+    };
+    this.isTestnet = config.isTestnet ?? false;
+    this.initialize();
+  }
+  /**
+   * Initialize metadata by fetching from Hyperliquid
+   */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.config.onlyUseStaticFallback) {
+      await this.loadStaticMetadata();
+      this.buildLookupMaps();
+      if (this.config.hip3Dexs && this.config.hip3Dexs.length > 0) {
+        await Promise.all(
+          this.config.hip3Dexs.map((dex) => this.loadHip3Metadata(dex))
+        );
+      }
+      this.initialized = true;
+      return;
+    }
+    try {
+      [this.spotMeta, this.perpsMeta, this.perpDexs] = await Promise.all([
+        this.infoClient.spotMeta(),
+        this.infoClient.meta(),
+        this.infoClient.perpDexs()
+      ]);
+      this.buildLookupMaps();
+      if (this.config.hip3Dexs && this.config.hip3Dexs.length > 0) {
+        await Promise.all(
+          this.config.hip3Dexs.map((dex) => this.loadHip3Metadata(dex))
+        );
+      }
+      this.initialized = true;
+    } catch (error) {
+      if (this.config.useStaticFallback) {
+        console.warn(
+          "Failed to fetch metadata from API, using static fallback data",
+          error
+        );
+        await this.loadStaticMetadata();
+        this.buildLookupMaps();
+        this.initialized = true;
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Load static metadata from bundled JSON files
+   */
+  async loadStaticMetadata() {
+    const network = this.isTestnet ? "testnet" : "mainnet";
+    try {
+      const [spotMetaModule, perpsMetaModule, perpDexsModule] = await Promise.all([
+        globImport_data_spotMeta_json(`./data/${network}/spotMeta.json`),
+        globImport_data_meta_json(`./data/${network}/meta.json`),
+        globImport_data_perpDexs_json(`./data/${network}/perpDexs.json`)
+      ]);
+      this.spotMeta = spotMetaModule.default;
+      this.perpsMeta = perpsMetaModule.default;
+      this.perpDexs = perpDexsModule.default;
+      console.warn(`Using static ${network} metadata`);
+    } catch (error) {
+      console.error(`Failed to load static ${network} metadata:`, error);
+      throw new Error(`Could not load metadata for ${network}`);
+    }
+  }
+  /**
+   * Build optimized lookup maps from raw metadata
+   * Called after metadata is loaded (from API or static files)
+   */
+  buildLookupMaps() {
+    this.perpsSymbolToIndex.clear();
+    this.spotTokenNameToIndex.clear();
+    this.spotPairToMarket.clear();
+    this.baseTokenToMarkets.clear();
+    this.coinToMarket.clear();
+    this.hip3SymbolToMarket.clear();
+    this.dexNameToIndex.clear();
+    this.quoteAssets = [];
+    if (this.perpDexs) {
+      this.perpDexs.forEach((dex, index) => {
+        if (dex && dex.name) {
+          this.dexNameToIndex.set(dex.name.toLowerCase(), index);
+        }
+      });
+    }
+    if (this.perpsMeta) {
+      this.perpsMeta.universe.forEach((market, index) => {
+        const marketInfo = {
+          symbol: market.name,
+          coin: market.name,
+          assetId: index,
+          szDecimals: market.szDecimals,
+          type: "perps",
+          maxLeverage: market.maxLeverage
+        };
+        this.perpsSymbolToIndex.set(market.name.toUpperCase(), index);
+        this.coinToMarket.set(market.name, marketInfo);
+      });
+    }
+    if (this.spotMeta) {
+      this.spotMeta.tokens.forEach((token) => {
+        this.spotTokenNameToIndex.set(token.name.toUpperCase(), token.index);
+      });
+      const quoteIndices = /* @__PURE__ */ new Set();
+      this.spotMeta.universe.forEach((universe) => {
+        const baseToken = this.spotMeta.tokens[universe.tokens[0]];
+        const quoteToken = this.spotMeta.tokens[universe.tokens[1]];
+        if (!baseToken || !quoteToken) return;
+        const coin = universe.name;
+        quoteIndices.add(quoteToken.index);
+        const marketInfo = {
+          coin,
+          symbol: `${baseToken.name}/${quoteToken.name}`,
+          assetId: 1e4 + universe.index,
+          szDecimals: baseToken.szDecimals,
+          type: "spot",
+          baseToken,
+          quoteToken
+        };
+        const pairKey = `${baseToken.name}/${quoteToken.name}`.toUpperCase();
+        this.spotPairToMarket.set(pairKey, marketInfo);
+        this.coinToMarket.set(pairKey, marketInfo);
+        this.coinToMarket.set(coin, marketInfo);
+        const baseKey = baseToken.name.toUpperCase();
+        const existing = this.baseTokenToMarkets.get(baseKey) || [];
+        existing.push(marketInfo);
+        this.baseTokenToMarkets.set(baseKey, existing);
+      });
+      this.quoteAssets = Array.from(quoteIndices).map((idx) => this.spotMeta.tokens[idx].name).sort();
+    }
+  }
+  /**
+   * Load metadata for a specific HIP-3 DEX
+   * Also builds optimized lookups for this DEX's markets
+   */
+  async loadHip3Metadata(dexName) {
+    if (this.hip3DexsMeta.has(dexName)) return this.hip3DexsMeta.get(dexName);
+    try {
+      const [meta, contexts] = await this.infoClient.metaAndAssetCtxs({
+        dex: dexName
+      });
+      let dexIndex = this.dexNameToIndex.get(dexName.toLowerCase());
+      if (dexIndex === void 0) {
+        dexIndex = this.perpDexs.findIndex(
+          (d) => d && d.name.toLowerCase() === dexName.toLowerCase()
+        );
+      }
+      if (dexIndex === -1 || dexIndex === void 0) {
+        throw new Error(`DEX ${dexName} not found`);
+      }
+      const dex = this.perpDexs[dexIndex];
+      const collateralTokenIndex = meta.collateralToken ?? 0;
+      const spotMetaTokens = this.spotMeta?.tokens;
+      const collateralTokenSymbol = spotMetaTokens?.[collateralTokenIndex]?.name ?? "USDC";
+      const dexInfo = {
+        meta,
+        assetContext: contexts,
+        collateralTokenSymbol,
+        dexFullName: dex?.full_name ?? dexName,
+        dexName: dex?.name ?? dexName,
+        dexIndex
+      };
+      this.hip3DexsMeta.set(dexName, dexInfo);
+      this.buildHip3MarketsForDex(dexName, dexInfo);
+      return dexInfo;
+    } catch (error) {
+      console.error(`Failed to load HIP-3 metadata for ${dexName}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Build optimized lookups for HIP-3 markets of a specific DEX
+   */
+  buildHip3MarketsForDex(dexName, dexInfo) {
+    dexInfo.meta.universe.forEach((market, index) => {
+      const symbol = market.name;
+      const marketInfo = {
+        coin: symbol,
+        symbol,
+        assetId: 1e5 + dexInfo.dexIndex * 1e4 + index,
+        szDecimals: market.szDecimals,
+        type: "hip3",
+        maxLeverage: market.maxLeverage,
+        dexName,
+        dexIndex: dexInfo.dexIndex
+      };
+      this.coinToMarket.set(symbol, marketInfo);
+      this.hip3SymbolToMarket.set(symbol, marketInfo);
+    });
+  }
+  /**
+   * Ensure metadata is loaded (for lazy init)
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  /**
+   * Get market information by symbol
+   * Optimized: O(1) direct map lookup for most cases
+   * Lazily initialize hip-3 metadata if not already initialized
+   *
+   * @param symbol - Market symbol (e.g., "BTC", "PURR/USDC", "vntls:ABC")
+   * @param quoteAsset - Quote asset for spot markets (default: "USDC")
+   * @returns Market information or null if not found
+   */
+  async getMarketBySymbolAsync(symbol, quoteAsset = "USDC") {
+    await this.ensureInitialized();
+    if (symbol.includes(":")) {
+      return this.getHip3Market(symbol);
+    }
+    let lookupKey = symbol.toUpperCase();
+    if (!symbol.includes("/") && !symbol.includes("@")) {
+      const perpsMarket = this.coinToMarket.get(lookupKey);
+      if (perpsMarket?.type === "perps") {
+        return perpsMarket;
+      }
+      lookupKey = `${symbol}/${quoteAsset}`.toUpperCase();
+    }
+    return this.coinToMarket.get(lookupKey) || null;
+  }
+  getMarketByCoin(coin) {
+    return this.coinToMarket.get(coin) || null;
+  }
+  /**
+   * Get perpetuals market information
+   * Optimized: O(1) map lookup instead of O(n) array search
+   */
+  getPerpsMarket(symbol) {
+    if (!this.perpsMeta) return null;
+    if (isHip3Symbol(symbol)) {
+      const [dexName, coinName] = symbol.split(":");
+      if (!dexName || !coinName) return null;
+      let cachedMarket = this.hip3SymbolToMarket.get(symbol);
+      return cachedMarket || null;
+    }
+    const index = this.perpsSymbolToIndex.get(symbol.toUpperCase());
+    if (index === void 0) return null;
+    const market = this.perpsMeta.universe[index];
+    return {
+      coin: symbol,
+      symbol: market.name,
+      assetId: index,
+      // Perps asset ID is just the index
+      szDecimals: market.szDecimals,
+      type: "perps",
+      maxLeverage: market.maxLeverage
+    };
+  }
+  /**
+   * Get spot market information
+   * Optimized: O(1) map lookup instead of O(n) array searches
+   *
+   * @param baseSymbol - Base token symbol (e.g., "PURR", "UHYPE")
+   * @param quoteSymbol - Quote token symbol (default: "USDC")
+   */
+  getSpotMarket(baseSymbol, quoteSymbol = "USDC") {
+    if (!this.spotMeta) return null;
+    const pairKey = `${baseSymbol}/${quoteSymbol}`.toUpperCase();
+    const market = this.spotPairToMarket.get(pairKey);
+    return market || null;
+  }
+  /**
+   * Get HIP-3 market information
+   * Optimized: O(1) map lookup after DEX metadata is loaded
+   *
+   * @param symbol - HIP-3 market symbol (format: "dex:coin")
+   */
+  async getHip3Market(symbol) {
+    const [dexName, coinName] = symbol.split(":");
+    if (!dexName || !coinName) return null;
+    let cachedMarket = this.hip3SymbolToMarket.get(symbol);
+    if (cachedMarket) return cachedMarket;
+    const dexMeta = this.hip3DexsMeta.get(dexName);
+    if (!dexMeta && this.config.lazyInit) {
+      await this.loadHip3Metadata(dexName);
+      cachedMarket = this.hip3SymbolToMarket.get(symbol);
+      return cachedMarket || null;
+    }
+    return null;
+  }
+  async getHip3Dex(dexName) {
+    await this.ensureInitialized();
+    let dexInfo = this.hip3DexsMeta.get(dexName) ?? null;
+    if (this.config.lazyInit && !dexInfo) {
+      dexInfo = await this.loadHip3Metadata(dexName);
+    }
+    return dexInfo;
+  }
+  /**
+   * Get all available markets for a base token
+   * Optimized: O(1) map lookup instead of O(n) filter + map
+   * Useful for showing all quote asset options
+   */
+  getAllMarketsForBase(baseSymbol) {
+    if (!this.spotMeta) return [];
+    const baseKey = baseSymbol.toUpperCase();
+    return this.baseTokenToMarkets.get(baseKey) || [];
+  }
+  /**
+   * Get spot token information
+   * Optimized: O(1) map lookup instead of O(n) array search
+   */
+  getSpotTokenInfo(tokenSymbol) {
+    if (!this.spotMeta) return null;
+    const tokenIndex = this.spotTokenNameToIndex.get(tokenSymbol.toUpperCase());
+    if (tokenIndex === void 0) return null;
+    const token = this.spotMeta.tokens[tokenIndex];
+    return {
+      name: token.name,
+      index: token.index,
+      szDecimals: token.szDecimals,
+      weiDecimals: token.weiDecimals,
+      tokenId: token.tokenId
+    };
+  }
+  /**
+   * Get all available quote assets
+   * Optimized: O(1) pre-computed array instead of O(n) computation
+   */
+  getAvailableQuoteAssets() {
+    return this.quoteAssets;
+  }
+  /**
+   * Get raw metadata (for advanced use cases)
+   */
+  getRawMetadata() {
+    return {
+      spotMeta: this.spotMeta,
+      perpsMeta: this.perpsMeta,
+      perpDexs: this.perpDexs,
+      hip3DexsMeta: Object.fromEntries(this.hip3DexsMeta)
+    };
+  }
+  /**
+   * Get network configuration
+   */
+  getNetworkInfo() {
+    return {
+      isTestnet: this.isTestnet,
+      useStaticFallback: this.config.useStaticFallback,
+      initialized: this.initialized
+    };
+  }
+};
+
+// lib/utils/formatter.ts
+import { Decimal } from "decimal.js";
+var formatPriceAndSize = ({
+  px,
+  sz,
+  szDecimals,
+  isSpot
+}) => {
+  const priceDecimals = getPriceDecimals(px, szDecimals, isSpot);
+  const price = new Decimal(px).toDP(priceDecimals).toNumber();
+  const size = new Decimal(sz).toDP(szDecimals, Decimal.ROUND_DOWN).toNumber();
+  return {
+    price,
+    size
+  };
+};
+var formatPriceForOrder = ({
+  px,
+  szDecimals,
+  isSpot
+}) => {
+  const priceDecimals = getPriceDecimals(px, szDecimals, isSpot);
+  const price = new Decimal(px).toDP(priceDecimals).toNumber();
+  return price;
+};
+var formatSizeForOrder = ({
+  sz,
+  szDecimals
+}) => {
+  return new Decimal(sz).toDP(szDecimals, Decimal.ROUND_DOWN).toNumber();
+};
+function getPriceDecimals(price, szDecimals, isSpot) {
+  const baseDecimals = isSpot ? 8 : 6;
+  const maxDP = Math.max(baseDecimals - szDecimals, 0);
+  const maxSigFigs = 5;
+  let minDecimals;
+  if (price >= 1e5) {
+    minDecimals = 0;
+  } else {
+    const exp = Math.floor(Math.log10(price));
+    const dp = Math.max(maxSigFigs - exp - 1, 0);
+    minDecimals = Math.min(dp, maxDP);
+  }
+  return minDecimals;
+}
+export {
+  CloidClientCode,
+  CloidClientCodeNameById,
+  MetadataClient,
+  PUP_TOKEN_ADDRESS,
+  PUP_TOKEN_THRESHOLDS,
+  TARGET_APPROVED_MAX_BUILDER_FEE,
+  TARGET_APPROVED_MAX_BUILDER_FEE_PERCENT,
+  TESTNET_USDC_SPOT_TOKEN,
+  USDC_SPOT_TOKEN,
+  WidgetType,
+  WidgetTypeById,
+  XP_BOOST_PERCENTAGES,
+  buildCloid,
+  calculateBoostPercentage,
+  calculateTotalPupAmount,
+  decodeSlug,
+  encodeSlug,
+  formatPriceAndSize,
+  formatPriceForOrder,
+  formatSizeForOrder,
+  getApprovalAmount,
+  getClientCodeNameById,
+  getCloid,
+  getNextTierInfo,
+  getPriceDecimals,
+  getWidgetTypeById,
+  isBasedCloid,
+  isClientCode,
+  isMiniAppCloid,
+  isMiniAppTriggeredCloid,
+  isTenantCloid,
+  isTrackingIdCloid,
+  isWidgetType,
+  normaliseSlug,
+  normaliseTrackingId,
+  normalizeAirdropAmount,
+  parseCloid
+};