@basedone/core 0.0.1 → 0.0.7

package/lib/pup/calculator.ts

@@ -0,0 +1,221 @@
+/**
+ * PUP Token Calculation Logic
+ * Pure functions for calculating PUP amounts and boost percentages
+ */
+
+import {
+  UpheavalPosition,
+  PUP_TOKEN_ADDRESS,
+  PUP_TOKEN_THRESHOLDS,
+  XP_BOOST_PERCENTAGES,
+} from './types';
+
+/**
+ * Calculate total PUP amount from all positions
+ * @param positions Array of Upheaval positions
+ * @returns Total PUP token amount
+ */
+export function calculateTotalPupAmount(positions: UpheavalPosition[]): number {
+  let totalPupAmount = 0;
+  const pupAddress = PUP_TOKEN_ADDRESS.toLowerCase();
+
+  for (const position of positions) {
+    try {
+      if (position.version === 'erc20' && position.pair === 'PUP') {
+        // Pure PUP position - amount is in wei (18 decimals)
+        const amount = parseFloat(position.amount) / 1e18;
+        totalPupAmount += amount;
+        console.log(`Found pure PUP position: ${amount} PUP`);
+      } 
+      else if (position.version === 'v3' && position.v3LPTokenInfo) {
+        // V3 LP position - check if PUP is token0 or token1
+        const { token0, token1 } = position.v3LPTokenInfo;
+        
+        if (token0.address.toLowerCase() === pupAddress || token0.symbol === 'PUP') {
+          // PUP is token0 - amount is already in human-readable format
+          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') {
+          // PUP is token1 - amount is already in human-readable format
+          totalPupAmount += token1.amount;
+          console.log(`Found V3 LP position with PUP as token1: ${token1.amount} PUP`);
+        }
+      } 
+      // V2 LP positions excluded for security (can't verify if it's real PUP)
+      // As noted: "Someone can just create another PUP ERC20 token and pair it"
+    } catch (error) {
+      console.error(`Error processing position ${position.pair}:`, error);
+    }
+  }
+
+  console.log(`Total PUP amount calculated: ${totalPupAmount}`);
+  return totalPupAmount;
+}
+
+/**
+ * Calculate XP boost percentage based on PUP holdings
+ * @param pupTokenAmount Current PUP token holdings
+ * @param normalizedAirDropAmount Normalized airdrop amount (divided by 1e18)
+ * @param isAirdropRecipient Whether user received an airdrop
+ * @returns Boost percentage (0, 25, 50, or 60)
+ */
+export function calculateBoostPercentage(
+  pupTokenAmount: number,
+  normalizedAirDropAmount: number,
+  isAirdropRecipient: boolean
+): number {
+  if (isAirdropRecipient && normalizedAirDropAmount > 0) {
+    // Airdrop recipients: boost based on percentage of airdrop retained
+    const retentionRatio = pupTokenAmount / normalizedAirDropAmount;
+    
+    if (retentionRatio >= PUP_TOKEN_THRESHOLDS.AIRDROP_110_PERCENT) {
+      return XP_BOOST_PERCENTAGES.TIER_3; // 60%
+    }
+    if (retentionRatio >= PUP_TOKEN_THRESHOLDS.AIRDROP_70_PERCENT) {
+      return XP_BOOST_PERCENTAGES.TIER_2; // 50%
+    }
+    if (retentionRatio >= PUP_TOKEN_THRESHOLDS.AIRDROP_35_PERCENT) {
+      return XP_BOOST_PERCENTAGES.TIER_1; // 25%
+    }
+    return XP_BOOST_PERCENTAGES.NO_BOOST;
+  } else {
+    // Non-airdrop recipients: need 2M+ PUP tokens for 25% boost
+    if (pupTokenAmount >= PUP_TOKEN_THRESHOLDS.NON_AIRDROP_TOKENS) {
+      return XP_BOOST_PERCENTAGES.TIER_1; // 25%
+    }
+    return XP_BOOST_PERCENTAGES.NO_BOOST;
+  }
+}
+
+/**
+ * Normalize airdrop amount from BigInt or Prisma Decimal
+ * @param amount Airdrop amount from database
+ * @returns Normalized amount as number
+ */
+export function normalizeAirdropAmount(
+  amount: bigint | { div: (divisor: number) => { toNumber: () => number } } | null | undefined
+): number {
+  if (!amount) return 0;
+  
+  if (typeof amount === 'bigint') {
+    // Direct BigInt
+    return Number(amount) / 1e18;
+  } else if (amount && typeof amount.div === 'function') {
+    // Prisma Decimal type
+    return amount.div(1e18).toNumber();
+  }
+  
+  return 0;
+}
+
+/**
+ * Get information about the next tier and amount needed to reach it
+ * @param pupTokenAmount Current PUP token holdings
+ * @param normalizedAirDropAmount Normalized airdrop amount (divided by 1e18)
+ * @param isAirdropRecipient Whether user received an airdrop
+ * @returns Information about current tier and progression to next tier
+ */
+export function getNextTierInfo(
+  pupTokenAmount: number,
+  normalizedAirDropAmount: number,
+  isAirdropRecipient: boolean
+): {
+  currentTier: number;
+  currentBoost: number;
+  nextTier: number | null;
+  nextBoost: number | null;
+  amountToNextTier: number | null;
+  nextTierThreshold: number | null;
+  progressPercentage: number;
+} {
+  const currentBoost = calculateBoostPercentage(pupTokenAmount, normalizedAirDropAmount, isAirdropRecipient);
+  
+  // Determine current tier
+  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) {
+    // Airdrop recipients: calculate based on percentage of airdrop
+    const retentionRatio = pupTokenAmount / normalizedAirDropAmount;
+    
+    if (currentTier === 0) {
+      // Currently no boost, need 35% of airdrop for Tier 1
+      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) {
+      // Currently 25% boost, need 70% of airdrop for Tier 2
+      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) {
+      // Currently 50% boost, need 110% of airdrop for Tier 3
+      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 {
+      // Already at max tier (60% boost)
+      return {
+        currentTier: 3,
+        currentBoost: XP_BOOST_PERCENTAGES.TIER_3,
+        nextTier: null,
+        nextBoost: null,
+        amountToNextTier: null,
+        nextTierThreshold: null,
+        progressPercentage: 100
+      };
+    }
+  } else {
+    // Non-airdrop recipients: only one tier available (25% at 2M tokens)
+    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 {
+      // Already at max tier for non-airdrop (25% boost)
+      return {
+        currentTier: 1,
+        currentBoost: XP_BOOST_PERCENTAGES.TIER_1,
+        nextTier: null,
+        nextBoost: null,
+        amountToNextTier: null,
+        nextTierThreshold: null,
+        progressPercentage: 100
+      };
+    }
+  }
+}

