@satrush/api 0.1.7 → 0.1.8

package/dist/index.js

@@ -1059,14 +1059,98 @@ var getConfigResponseTransformer = async (data) => {
   data.data = satrushConfigDtoSchemaResponseTransformer(data.data);
   return data;
 };
+var epochIterationHistoryDtoSchemaResponseTransformer = (data) => {
+  if (data.endedAt) {
+    data.endedAt = new Date(data.endedAt);
+  }
+  data.poolBtcAmount = u64DtoSchemaResponseTransformer(data.poolBtcAmount);
+  data.poolUsdAmount = u64DtoSchemaResponseTransformer(data.poolUsdAmount);
+  data.startedAt = new Date(data.startedAt);
+  data.totalTickets = u64DtoSchemaResponseTransformer(data.totalTickets);
+  if (data.triggeredAt) {
+    data.triggeredAt = new Date(data.triggeredAt);
+  }
+  return data;
+};
+var getEpochHistoryResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => epochIterationHistoryDtoSchemaResponseTransformer(item));
+  return data;
+};
+var epochWinnerHistoryDtoSchemaResponseTransformer = (data) => {
+  if (data.settledAt) {
+    data.settledAt = new Date(data.settledAt);
+  }
+  if (data.settledAtSlot) {
+    data.settledAtSlot = u64DtoSchemaResponseTransformer(data.settledAtSlot);
+  }
+  data.tickets = u64DtoSchemaResponseTransformer(data.tickets);
+  data.wonBtcAmount = u64DtoSchemaResponseTransformer(data.wonBtcAmount);
+  data.wonUsdAmount = u64DtoSchemaResponseTransformer(data.wonUsdAmount);
+  return data;
+};
+var getEpochWinnersResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => epochWinnerHistoryDtoSchemaResponseTransformer(item));
+  return data;
+};
 var leaderboardEntryDtoSchemaResponseTransformer = (data) => {
+  data.totalHashrateEarned = u64DtoSchemaResponseTransformer(data.totalHashrateEarned);
+  data.totalSatsEarned = u64DtoSchemaResponseTransformer(data.totalSatsEarned);
   data.totalUsdDeployed = u64DtoSchemaResponseTransformer(data.totalUsdDeployed);
   return data;
 };
-var getLeaderboardResponseTransformer = async (data) => {
+var getHashrateEarnedLeaderboardResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => leaderboardEntryDtoSchemaResponseTransformer(item));
+  return data;
+};
+var getRoundsPlayedLeaderboardResponseTransformer = async (data) => {
   data.data = data.data.map((item) => leaderboardEntryDtoSchemaResponseTransformer(item));
   return data;
 };
+var getSatsEarnedLeaderboardResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => leaderboardEntryDtoSchemaResponseTransformer(item));
+  return data;
+};
+var oneBtcIterationHistoryDtoSchemaResponseTransformer = (data) => {
+  if (data.endedAt) {
+    data.endedAt = new Date(data.endedAt);
+  }
+  if (data.settledAt) {
+    data.settledAt = new Date(data.settledAt);
+  }
+  data.startedAt = new Date(data.startedAt);
+  data.totalTickets = u64DtoSchemaResponseTransformer(data.totalTickets);
+  return data;
+};
+var getOneBtcHistoryResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => oneBtcIterationHistoryDtoSchemaResponseTransformer(item));
+  return data;
+};
+var roundHistoryDtoSchemaResponseTransformer = (data) => {
+  if (data.settledAt) {
+    data.settledAt = new Date(data.settledAt);
+  }
+  if (data.startedAt) {
+    data.startedAt = new Date(data.startedAt);
+  }
+  if (data.strikeBonusBtc) {
+    data.strikeBonusBtc = u64DtoSchemaResponseTransformer(data.strikeBonusBtc);
+  }
+  if (data.strikeBonusUsd) {
+    data.strikeBonusUsd = u64DtoSchemaResponseTransformer(data.strikeBonusUsd);
+  }
+  data.totalDeployedUsd = u64DtoSchemaResponseTransformer(data.totalDeployedUsd);
+  if (data.totalPotBtc) {
+    data.totalPotBtc = u64DtoSchemaResponseTransformer(data.totalPotBtc);
+  }
+  if (data.totalPotUsd) {
+    data.totalPotUsd = u64DtoSchemaResponseTransformer(data.totalPotUsd);
+  }
+  return data;
+};
+var getRoundsResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => roundHistoryDtoSchemaResponseTransformer(item));
+  return data;
+};
 var publicAutomationDtoSchemaResponseTransformer = (data) => {
   data.perRoundUsdAmount = u64DtoSchemaResponseTransformer(data.perRoundUsdAmount);
   data.remainingUsdAmount = u64DtoSchemaResponseTransformer(data.remainingUsdAmount);
@@ -1174,6 +1258,47 @@ var getUserDeploymentsResponseTransformer = async (data) => {
   data.data = data.data.map((item) => minerDeploymentDtoSchemaResponseTransformer(item));
   return data;
 };
+var minerEpochEntryDtoSchemaResponseTransformer = (data) => {
+  if (data.claimedAt) {
+    data.claimedAt = new Date(data.claimedAt);
+  }
+  data.createdAt = new Date(data.createdAt);
+  data.tickets = u64DtoSchemaResponseTransformer(data.tickets);
+  if (data.wonBtcAmount) {
+    data.wonBtcAmount = u64DtoSchemaResponseTransformer(data.wonBtcAmount);
+  }
+  if (data.wonUsdAmount) {
+    data.wonUsdAmount = u64DtoSchemaResponseTransformer(data.wonUsdAmount);
+  }
+  return data;
+};
+var getUserEpochEntriesResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => minerEpochEntryDtoSchemaResponseTransformer(item));
+  return data;
+};
+var minerHashrateActionDtoSchemaResponseTransformer = (data) => {
+  data.executedAt = new Date(data.executedAt);
+  data.hashrateSpent = u64DtoSchemaResponseTransformer(data.hashrateSpent);
+  data.ticketsBought = u64DtoSchemaResponseTransformer(data.ticketsBought);
+  return data;
+};
+var getUserHashrateActionsResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => minerHashrateActionDtoSchemaResponseTransformer(item));
+  return data;
+};
+var minerOneBtcEntryDtoSchemaResponseTransformer = (data) => {
+  if (data.claimedAt) {
+    data.claimedAt = new Date(data.claimedAt);
+  }
+  data.createdAt = new Date(data.createdAt);
+  data.startTicketId = u64DtoSchemaResponseTransformer(data.startTicketId);
+  data.tickets = u64DtoSchemaResponseTransformer(data.tickets);
+  return data;
+};
+var getUserOneBtcEntriesResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => minerOneBtcEntryDtoSchemaResponseTransformer(item));
+  return data;
+};
 
 // src/generated/zod.gen.ts
 import * as z from "zod";
@@ -1190,22 +1315,83 @@ var zBadRequestErrorCodeErrorBody = z.object({
   ])
 });
 var zClaimTypeDto = z.enum(["usd", "sats"]);
+var zEpochHistoryApiError400InvalidRange = z.object({
+  code: z.enum(["invalid_range"])
+});
+var zEpochHistoryApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_range")
+  }).and(zEpochHistoryApiError400InvalidRange),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zEpochHistoryApiError500Error = z.object({
+  code: z.enum(["internal"])
+});
 var zEpochStateDto = z.enum([
   "open",
   "settling",
   "settled",
   "complete"
 ]);
+var zEpochWinnersApiError400InvalidBefore = z.object({
+  code: z.enum(["invalid_before"])
+});
+var zEpochWinnersApiError400InvalidRange = z.object({
+  code: z.enum(["invalid_range"])
+});
+var zEpochWinnersApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_before")
+  }).and(zEpochWinnersApiError400InvalidBefore),
+  z.object({
+    code: z.literal("invalid_range")
+  }).and(zEpochWinnersApiError400InvalidRange),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zEpochWinnersApiError500Error = z.object({
+  code: z.enum(["internal"])
+});
 var zFieldError = z.object({
   field: z.string(),
   message: z.string()
 });
