@numen-crypto/contract 0.1.0

package/dist/index.cjs

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