package/lib/pup/index.ts

@@ -0,0 +1,9 @@
+/**
+ * PUP Module Exports
+ */
+
+// Export all types
+export * from './types';
+
+// Export calculator functions
+export * from './calculator';

package/lib/pup/types.ts

@@ -0,0 +1,94 @@
+/**
+ * PUP Token Eligibility Types and Constants
+ */
+
+// Upheaval API Types
+export interface V3LPTokenInfo {
+  token0: {
+    price: number;
+    value: number;
+    amount: number;
+    symbol: string;
+    address: string;
+  };
+  token1: {
+    price: number;
+    value: number;
+    amount: number;
+    symbol: string;
+    address: string;
+  };
+}
+
+export interface UpheavalPosition {
+  pair: string;
+  pool: string;
+  value: number;
+  amount: string;
+  version: 'erc20' | 'v3' | 'v2';
+  v3LPTokenInfo?: V3LPTokenInfo;
+}
+
+export interface UpheavalSnapshot {
+  id: string;
+  user_address: string;
+  total_lp_value: number;
+  position_count: number;
+  metadata: {
+    positions: UpheavalPosition[];
+    snapshot_date: string;
+  };
+  created_at: string;
+  userId: string | null;
+}
+
+export interface UpheavalApiResponse {
+  success: boolean;
+  snapshot: {
+    timestamp: string;
+    user_count: number;
+  };
+  data: UpheavalSnapshot[];
+  cached_at: string;
+  filtered_by: string;
+}
+
+// PUP Eligibility Types
+export interface PupEligibilityResult {
+  isEligible: boolean;
+  boostPct: number;
+  isAirdropRecipient: boolean;
+  pupTokenAmount?: number;
+  totalLpValue?: number;
+  // Tier progression info
+  currentTier?: number;
+  currentBoost?: number;
+  nextTier?: number | null;
+  nextBoost?: number | null;
+  amountToNextTier?: number | null;
+  nextTierThreshold?: number | null;
+  progressPercentage?: number;
+}
+
+// Airdrop Allocation Data (from database)
+export interface AirdropAllocationData {
+  amount: bigint | { div: (divisor: number) => { toNumber: () => number } };
+  walletAddress: string;
+}
+
+// Constants
+export const PUP_TOKEN_ADDRESS = '0x876e7f2f30935118a654fc0e1f807afc49efe500';
+
+export const PUP_TOKEN_THRESHOLDS = {
+  AIRDROP_70_PERCENT: 0.7,
+  AIRDROP_35_PERCENT: 0.35,
+  AIRDROP_110_PERCENT: 1.1,
+  NON_AIRDROP_TOKENS: 2000000,
+} as const;
+
+export const XP_BOOST_PERCENTAGES = {
+  NO_BOOST: 0,
+  TIER_1: 25,
+  TIER_2: 50,
+  TIER_3: 60,
+} as const;