+var zHashrateActionTypeDto = z.enum(["buy_epoch_tickets", "buy_one_btc_tickets"]);
 var zI128Dto = z.string();
 var zI64Dto = z.coerce.bigint().min(BigInt("-9223372036854775808"), { error: "Invalid value: Expected int64 to be >= -9223372036854775808" }).max(BigInt("9223372036854775807"), { error: "Invalid value: Expected int64 to be <= 9223372036854775807" });
 var zInternalErrorCodeErrorBody = z.object({
   code: z.enum(["internal_error"])
 });
 var zNotificationEntity = z.enum(["state_snapshot"]);
+var zOneBtcHistoryApiError400InvalidRange = z.object({
+  code: z.enum(["invalid_range"])
+});
+var zOneBtcHistoryApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_range")
+  }).and(zOneBtcHistoryApiError400InvalidRange),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zOneBtcHistoryApiError500Error = z.object({
+  code: z.enum(["internal"])
+});
 var zOneBtcStateDto = z.enum([
   "open",
   "settled",
@@ -1220,14 +1406,68 @@ var zPricesDto = z.object({
   sat: z.number()
 });
 var zPubkeyDto = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var zRoundHistoryStateDto = z.enum([
+  "pending",
+  "active",
+  "revealed",
+  "settled",
+  "finished"
+]);
 var zRoundStateDto = z.enum([
   "active",
   "revealed",
   "settled",
   "finished"
 ]);
+var zRoundsApiError400InvalidBefore = z.object({
+  code: z.enum(["invalid_before"])
+});
+var zRoundsApiError400InvalidIsSatStrike = z.object({
+  code: z.enum(["invalid_is_sat_strike"])
+});
+var zRoundsApiError400InvalidRange = z.object({
+  code: z.enum(["invalid_range"])
+});
+var zRoundsApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_before")
+  }).and(zRoundsApiError400InvalidBefore),
+  z.object({
+    code: z.literal("invalid_range")
+  }).and(zRoundsApiError400InvalidRange),
+  z.object({
+    code: z.literal("invalid_is_sat_strike")
+  }).and(zRoundsApiError400InvalidIsSatStrike),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zRoundsApiError500Error = z.object({
+  code: z.enum(["internal"])
+});
 var zU128Dto = z.string();
 var zU64Dto = z.coerce.bigint().min(BigInt("0"), { error: "Invalid value: Expected uint64 to be >= 0" }).max(BigInt("18446744073709551615"), { error: "Invalid value: Expected uint64 to be <= 18446744073709551615" });
