@numen-crypto/contract 0.1.0

package/dist/index.js

@@ -0,0 +1,683 @@
+import { z } from 'zod';
+
+// src/constants/error-codes.ts
+var ERROR_CODE = {
+  // generic
+  VALIDATION: "VALIDATION",
+  NOT_FOUND: "NOT_FOUND",
+  CONFLICT: "CONFLICT",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  RATE_LIMITED: "RATE_LIMITED",
+  INTERNAL: "INTERNAL",
+  // auth
+  EMAIL_TAKEN: "EMAIL_TAKEN",
+  REFERRER_NOT_FOUND: "REFERRER_NOT_FOUND",
+  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+  SESSION_INVALID: "SESSION_INVALID",
+  SESSION_EXPIRED: "SESSION_EXPIRED",
+  TOTP_REQUIRED: "TOTP_REQUIRED",
+  TOTP_ALREADY_ENABLED: "TOTP_ALREADY_ENABLED",
+  // wallet / purchase / withdrawal (reserved for next slices)
+  INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE",
+  PURCHASE_LIMIT_EXCEEDED: "PURCHASE_LIMIT_EXCEEDED",
+  SALE_PHASE_INACTIVE: "SALE_PHASE_INACTIVE",
+  WITHDRAWAL_COOLOFF: "WITHDRAWAL_COOLOFF",
+  // bonus
+  BONUS_ALREADY_CLAIMED: "BONUS_ALREADY_CLAIMED",
+  // account linking
+  LINK_PROVIDER_DISABLED: "LINK_PROVIDER_DISABLED",
+  LINK_VERIFICATION_FAILED: "LINK_VERIFICATION_FAILED",
+  LINK_ALREADY_USED: "LINK_ALREADY_USED"
+};
+var MONEY_REGEX = /^-?\d+(\.\d{1,18})?$/;
+var MoneyStringSchema = z.string().regex(MONEY_REGEX, "invalid money string (max 18 fractional digits)");
+var PositiveMoneyStringSchema = MoneyStringSchema.refine(
+  (v) => !v.startsWith("-") && Number.parseFloat(v) > 0,
+  "must be positive"
+);
+var UuidSchema = z.string().uuid();
+var ErrorResponseSchema = z.object({
+  error: z.object({
+    code: z.string(),
+    message: z.string()
+  }),
+  requestId: z.string().optional()
+});
+var PaginationQuerySchema = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).default(20)
+});
+function PaginatedSchema(item) {
+  return z.object({
+    items: z.array(item),
+    total: z.number().int().nonnegative(),
+    page: z.number().int().min(1),
+    pageSize: z.number().int().min(1)
+  });
+}
+var UserStatusSchema = z.enum(["pending", "active", "suspended", "deleted"]);
+var UserProfileSchema = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  displayName: z.string().nullable(),
+  avatarUrl: z.string().url().nullable(),
+  referrerId: z.string().uuid().nullable(),
+  rankId: z.string().uuid().nullable(),
+  status: UserStatusSchema,
+  totpEnabled: z.boolean(),
+  createdAt: z.string().datetime()
+});
+var SessionInfoSchema = z.object({
+  id: z.string(),
+  ip: z.string().nullable(),
+  userAgent: z.string().nullable(),
+  createdAt: z.string().datetime(),
+  lastSeenAt: z.string().datetime(),
+  current: z.boolean()
+});
+var ASSET_SYMBOLS = ["NMN", "USDT", "BTC", "ETH", "BNB", "TRX", "SOL"];
+var AssetSymbolSchema = z.enum(ASSET_SYMBOLS);
+var DEPOSITABLE_ASSETS = ["USDT", "BTC", "ETH", "BNB", "TRX", "SOL"];
+var DepositableAssetSchema = z.enum(DEPOSITABLE_ASSETS);
+var TOKEN_ASSET = "NMN";
+var FUNDING_ASSET = "USDT";
+var AssetBalanceSchema = z.object({
+  asset: AssetSymbolSchema,
+  name: z.string(),
+  networks: z.array(z.string()),
+  depositable: z.boolean(),
+  available: MoneyStringSchema,
+  locked: MoneyStringSchema,
+  usdValue: MoneyStringSchema,
+  isZero: z.boolean()
+});
+var WalletOverviewSchema = z.object({
+  totalUsd: MoneyStringSchema,
+  assets: z.array(AssetBalanceSchema)
+});
+var TransactionTypeSchema = z.enum([
+  "DEPOSIT",
+  "WITHDRAWAL",
+  "BUY",
+  "SELL",
+  "COMMISSION",
+  "BONUS",
+  "ADJUSTMENT"
+]);
+var TransactionStatusSchema = z.enum([
+  "PENDING",
+  "PROCESSING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED"
+]);
+var TransactionSchema = z.object({
+  id: z.string().uuid(),
+  type: TransactionTypeSchema,
+  asset: AssetSymbolSchema,
+  amount: MoneyStringSchema,
+  status: TransactionStatusSchema,
+  reference: z.string().nullable(),
+  createdAt: z.string().datetime()
+});
+var DepositAddressSchema = z.object({
+  asset: DepositableAssetSchema,
+  network: z.string(),
+  address: z.string(),
+  minAmount: MoneyStringSchema,
+  confirmations: z.number().int().nonnegative()
+});
+var PartnerLevelSchema = z.object({
+  level: z.number().int().min(1).max(10),
+  partners: z.number().int().nonnegative()
+});
+var PartnersOverviewSchema = z.object({
+  referralCode: z.string(),
+  totalPartners: z.number().int().nonnegative(),
+  directPartners: z.number().int().nonnegative(),
+  networkTurnover: MoneyStringSchema,
+  affiliateIncome: MoneyStringSchema,
+  levels: z.array(PartnerLevelSchema)
+});
+var RankDefSchema = z.object({
+  name: z.string(),
+  order: z.number().int().nonnegative(),
+  minTurnover: MoneyStringSchema
+});
+var UserRankSchema = z.object({
+  name: z.string(),
+  order: z.number().int().nonnegative(),
+  minTurnover: MoneyStringSchema,
+  nextName: z.string().nullable(),
+  nextMinTurnover: MoneyStringSchema.nullable(),
+  progressPct: z.string()
+});
+var EarningsOverviewSchema = z.object({
+  tokenBalance: MoneyStringSchema,
+  tokenPrice: MoneyStringSchema,
+  tokenValueUsd: MoneyStringSchema,
+  affiliateIncome: MoneyStringSchema,
+  networkTurnover: MoneyStringSchema,
+  rank: UserRankSchema
+});
+var UserSettingsSchema = z.object({
+  notifyTrades: z.boolean(),
+  notifyByEmail: z.boolean(),
+  withdrawalEmailConfirm: z.boolean()
+});
+var DailyBonusDaySchema = z.object({
+  dayIndex: z.number().int().min(1),
+  rewardNmn: MoneyStringSchema,
+  surprise: z.boolean()
+});
+var DailyBonusStatusSchema = z.object({
+  currentStreak: z.number().int().nonnegative(),
+  cycleLength: z.number().int().positive(),
+  claimableToday: z.boolean(),
+  todayDayIndex: z.number().int().min(1),
+  nextRewardNmn: MoneyStringSchema,
+  days: z.array(DailyBonusDaySchema)
+});
+var DailyBonusClaimResultSchema = z.object({
+  claimed: z.boolean(),
+  dayIndex: z.number().int().min(1),
+  rewardNmn: MoneyStringSchema,
+  currentStreak: z.number().int().positive()
+});
+var NotificationTypeSchema = z.enum([
+  "TRADE_EXECUTED",
+  "DEPOSIT_CREDITED",
+  "COMMISSION_ACCRUED",
+  "WITHDRAWAL_SENT",
+  "BONUS_CLAIMED",
+  "SYSTEM"
+]);
+var NotificationSchema = z.object({
+  id: z.string().uuid(),
+  type: NotificationTypeSchema,
+  title: z.string(),
+  body: z.string(),
+  read: z.boolean(),
+  meta: z.record(z.unknown()).nullable(),
+  createdAt: z.string().datetime()
+});
+var LeaderboardPeriodSchema = z.enum(["week", "month", "year", "all"]);
+var LeaderboardEntrySchema = z.object({
+  rank: z.number().int().positive(),
+  userId: z.string().uuid(),
+  displayName: z.string(),
+  line: z.number().int().min(1).max(10).nullable(),
+  partners: z.number().int().nonnegative(),
+  turnoverUsd: MoneyStringSchema,
+  changePct: z.number(),
+  isSelf: z.boolean()
+});
+var LeaderboardSchema = z.object({
+  period: LeaderboardPeriodSchema,
+  items: z.array(LeaderboardEntrySchema),
+  self: LeaderboardEntrySchema.nullable()
+});
+var LinkProviderSchema = z.enum(["telegram", "google"]);
+var LinkedAccountSchema = z.object({
+  provider: LinkProviderSchema,
+  providerUserId: z.string(),
+  displayName: z.string().nullable(),
+  linkedAt: z.string().datetime()
+});
+var IncomePeriodSchema = z.enum(["week", "month", "year", "all"]);
+var PartnerAccrualSchema = z.object({
+  id: z.string().uuid(),
+  level: z.number().int().min(1).max(10),
+  sourceUserId: z.string().uuid(),
+  sourceName: z.string(),
+  amountUsd: MoneyStringSchema,
+  createdAt: z.string().datetime()
+});
+var MonthlyPricePointSchema = z.object({
+  month: z.string(),
+  fromPrice: MoneyStringSchema,
+  toPrice: MoneyStringSchema,
+  holdingGrowthUsd: MoneyStringSchema
+});
+var IncomeOverviewSchema = z.object({
+  period: IncomePeriodSchema,
+  tokenGrowthIncomeUsd: MoneyStringSchema,
+  tokenGrowthPct: z.number(),
+  affiliateIncomeNmn: MoneyStringSchema,
+  affiliateIncomeUsd: MoneyStringSchema,
+  totalEarnedUsd: MoneyStringSchema,
+  partnerAccruals: z.array(PartnerAccrualSchema),
+  monthlyPrice: z.array(MonthlyPricePointSchema)
+});
+var WithdrawalStatusSchema = z.enum([
+  "AWAITING_CONFIRM",
+  "AWAITING_COOLOFF",
+  "QUEUED",
+  "SENT",
+  "CONFIRMED",
+  "FAILED",
+  "CANCELLED"
+]);
+var WithdrawalSchema = z.object({
+  id: z.string().uuid(),
+  asset: AssetSymbolSchema,
+  amount: MoneyStringSchema,
+  address: z.string(),
+  status: WithdrawalStatusSchema,
+  createdAt: z.string().datetime()
+});
+var TokenPriceSchema = z.object({
+  price: MoneyStringSchema,
+  change24hPct: z.string(),
+  tradeIndex: z.number().int().nonnegative(),
+  updatedAt: z.string().datetime()
+});
+var ChartPeriodSchema = z.enum(["day", "week", "month", "year"]);
+var ChartPointSchema = z.object({
+  t: z.string().datetime(),
+  price: MoneyStringSchema
+});
+var SwapSideSchema = z.enum(["BUY", "SELL"]);
+var TradeResultSchema = z.object({
+  tradeId: z.string().uuid(),
+  side: SwapSideSchema,
+  usdtAmount: MoneyStringSchema,
+  nmnAmount: MoneyStringSchema,
+  price: MoneyStringSchema,
+  feeUsdt: MoneyStringSchema
+});
+
+// src/commands/command.types.ts
+function endpoint(method, path, summary) {
+  return { method, path, summary };
+}
+var RegisterCommand;
+((RegisterCommand2) => {
+  RegisterCommand2.endpointDetails = endpoint("POST", "/auth/register", "Register a new user");
+  RegisterCommand2.RequestSchema = z.object({
+    email: z.string().email().max(254),
+    password: z.string().min(12).max(128),
+    referralCode: z.string().min(4).max(64).optional()
+  });
+  RegisterCommand2.ResponseSchema = z.object({
+    userId: z.string().uuid()
+  });
+})(RegisterCommand || (RegisterCommand = {}));
+var LoginCommand;
+((LoginCommand2) => {
+  LoginCommand2.endpointDetails = endpoint("POST", "/auth/login", "Login with email and password");
+  LoginCommand2.RequestSchema = z.object({
+    email: z.string().email().max(254),
+    password: z.string().min(1).max(128),
+    totp: z.string().regex(/^\d{6}$/).optional()
+  });
+  LoginCommand2.ResponseSchema = z.object({
+    user: UserProfileSchema
+  });
+})(LoginCommand || (LoginCommand = {}));
+var LogoutCommand;
+((LogoutCommand2) => {
+  LogoutCommand2.endpointDetails = endpoint("POST", "/auth/logout", "Terminate the current session");
+  LogoutCommand2.RequestSchema = z.object({
+    allDevices: z.boolean().optional().default(false)
+  });
+  LogoutCommand2.ResponseSchema = z.void();
+})(LogoutCommand || (LogoutCommand = {}));
+var MeCommand;
+((MeCommand2) => {
+  MeCommand2.endpointDetails = endpoint("GET", "/auth/me", "Get the current authenticated user");
+  MeCommand2.ResponseSchema = z.object({
+    user: UserProfileSchema
+  });
+})(MeCommand || (MeCommand = {}));
+var SetupTotpCommand;
+((SetupTotpCommand2) => {
+  SetupTotpCommand2.endpointDetails = endpoint("POST", "/auth/totp/setup", "Begin TOTP enrollment");
+  SetupTotpCommand2.ResponseSchema = z.object({
+    secret: z.string(),
+    otpauthUrl: z.string()
+  });
+})(SetupTotpCommand || (SetupTotpCommand = {}));
+var ConfirmTotpCommand;
+((ConfirmTotpCommand2) => {
+  ConfirmTotpCommand2.endpointDetails = endpoint("POST", "/auth/totp/confirm", "Confirm and enable TOTP");
+  ConfirmTotpCommand2.RequestSchema = z.object({
+    secret: z.string().min(16).max(128),
+    otp: z.string().regex(/^\d{6}$/)
+  });
+  ConfirmTotpCommand2.ResponseSchema = z.void();
+})(ConfirmTotpCommand || (ConfirmTotpCommand = {}));
+
+// src/commands/wallet/get-wallet.command.ts
+var GetWalletCommand;
+((GetWalletCommand2) => {
+  GetWalletCommand2.endpointDetails = endpoint("GET", "/wallet", "Get wallet overview with all asset balances");
+  GetWalletCommand2.ResponseSchema = WalletOverviewSchema;
+})(GetWalletCommand || (GetWalletCommand = {}));
+
+// src/commands/wallet/get-transactions.command.ts
+var GetTransactionsCommand;
+((GetTransactionsCommand2) => {
+  GetTransactionsCommand2.endpointDetails = endpoint("GET", "/wallet/transactions", "List the user transaction history");
+  GetTransactionsCommand2.QuerySchema = PaginationQuerySchema.extend({
+    type: TransactionTypeSchema.optional()
+  });
+  GetTransactionsCommand2.ResponseSchema = PaginatedSchema(TransactionSchema);
+})(GetTransactionsCommand || (GetTransactionsCommand = {}));
+var DepositAddressCommand;
+((DepositAddressCommand2) => {
+  DepositAddressCommand2.endpointDetails = endpoint(
+    "POST",
+    "/wallet/deposit-address",
+    "Get a deposit address for the given asset"
+  );
+  DepositAddressCommand2.RequestSchema = z.object({
+    asset: DepositableAssetSchema,
+    network: z.string().min(2).max(32)
+  });
+  DepositAddressCommand2.ResponseSchema = DepositAddressSchema;
+})(DepositAddressCommand || (DepositAddressCommand = {}));
+
+// src/commands/token/get-price.command.ts
+var GetTokenPriceCommand;
+((GetTokenPriceCommand2) => {
+  GetTokenPriceCommand2.endpointDetails = endpoint("GET", "/token/price", "Current NMN price and 24h change");
+  GetTokenPriceCommand2.ResponseSchema = TokenPriceSchema;
+})(GetTokenPriceCommand || (GetTokenPriceCommand = {}));
+var GetTokenChartCommand;
+((GetTokenChartCommand2) => {
+  GetTokenChartCommand2.endpointDetails = endpoint("GET", "/token/chart", "NMN price chart points for a period");
+  GetTokenChartCommand2.QuerySchema = z.object({
+    period: ChartPeriodSchema.default("day")
+  });
+  GetTokenChartCommand2.ResponseSchema = z.object({
+    period: ChartPeriodSchema,
+    points: z.array(ChartPointSchema)
+  });
+})(GetTokenChartCommand || (GetTokenChartCommand = {}));
+var SwapCommand;
+((SwapCommand2) => {
+  SwapCommand2.endpointDetails = endpoint("POST", "/swap", "Buy or sell NMN against USDT at the live price");
+  SwapCommand2.RequestSchema = z.object({
+    side: SwapSideSchema,
+    amount: PositiveMoneyStringSchema,
+    maxPrice: PositiveMoneyStringSchema.optional(),
+    idempotencyKey: z.string().min(8).max(128)
+  });
+  SwapCommand2.ResponseSchema = TradeResultSchema;
+})(SwapCommand || (SwapCommand = {}));
+
+// src/commands/partners/get-partners.command.ts
+var GetPartnersCommand;
+((GetPartnersCommand2) => {
+  GetPartnersCommand2.endpointDetails = endpoint("GET", "/partners", "Affiliate network overview with 10 levels");
+  GetPartnersCommand2.ResponseSchema = PartnersOverviewSchema;
+})(GetPartnersCommand || (GetPartnersCommand = {}));
+var GetRanksCommand;
+((GetRanksCommand2) => {
+  GetRanksCommand2.endpointDetails = endpoint("GET", "/ranks", "List all rank tiers");
+  GetRanksCommand2.ResponseSchema = z.object({
+    ranks: z.array(RankDefSchema)
+  });
+})(GetRanksCommand || (GetRanksCommand = {}));
+
+// src/commands/earnings/get-earnings.command.ts
+var GetEarningsCommand;
+((GetEarningsCommand2) => {
+  GetEarningsCommand2.endpointDetails = endpoint("GET", "/earnings", "Earnings overview: token growth + affiliate + rank");
+  GetEarningsCommand2.ResponseSchema = EarningsOverviewSchema;
+})(GetEarningsCommand || (GetEarningsCommand = {}));
+var RequestWithdrawalCommand;
+((RequestWithdrawalCommand2) => {
+  RequestWithdrawalCommand2.endpointDetails = endpoint("POST", "/withdrawals", "Request a withdrawal to an external address");
+  RequestWithdrawalCommand2.RequestSchema = z.object({
+    asset: DepositableAssetSchema,
+    amount: PositiveMoneyStringSchema,
+    address: z.string().min(8).max(256),
+    totp: z.string().regex(/^\d{6}$/).optional(),
+    idempotencyKey: z.string().min(8).max(128)
+  });
+  RequestWithdrawalCommand2.ResponseSchema = z.object({
+    withdrawalId: z.string().uuid(),
+    status: WithdrawalStatusSchema
+  });
+})(RequestWithdrawalCommand || (RequestWithdrawalCommand = {}));
+var ListWithdrawalsCommand;
+((ListWithdrawalsCommand2) => {
+  ListWithdrawalsCommand2.endpointDetails = endpoint("GET", "/withdrawals", "List the user withdrawals");
+  ListWithdrawalsCommand2.ResponseSchema = z.object({
+    items: z.array(WithdrawalSchema)
+  });
+})(ListWithdrawalsCommand || (ListWithdrawalsCommand = {}));
+var CancelWithdrawalCommand;
+((CancelWithdrawalCommand2) => {
+  CancelWithdrawalCommand2.endpointDetails = endpoint("POST", "/withdrawals/:id/cancel", "Cancel a pending withdrawal");
+  CancelWithdrawalCommand2.ResponseSchema = z.object({
+    status: WithdrawalStatusSchema
+  });
+})(CancelWithdrawalCommand || (CancelWithdrawalCommand = {}));
+var ConfirmWithdrawalCommand;
+((ConfirmWithdrawalCommand2) => {
+  ConfirmWithdrawalCommand2.endpointDetails = endpoint("POST", "/withdrawals/:id/confirm", "Confirm a withdrawal with the email token");
+  ConfirmWithdrawalCommand2.RequestSchema = z.object({
+    token: z.string().min(6).max(128)
+  });
+  ConfirmWithdrawalCommand2.ResponseSchema = z.object({
+    status: WithdrawalStatusSchema
+  });
+})(ConfirmWithdrawalCommand || (ConfirmWithdrawalCommand = {}));
+var AVATAR_CONTENT_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
+var AvatarContentTypeSchema = z.enum(AVATAR_CONTENT_TYPES);
+var RequestEmailChangeCommand;
+((RequestEmailChangeCommand2) => {
+  RequestEmailChangeCommand2.endpointDetails = endpoint("POST", "/settings/email/request", "Start an email change (sends a code)");
+  RequestEmailChangeCommand2.RequestSchema = z.object({
+    newEmail: z.string().email().max(254)
+  });
+  RequestEmailChangeCommand2.ResponseSchema = z.object({ sent: z.boolean() });
+})(RequestEmailChangeCommand || (RequestEmailChangeCommand = {}));
+var ConfirmEmailChangeCommand;
+((ConfirmEmailChangeCommand2) => {
+  ConfirmEmailChangeCommand2.endpointDetails = endpoint("POST", "/settings/email/confirm", "Confirm an email change with the code");
+  ConfirmEmailChangeCommand2.RequestSchema = z.object({
+    code: z.string().regex(/^\d{6}$/)
+  });
+  ConfirmEmailChangeCommand2.ResponseSchema = z.object({ email: z.string().email() });
+})(ConfirmEmailChangeCommand || (ConfirmEmailChangeCommand = {}));
+var DisableTotpCommand;
+((DisableTotpCommand2) => {
+  DisableTotpCommand2.endpointDetails = endpoint("POST", "/auth/totp/disable", "Disable TOTP two-factor auth");
+  DisableTotpCommand2.RequestSchema = z.object({
+    totp: z.string().regex(/^\d{6}$/)
+  });
+  DisableTotpCommand2.ResponseSchema = z.void();
+})(DisableTotpCommand || (DisableTotpCommand = {}));
+var UpdateProfileCommand;
+((UpdateProfileCommand2) => {
+  UpdateProfileCommand2.endpointDetails = endpoint("PATCH", "/settings/profile", "Update display name and avatar");
+  UpdateProfileCommand2.RequestSchema = z.object({
+    displayName: z.string().min(2).max(48).nullable().optional(),
+    avatarKey: z.string().max(256).nullable().optional()
+  }).refine((v) => v.displayName !== void 0 || v.avatarKey !== void 0, "no fields to update");
+  UpdateProfileCommand2.ResponseSchema = UserProfileSchema;
+})(UpdateProfileCommand || (UpdateProfileCommand = {}));
+var AvatarUploadUrlCommand;
+((AvatarUploadUrlCommand2) => {
+  AvatarUploadUrlCommand2.endpointDetails = endpoint("POST", "/settings/avatar/upload-url", "Get a presigned avatar upload URL");
+  AvatarUploadUrlCommand2.RequestSchema = z.object({
+    contentType: AvatarContentTypeSchema
+  });
+  AvatarUploadUrlCommand2.ResponseSchema = z.object({
+    key: z.string(),
+    uploadUrl: z.string().url(),
+    publicUrl: z.string().url(),
+    expiresInSec: z.number().int().positive(),
+    maxBytes: z.number().int().positive()
+  });
+})(AvatarUploadUrlCommand || (AvatarUploadUrlCommand = {}));
+var GetSettingsCommand;
+((GetSettingsCommand2) => {
+  GetSettingsCommand2.endpointDetails = endpoint("GET", "/settings", "Get user preferences");
+  GetSettingsCommand2.ResponseSchema = UserSettingsSchema;
+})(GetSettingsCommand || (GetSettingsCommand = {}));
+var UpdateSettingsCommand;
+((UpdateSettingsCommand2) => {
+  UpdateSettingsCommand2.endpointDetails = endpoint("PATCH", "/settings", "Update user preferences");
+  UpdateSettingsCommand2.RequestSchema = z.object({
+    notifyTrades: z.boolean().optional(),
+    notifyByEmail: z.boolean().optional(),
+    withdrawalEmailConfirm: z.boolean().optional()
+  }).refine((v) => Object.keys(v).length > 0, "no fields to update");
+  UpdateSettingsCommand2.ResponseSchema = UserSettingsSchema;
+})(UpdateSettingsCommand || (UpdateSettingsCommand = {}));
+
+// src/commands/bonus/bonus.command.ts
+var GetDailyBonusCommand;
+((GetDailyBonusCommand2) => {
+  GetDailyBonusCommand2.endpointDetails = endpoint("GET", "/bonus/daily", "Daily bonus status and current streak");
+  GetDailyBonusCommand2.ResponseSchema = DailyBonusStatusSchema;
+})(GetDailyBonusCommand || (GetDailyBonusCommand = {}));
+var ClaimDailyBonusCommand;
+((ClaimDailyBonusCommand2) => {
+  ClaimDailyBonusCommand2.endpointDetails = endpoint("POST", "/bonus/daily/claim", "Claim today's daily bonus");
+  ClaimDailyBonusCommand2.ResponseSchema = DailyBonusClaimResultSchema;
+})(ClaimDailyBonusCommand || (ClaimDailyBonusCommand = {}));
+var GetLeaderboardCommand;
+((GetLeaderboardCommand2) => {
+  GetLeaderboardCommand2.endpointDetails = endpoint("GET", "/leaderboard", "Top partners ranked by network turnover");
+  GetLeaderboardCommand2.QuerySchema = z.object({
+    period: LeaderboardPeriodSchema.default("month"),
+    limit: z.coerce.number().int().min(1).max(100).default(20)
+  });
+  GetLeaderboardCommand2.ResponseSchema = LeaderboardSchema;
+})(GetLeaderboardCommand || (GetLeaderboardCommand = {}));
+var GetIncomeCommand;
+((GetIncomeCommand2) => {
+  GetIncomeCommand2.endpointDetails = endpoint("GET", "/income", "Income overview: token growth + affiliate earnings");
+  GetIncomeCommand2.QuerySchema = z.object({
+    period: IncomePeriodSchema.default("month")
+  });
+  GetIncomeCommand2.ResponseSchema = IncomeOverviewSchema;
+})(GetIncomeCommand || (GetIncomeCommand = {}));
+var ListNotificationsCommand;
+((ListNotificationsCommand2) => {
+  ListNotificationsCommand2.endpointDetails = endpoint("GET", "/notifications", "List in-app notifications");
+  ListNotificationsCommand2.QuerySchema = PaginationQuerySchema.extend({
+    unreadOnly: z.union([z.boolean(), z.string()]).optional().transform((v) => v === true || v === "true" || v === "1")
+  });
+  ListNotificationsCommand2.ResponseSchema = PaginatedSchema(NotificationSchema).extend({
+    unread: z.number().int().nonnegative()
+  });
+})(ListNotificationsCommand || (ListNotificationsCommand = {}));
+var MarkNotificationsReadCommand;
+((MarkNotificationsReadCommand2) => {
+  MarkNotificationsReadCommand2.endpointDetails = endpoint("POST", "/notifications/read", "Mark notifications as read");
+  MarkNotificationsReadCommand2.RequestSchema = z.object({
+    ids: z.array(z.string().uuid()).max(500).optional(),
+    all: z.boolean().optional()
+  });
+  MarkNotificationsReadCommand2.ResponseSchema = z.object({ updated: z.number().int().nonnegative() });
+})(MarkNotificationsReadCommand || (MarkNotificationsReadCommand = {}));
+var ListLinkedAccountsCommand;
+((ListLinkedAccountsCommand2) => {
+  ListLinkedAccountsCommand2.endpointDetails = endpoint("GET", "/settings/links", "List linked external accounts");
+  ListLinkedAccountsCommand2.ResponseSchema = z.object({ items: z.array(LinkedAccountSchema) });
+})(ListLinkedAccountsCommand || (ListLinkedAccountsCommand = {}));
+var LinkTelegramCommand;
+((LinkTelegramCommand2) => {
+  LinkTelegramCommand2.endpointDetails = endpoint("POST", "/settings/link/telegram", "Link a Telegram account (login widget)");
+  LinkTelegramCommand2.RequestSchema = z.object({
+    id: z.union([z.number(), z.string()]),
+    auth_date: z.union([z.number(), z.string()]),
+    hash: z.string(),
+    first_name: z.string().optional(),
+    last_name: z.string().optional(),
+    username: z.string().optional(),
+    photo_url: z.string().optional()
+  });
+  LinkTelegramCommand2.ResponseSchema = LinkedAccountSchema;
+})(LinkTelegramCommand || (LinkTelegramCommand = {}));
+var LinkGoogleCommand;
+((LinkGoogleCommand2) => {
+  LinkGoogleCommand2.endpointDetails = endpoint("POST", "/settings/link/google", "Link a Google account (ID token)");
+  LinkGoogleCommand2.RequestSchema = z.object({ idToken: z.string().min(10) });
+  LinkGoogleCommand2.ResponseSchema = LinkedAccountSchema;
+})(LinkGoogleCommand || (LinkGoogleCommand = {}));
+var UnlinkAccountCommand;
+((UnlinkAccountCommand2) => {
+  UnlinkAccountCommand2.endpointDetails = endpoint("DELETE", "/settings/link/:provider", "Unlink an external account");
+  UnlinkAccountCommand2.ParamsSchema = z.object({ provider: LinkProviderSchema });
+  UnlinkAccountCommand2.ResponseSchema = z.void();
+})(UnlinkAccountCommand || (UnlinkAccountCommand = {}));
+
+// src/api/routes.ts
+var REST_API = {
+  AUTH: {
+    REGISTER: "/auth/register",
+    LOGIN: "/auth/login",
+    LOGOUT: "/auth/logout",
+    ME: "/auth/me",
+    TOTP_SETUP: "/auth/totp/setup",
+    TOTP_CONFIRM: "/auth/totp/confirm"
+  },
+  WALLET: {
+    OVERVIEW: "/wallet",
+    TRANSACTIONS: "/wallet/transactions",
+    DEPOSIT_ADDRESS: "/wallet/deposit-address"
+  },
+  TOKEN: {
+    PRICE: "/token/price",
+    CHART: "/token/chart"
+  },
+  SWAP: {
+    EXECUTE: "/swap"
+  },
+  PARTNERS: {
+    OVERVIEW: "/partners"
+  },
+  RANKS: {
+    LIST: "/ranks"
+  },
+  EARNINGS: {
+    OVERVIEW: "/earnings"
+  },
+  WITHDRAWALS: {
+    REQUEST: "/withdrawals",
+    LIST: "/withdrawals",
+    CANCEL: "/withdrawals/:id/cancel",
+    CONFIRM: "/withdrawals/:id/confirm"
+  },
+  SETTINGS: {
+    EMAIL_REQUEST: "/settings/email/request",
+    EMAIL_CONFIRM: "/settings/email/confirm",
+    TOTP_DISABLE: "/auth/totp/disable",
+    PROFILE: "/settings/profile",
+    AVATAR_UPLOAD_URL: "/settings/avatar/upload-url",
+    PREFERENCES: "/settings",
+    LINKS: "/settings/links",
+    LINK_TELEGRAM: "/settings/link/telegram",
+    LINK_GOOGLE: "/settings/link/google",
+    UNLINK: "/settings/link/:provider"
+  },
+  BONUS: {
+    DAILY: "/bonus/daily",
+    DAILY_CLAIM: "/bonus/daily/claim"
+  },
+  LEADERBOARD: {
+    OVERVIEW: "/leaderboard"
+  },
+  INCOME: {
+    OVERVIEW: "/income"
+  },
+  NOTIFICATIONS: {
+    LIST: "/notifications",
+    READ: "/notifications/read"
+  }
+};
+var API_PREFIX = "/api";
+var API_VERSION = "v1";
+
+export { API_PREFIX, API_VERSION, ASSET_SYMBOLS, AVATAR_CONTENT_TYPES, AssetBalanceSchema, AssetSymbolSchema, AvatarContentTypeSchema, AvatarUploadUrlCommand, CancelWithdrawalCommand, ChartPeriodSchema, ChartPointSchema, ClaimDailyBonusCommand, ConfirmEmailChangeCommand, ConfirmTotpCommand, ConfirmWithdrawalCommand, DEPOSITABLE_ASSETS, DailyBonusClaimResultSchema, DailyBonusDaySchema, DailyBonusStatusSchema, DepositAddressCommand, DepositAddressSchema, DepositableAssetSchema, DisableTotpCommand, ERROR_CODE, EarningsOverviewSchema, ErrorResponseSchema, FUNDING_ASSET, GetDailyBonusCommand, GetEarningsCommand, GetIncomeCommand, GetLeaderboardCommand, GetPartnersCommand, GetRanksCommand, GetSettingsCommand, GetTokenChartCommand, GetTokenPriceCommand, GetTransactionsCommand, GetWalletCommand, IncomeOverviewSchema, IncomePeriodSchema, LeaderboardEntrySchema, LeaderboardPeriodSchema, LeaderboardSchema, LinkGoogleCommand, LinkProviderSchema, LinkTelegramCommand, LinkedAccountSchema, ListLinkedAccountsCommand, ListNotificationsCommand, ListWithdrawalsCommand, LoginCommand, LogoutCommand, MONEY_REGEX, MarkNotificationsReadCommand, MeCommand, MoneyStringSchema, MonthlyPricePointSchema, NotificationSchema, NotificationTypeSchema, PaginatedSchema, PaginationQuerySchema, PartnerAccrualSchema, PartnerLevelSchema, PartnersOverviewSchema, PositiveMoneyStringSchema, REST_API, RankDefSchema, RegisterCommand, RequestEmailChangeCommand, RequestWithdrawalCommand, SessionInfoSchema, SetupTotpCommand, SwapCommand, SwapSideSchema, TOKEN_ASSET, TokenPriceSchema, TradeResultSchema, TransactionSchema, TransactionStatusSchema, TransactionTypeSchema, UnlinkAccountCommand, UpdateProfileCommand, UpdateSettingsCommand, UserProfileSchema, UserRankSchema, UserSettingsSchema, UserStatusSchema, UuidSchema, WalletOverviewSchema, WithdrawalSchema, WithdrawalStatusSchema, endpoint };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map