package/lib/utils/formatter.ts

@@ -0,0 +1,97 @@
+import { Decimal } from "decimal.js";
+
+export const formatPriceAndSize = ({
+  px,
+  sz,
+  szDecimals,
+  isSpot,
+}: {
+  px: number;
+  sz: number;
+  szDecimals: number;
+  isSpot: boolean;
+}) => {
+  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,
+  };
+};
+
+/**
+ * Formats price for order placement following Hyperliquid rules
+ * - Rounded to priceDecimals of the asset
+ * @param px - The price to format
+ * @param priceDecimals - Price decimals for the asset
+ * @returns Formatted price as number (rounded to priceDecimals if exceeds)
+ */
+export const formatPriceForOrder = ({
+  px,
+  szDecimals,
+  isSpot,
+}: {
+  px: number;
+  szDecimals: number;
+  isSpot: boolean;
+}) => {
+  const priceDecimals = getPriceDecimals(px, szDecimals, isSpot);
+  const price = new Decimal(px).toDP(priceDecimals).toNumber();
+
+  return price;
+};
+
+/**
+ * Formats size for order placement following Hyperliquid rules
+ * - Rounded to szDecimals of the asset
+ * @param sz - The size to format
+ * @param szDecimals - Size decimals for the asset
+ * @returns Formatted size as number (rounded down to szDecimals if exceeds)
+ */
+export const formatSizeForOrder = ({
+  sz,
+  szDecimals,
+}: {
+  sz: number;
+  szDecimals: number;
+}) => {
+  return new Decimal(sz).toDP(szDecimals, Decimal.ROUND_DOWN).toNumber();
+};
+
+/**
+ * Get minimum price decimals for tick size calculations
+ * Uses the same logic as internal price formatting
+ *
+ * @param price - The current price
+ * @param szDecimals - Size decimals for the asset
+ * @param isSpot - Whether this is a spot market (true) or perp market (false)
+ * @returns Minimum decimal places for price display
+ *
+ * @example
+ * getPriceDecimals(1234.5, 0, false)    // 1 (PERP market)
+ * getPriceDecimals(0.00123, 0, true)    // 6 (SPOT market)
+ * getPriceDecimals(100000, 0, false)    // 0 (large prices)
+ */
+export function getPriceDecimals(
+  price: number,
+  szDecimals: number,
+  isSpot: boolean,
+): number {
+  const baseDecimals = isSpot ? 8 : 6; // SPOT: 8, PERP: 6
+  const maxDP = Math.max(baseDecimals - szDecimals, 0);
+  const maxSigFigs = 5;
+
+  let minDecimals: number;
+  if (price >= 100000) {
+    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;
+}

package/package.json

@@ -1,30 +1,34 @@
 {
   "name": "@basedone/core",
-  "version": "0.0.1",
+  "version": "0.0.7",
   "description": "Core utilities for Based One",
   "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    }
-  },
+  "source": "./index.ts",
   "files": [
-    "dist"
+    "dist",
+    "index.ts",
+    "lib"
   ],
+  "scripts": {
+    "build": "tsup index.ts --format cjs,esm --dts",
+    "dev": "tsup index.ts --format cjs,esm --dts --watch",
+    "test": "vitest",
+    "update-meta": "tsx scripts/update-static-meta.ts"
+  },
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "dependencies": {
-    "vitest": "^3.2.4"
-  },
+  "packageManager": "pnpm@10.10.0",
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.0.0",
+    "vitest": "^3.2.4"
   },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest"
+  "dependencies": {
+    "@nktkas/hyperliquid": "^0.24.3",
+    "decimal.js": "^10.6.0"
   }
-}
+}