+var zEpochIterationHistoryDto = z.object({
+  address: zPubkeyDto,
+  endedAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
+  id: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  poolBtcAmount: zU64Dto,
+  poolUsdAmount: zU64Dto,
+  startedAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+  totalParticipants: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  totalTickets: zU64Dto,
+  triggeredAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ]))
+});
 var zEpochVaultEntryDto = z.object({
   address: zPubkeyDto,
   iterationId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
@@ -1283,11 +1523,30 @@ var zEpochVaultDto = z.object({
   reservedBtcAmount: zU64Dto,
   reservedUsdAmount: zU64Dto
 });
+var zEpochWinnerHistoryDto = z.object({
+  authority: zPubkeyDto,
+  id: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  iterationId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  rank: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  settledAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
+  settledAtSlot: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  tickets: zU64Dto,
+  wonBtcAmount: zU64Dto,
+  wonUsdAmount: zU64Dto
+});
 var zLeaderboardEntryDto = z.object({
   authority: zPubkeyDto,
   maxStreak: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
   rank: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  totalHashrateEarned: zU64Dto,
   totalRoundsPlayed: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  totalSatsEarned: zU64Dto,
   totalUsdDeployed: zU64Dto
 });
 var zMinerClaimDto = z.object({
@@ -1361,6 +1620,79 @@ var zMinerDto = z.object({
   unsettledSatsShares: zU64Dto,
   unsettledUsdAmount: zU64Dto
 });
+var zMinerEpochEntryDto = z.object({
+  address: zPubkeyDto,
+  authority: zPubkeyDto,
+  claimedAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
+  createdAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+  id: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  isWon: z.optional(z.union([
+    z.boolean(),
+    z.null()
+  ])),
+  iterationId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  rank: z.optional(z.union([
+    z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+    z.null()
+  ])),
+  tickets: zU64Dto,
+  wonBtcAmount: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  wonUsdAmount: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ]))
+});
+var zMinerHashrateActionDto = z.object({
+  actionType: zHashrateActionTypeDto,
+  authority: zPubkeyDto,
+  executedAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+  hashrateSpent: zU64Dto,
+  id: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  signature: z.string(),
+  ticketsBought: zU64Dto
+});
+var zMinerOneBtcEntryDto = z.object({
+  address: zPubkeyDto,
+  authority: zPubkeyDto,
+  claimedAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
+  createdAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+  id: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  isWon: z.optional(z.union([
+    z.boolean(),
+    z.null()
+  ])),
+  iterationId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  startTicketId: zU64Dto,
+  tickets: zU64Dto
+});
+var zOneBtcIterationHistoryDto = z.object({
+  address: zPubkeyDto,
+  endedAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
+  id: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  settledAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
+  startedAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+  totalParticipants: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  totalTickets: zU64Dto,
+  winner: z.optional(z.union([
+    z.null(),
+    zPubkeyDto
+  ]))
+});
 var zOneBtcVaultEntryDto = z.object({
   address: zPubkeyDto,
   iterationId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
@@ -1420,6 +1752,48 @@ var zProfileDto = z.object({
   oneBtcVaultEntries: z.array(zOneBtcVaultEntryDto),
   unsettledDeployments: z.array(zPublicDeploymentDto)
 });
+var zRoundHistoryDto = z.object({
+  id: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  isSatStrike: z.optional(z.union([
+    z.boolean(),
+    z.null()
+  ])),
+  minersCount: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  settledAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
+  startedAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
+  state: zRoundHistoryStateDto,
+  strikeBonusBtc: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  strikeBonusUsd: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  totalDeployedUsd: zU64Dto,
+  totalPotBtc: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  totalPotUsd: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  winnersCount: z.optional(z.union([
+    z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+    z.null()
+  ])),
+  winningTile: z.optional(z.union([
+    z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+    z.null()
+  ]))
+});
 var zSatrushConfigDto = z.object({
   address: zPubkeyDto,
   btcMint: zPubkeyDto,
@@ -1571,6 +1945,36 @@ var zUserDeploymentsApiError400Error = z.union([
 var zUserDeploymentsApiError500Error = z.object({
   code: z.enum(["internal"])
 });
+var zUserHashrateApiError400InvalidAddress = z.object({
+  code: z.enum(["invalid_address"])
+});
+var zUserHashrateApiError400InvalidBefore = z.object({
+  code: z.enum(["invalid_before"])
+});
+var zUserHashrateApiError400InvalidRange = z.object({
+  code: z.enum(["invalid_range"])
+});
+var zUserHashrateApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_address")
+  }).and(zUserHashrateApiError400InvalidAddress),
+  z.object({
+    code: z.literal("invalid_before")
+  }).and(zUserHashrateApiError400InvalidBefore),
+  z.object({
+    code: z.literal("invalid_range")
+  }).and(zUserHashrateApiError400InvalidRange),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zUserHashrateApiError500Error = z.object({
+  code: z.enum(["internal"])
+});
 var zUserProfileApiError400InvalidAddress = z.object({
   code: z.enum(["invalid_address"])
 });
@@ -1586,6 +1990,42 @@ var zUserProfileApiError400Error = z.union([
     ])
   }).and(zBadRequestErrorCodeErrorBody)
 ]);
+var zUserVaultEntriesApiError400InvalidAddress = z.object({
+  code: z.enum(["invalid_address"])
+});
+var zUserVaultEntriesApiError400InvalidBefore = z.object({
+  code: z.enum(["invalid_before"])
+});
+var zUserVaultEntriesApiError400InvalidRange = z.object({
+  code: z.enum(["invalid_range"])
+});
+var zUserVaultEntriesApiError400InvalidWinsOnly = z.object({
+  code: z.enum(["invalid_wins_only"])
+});
+var zUserVaultEntriesApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_address")
+  }).and(zUserVaultEntriesApiError400InvalidAddress),
+  z.object({
+    code: z.literal("invalid_before")
+  }).and(zUserVaultEntriesApiError400InvalidBefore),
+  z.object({
+    code: z.literal("invalid_range")
+  }).and(zUserVaultEntriesApiError400InvalidRange),
+  z.object({
+    code: z.literal("invalid_wins_only")
+  }).and(zUserVaultEntriesApiError400InvalidWinsOnly),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zUserVaultEntriesApiError500Error = z.object({
+  code: z.enum(["internal"])
+});
 var zValidationErrorCodeErrorBody = z.object({
   code: z.enum(["validation_failed"]),
   data: z.optional(z.object({
@@ -1614,14 +2054,79 @@ var zGetConfigData = z.object({
 var zGetConfigResponse = z.object({
   data: zSatrushConfigDto
 });
-var zGetLeaderboardData = z.object({
+var zGetEpochHistoryData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.object({
+    before: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    after: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    limit: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }))
+  }))
+});
+var zGetEpochHistoryResponse = z.object({
+  data: z.array(zEpochIterationHistoryDto)
+});
+var zGetEpochWinnersData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.object({
+    before: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    after: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    limit: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }))
+  }))
+});
+var zGetEpochWinnersResponse = z.object({
+  data: z.array(zEpochWinnerHistoryDto)
+});
+var zGetHashrateEarnedLeaderboardData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.never())
+});
+var zGetHashrateEarnedLeaderboardResponse = z.object({
+  data: z.array(zLeaderboardEntryDto)
+});
+var zGetRoundsPlayedLeaderboardData = z.object({
   body: z.optional(z.never()),
   path: z.optional(z.never()),
   query: z.optional(z.never())
 });
-var zGetLeaderboardResponse = z.object({
+var zGetRoundsPlayedLeaderboardResponse = z.object({
   data: z.array(zLeaderboardEntryDto)
 });
+var zGetSatsEarnedLeaderboardData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.never())
+});
+var zGetSatsEarnedLeaderboardResponse = z.object({
+  data: z.array(zLeaderboardEntryDto)
+});
+var zGetOneBtcHistoryData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.object({
+    before: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    after: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    limit: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }))
+  }))
+});
+var zGetOneBtcHistoryResponse = z.object({
+  data: z.array(zOneBtcIterationHistoryDto)
+});
+var zGetRoundsData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.object({
+    before: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    after: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    limit: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    isSatStrike: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }))
+  }))
+});
+var zGetRoundsResponse = z.object({
+  data: z.array(zRoundHistoryDto)
+});
 var zSseData = z.object({
   body: z.optional(z.never()),
   path: z.optional(z.never()),
@@ -1668,6 +2173,50 @@ var zGetUserDeploymentsData = z.object({
 var zGetUserDeploymentsResponse = z.object({
   data: z.array(zMinerDeploymentDto)
 });
+var zGetUserEpochEntriesData = z.object({
+  body: z.optional(z.never()),
+  path: z.object({
+    address: z.string()
+  }),
+  query: z.optional(z.object({
+    before: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    after: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    limit: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    winsOnly: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }))
+  }))
+});
+var zGetUserEpochEntriesResponse = z.object({
+  data: z.array(zMinerEpochEntryDto)
+});
+var zGetUserHashrateActionsData = z.object({
+  body: z.optional(z.never()),
+  path: z.object({
+    address: z.string()
+  }),
+  query: z.optional(z.object({
+    before: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    after: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    limit: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }))
+  }))
+});
+var zGetUserHashrateActionsResponse = z.object({
+  data: z.array(zMinerHashrateActionDto)
+});
+var zGetUserOneBtcEntriesData = z.object({
+  body: z.optional(z.never()),
+  path: z.object({
+    address: z.string()
+  }),
+  query: z.optional(z.object({
+    before: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    after: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    limit: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })),
+    winsOnly: z.optional(z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }))
+  }))
+});
+var zGetUserOneBtcEntriesResponse = z.object({
+  data: z.array(zMinerOneBtcEntryDto)
+});
 
 // src/generated/sdk.gen.ts
 var HeyApiClient = class {
@@ -1721,17 +2270,114 @@ var SatrushBackendSdk = class _SatrushBackendSdk extends HeyApiClient {
     });
   }
   /**
-   * Request the top miners by lifetime USD deployed
+   * Request Epoch Vault history
    */
-  getLeaderboard(options) {
+  getEpochHistory(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [
+      { in: "query", key: "before" },
+      { in: "query", key: "after" },
+      { in: "query", key: "limit" }
+    ] }]);
     return (options?.client ?? this.client).get({
-      requestValidator: async (data) => await zGetLeaderboardData.parseAsync(data),
-      responseTransformer: getLeaderboardResponseTransformer,
-      responseValidator: async (data) => await zGetLeaderboardResponse.parseAsync(data),
-      url: "/v1/leaderboard",
+      requestValidator: async (data) => await zGetEpochHistoryData.parseAsync(data),
+      responseTransformer: getEpochHistoryResponseTransformer,
+      responseValidator: async (data) => await zGetEpochHistoryResponse.parseAsync(data),
+      url: "/v1/epoch/history",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Request Epoch Vault winners
+   */
+  getEpochWinners(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [
+      { in: "query", key: "before" },
+      { in: "query", key: "after" },
+      { in: "query", key: "limit" }
+    ] }]);
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetEpochWinnersData.parseAsync(data),
+      responseTransformer: getEpochWinnersResponseTransformer,
+      responseValidator: async (data) => await zGetEpochWinnersResponse.parseAsync(data),
+      url: "/v1/epoch/winners",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Request the top miners by lifetime hashrate earned
+   */
+  getHashrateEarnedLeaderboard(options) {
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetHashrateEarnedLeaderboardData.parseAsync(data),
+      responseTransformer: getHashrateEarnedLeaderboardResponseTransformer,
+      responseValidator: async (data) => await zGetHashrateEarnedLeaderboardResponse.parseAsync(data),
+      url: "/v1/leaderboard/hashrate-earned",
       ...options
     });
   }
+  /**
+   * Request the top miners by lifetime rounds played
+   */
+  getRoundsPlayedLeaderboard(options) {
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetRoundsPlayedLeaderboardData.parseAsync(data),
+      responseTransformer: getRoundsPlayedLeaderboardResponseTransformer,
+      responseValidator: async (data) => await zGetRoundsPlayedLeaderboardResponse.parseAsync(data),
+      url: "/v1/leaderboard/rounds-played",
+      ...options
+    });
+  }
+  /**
+   * Request the top miners by lifetime sats earned
+   */
+  getSatsEarnedLeaderboard(options) {
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetSatsEarnedLeaderboardData.parseAsync(data),
+      responseTransformer: getSatsEarnedLeaderboardResponseTransformer,
+      responseValidator: async (data) => await zGetSatsEarnedLeaderboardResponse.parseAsync(data),
+      url: "/v1/leaderboard/sats-earned",
+      ...options
+    });
+  }
+  /**
+   * Request 1 BTC Vault history
+   */
+  getOneBtcHistory(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [
+      { in: "query", key: "before" },
+      { in: "query", key: "after" },
+      { in: "query", key: "limit" }
+    ] }]);
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetOneBtcHistoryData.parseAsync(data),
+      responseTransformer: getOneBtcHistoryResponseTransformer,
+      responseValidator: async (data) => await zGetOneBtcHistoryResponse.parseAsync(data),
+      url: "/v1/one-btc/history",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Request rounds history
+   */
+  getRounds(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [
+      { in: "query", key: "before" },
+      { in: "query", key: "after" },
+      { in: "query", key: "limit" },
+      { in: "query", key: "isSatStrike" }
+    ] }]);
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetRoundsData.parseAsync(data),
+      responseTransformer: getRoundsResponseTransformer,
+      responseValidator: async (data) => await zGetRoundsResponse.parseAsync(data),
+      url: "/v1/rounds",
+      ...options,
+      ...params
+    });
+  }
   /**
    * Subscribe for SSE stream
    */
@@ -1798,6 +2444,65 @@ var SatrushBackendSdk = class _SatrushBackendSdk extends HeyApiClient {
       ...params
     });
   }
+  /**
+   * Request user Epoch Vault entries
+   */
+  getUserEpochEntries(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [
+      { in: "path", key: "address" },
+      { in: "query", key: "before" },
+      { in: "query", key: "after" },
+      { in: "query", key: "limit" },
+      { in: "query", key: "winsOnly" }
+    ] }]);
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetUserEpochEntriesData.parseAsync(data),
+      responseTransformer: getUserEpochEntriesResponseTransformer,
+      responseValidator: async (data) => await zGetUserEpochEntriesResponse.parseAsync(data),
+      url: "/v1/users/{address}/epoch",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Request user hashrate history
+   */
+  getUserHashrateActions(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [
+      { in: "path", key: "address" },
+      { in: "query", key: "before" },
+      { in: "query", key: "after" },
+      { in: "query", key: "limit" }
+    ] }]);
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetUserHashrateActionsData.parseAsync(data),
+      responseTransformer: getUserHashrateActionsResponseTransformer,
+      responseValidator: async (data) => await zGetUserHashrateActionsResponse.parseAsync(data),
+      url: "/v1/users/{address}/hashrate",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Request user 1 BTC Vault entries
+   */
+  getUserOneBtcEntries(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [
+      { in: "path", key: "address" },
+      { in: "query", key: "before" },
+      { in: "query", key: "after" },
+      { in: "query", key: "limit" },
+      { in: "query", key: "winsOnly" }
+    ] }]);
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetUserOneBtcEntriesData.parseAsync(data),
+      responseTransformer: getUserOneBtcEntriesResponseTransformer,
+      responseValidator: async (data) => await zGetUserOneBtcEntriesResponse.parseAsync(data),
+      url: "/v1/users/{address}/one-btc",
+      ...options,
+      ...params
+    });
+  }
 };
 
 // src/generated/types.gen.ts
@@ -1813,12 +2518,20 @@ var EpochStateDto = {
   SETTLED: "settled",
   COMPLETE: "complete"
 };
+var HashrateActionTypeDto = { BUY_EPOCH_TICKETS: "buy_epoch_tickets", BUY_ONE_BTC_TICKETS: "buy_one_btc_tickets" };
 var NotificationEntity = { STATE_SNAPSHOT: "state_snapshot" };
 var OneBtcStateDto = {
   OPEN: "open",
   SETTLED: "settled",
   COMPLETE: "complete"
 };
+var RoundHistoryStateDto = {
+  PENDING: "pending",
+  ACTIVE: "active",
+  REVEALED: "revealed",
+  SETTLED: "settled",
+  FINISHED: "finished"
+};
 var RoundStateDto = {
   ACTIVE: "active",
   REVEALED: "revealed",
@@ -1874,8 +2587,10 @@ export {
   AutomationStrategyDto,
   ClaimTypeDto,
   EpochStateDto,
+  HashrateActionTypeDto,
   NotificationEntity,
   OneBtcStateDto,
+  RoundHistoryStateDto,
   RoundStateDto,
   SatrushBackendSdk,
   SatrushBackendSdkError,
@@ -1888,24 +2603,52 @@ export {
   zBadRequestErrorCodeErrorBody,
   zBoardDto,
   zClaimTypeDto,
+  zEpochHistoryApiError400Error,
+  zEpochHistoryApiError400InvalidRange,
+  zEpochHistoryApiError500Error,
+  zEpochIterationHistoryDto,
   zEpochStateDto,
   zEpochVaultDto,
   zEpochVaultEntryDto,
   zEpochVaultIterationDto,
   zEpochWinnerDto,
+  zEpochWinnerHistoryDto,
+  zEpochWinnersApiError400Error,
+  zEpochWinnersApiError400InvalidBefore,
+  zEpochWinnersApiError400InvalidRange,
+  zEpochWinnersApiError500Error,
   zFieldError,
   zGetBoardData,
   zGetBoardResponse,
   zGetConfigData,
   zGetConfigResponse,
-  zGetLeaderboardData,
-  zGetLeaderboardResponse,
+  zGetEpochHistoryData,
+  zGetEpochHistoryResponse,
+  zGetEpochWinnersData,
+  zGetEpochWinnersResponse,
+  zGetHashrateEarnedLeaderboardData,
+  zGetHashrateEarnedLeaderboardResponse,
+  zGetOneBtcHistoryData,
+  zGetOneBtcHistoryResponse,
+  zGetRoundsData,
+  zGetRoundsPlayedLeaderboardData,
+  zGetRoundsPlayedLeaderboardResponse,
+  zGetRoundsResponse,
+  zGetSatsEarnedLeaderboardData,
+  zGetSatsEarnedLeaderboardResponse,
   zGetUserClaimsData,
   zGetUserClaimsResponse,
   zGetUserDeploymentsData,
   zGetUserDeploymentsResponse,
+  zGetUserEpochEntriesData,
+  zGetUserEpochEntriesResponse,
+  zGetUserHashrateActionsData,
+  zGetUserHashrateActionsResponse,
+  zGetUserOneBtcEntriesData,
+  zGetUserOneBtcEntriesResponse,
   zGetUserProfileData,
   zGetUserProfileResponse,
+  zHashrateActionTypeDto,
   zI128Dto,
   zI64Dto,
   zInternalErrorCodeErrorBody,
@@ -1913,7 +2656,14 @@ export {
   zMinerClaimDto,
   zMinerDeploymentDto,
   zMinerDto,
+  zMinerEpochEntryDto,
+  zMinerHashrateActionDto,
+  zMinerOneBtcEntryDto,
   zNotificationEntity,
+  zOneBtcHistoryApiError400Error,
+  zOneBtcHistoryApiError400InvalidRange,
+  zOneBtcHistoryApiError500Error,
+  zOneBtcIterationHistoryDto,
   zOneBtcStateDto,
   zOneBtcVaultDto,
   zOneBtcVaultEntryDto,
@@ -1925,7 +2675,14 @@ export {
   zPublicAutomationDto,
   zPublicDeploymentDto,
   zRoundDto,
+  zRoundHistoryDto,
+  zRoundHistoryStateDto,
   zRoundStateDto,
+  zRoundsApiError400Error,
+  zRoundsApiError400InvalidBefore,
+  zRoundsApiError400InvalidIsSatStrike,
+  zRoundsApiError400InvalidRange,
+  zRoundsApiError500Error,
   zSatrushConfigDto,
   zSatsVaultDto,
   zSnapshotDto,
@@ -1947,8 +2704,19 @@ export {
   zUserDeploymentsApiError400InvalidBefore,
   zUserDeploymentsApiError400InvalidRange,
   zUserDeploymentsApiError500Error,
+  zUserHashrateApiError400Error,
+  zUserHashrateApiError400InvalidAddress,
+  zUserHashrateApiError400InvalidBefore,
+  zUserHashrateApiError400InvalidRange,
+  zUserHashrateApiError500Error,
   zUserProfileApiError400Error,
   zUserProfileApiError400InvalidAddress,
+  zUserVaultEntriesApiError400Error,
+  zUserVaultEntriesApiError400InvalidAddress,
+  zUserVaultEntriesApiError400InvalidBefore,
+  zUserVaultEntriesApiError400InvalidRange,
+  zUserVaultEntriesApiError400InvalidWinsOnly,
+  zUserVaultEntriesApiError500Error,
   zValidationErrorCodeErrorBody,
   zValidationErrorCodeValidationDetailsErrorBody
 };