@satrush/api 0.1.6 → 0.1.8

package/dist/index.cjs

@@ -30,9 +30,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AutomationStrategyDto: () => AutomationStrategyDto,
+  ClaimTypeDto: () => ClaimTypeDto,
   EpochStateDto: () => EpochStateDto,
+  HashrateActionTypeDto: () => HashrateActionTypeDto,
   NotificationEntity: () => NotificationEntity,
   OneBtcStateDto: () => OneBtcStateDto,
+  RoundHistoryStateDto: () => RoundHistoryStateDto,
   RoundStateDto: () => RoundStateDto,
   SatrushBackendSdk: () => SatrushBackendSdk,
   SatrushBackendSdkError: () => SatrushBackendSdkError,
@@ -44,26 +47,68 @@ __export(index_exports, {
   zAutomationStrategyDto: () => zAutomationStrategyDto,
   zBadRequestErrorCodeErrorBody: () => zBadRequestErrorCodeErrorBody,
   zBoardDto: () => zBoardDto,
+  zClaimTypeDto: () => zClaimTypeDto,
+  zEpochHistoryApiError400Error: () => zEpochHistoryApiError400Error,
+  zEpochHistoryApiError400InvalidRange: () => zEpochHistoryApiError400InvalidRange,
+  zEpochHistoryApiError500Error: () => zEpochHistoryApiError500Error,
+  zEpochIterationHistoryDto: () => zEpochIterationHistoryDto,
   zEpochStateDto: () => zEpochStateDto,
   zEpochVaultDto: () => zEpochVaultDto,
   zEpochVaultEntryDto: () => zEpochVaultEntryDto,
   zEpochVaultIterationDto: () => zEpochVaultIterationDto,
   zEpochWinnerDto: () => zEpochWinnerDto,
+  zEpochWinnerHistoryDto: () => zEpochWinnerHistoryDto,
+  zEpochWinnersApiError400Error: () => zEpochWinnersApiError400Error,
+  zEpochWinnersApiError400InvalidBefore: () => zEpochWinnersApiError400InvalidBefore,
+  zEpochWinnersApiError400InvalidRange: () => zEpochWinnersApiError400InvalidRange,
+  zEpochWinnersApiError500Error: () => zEpochWinnersApiError500Error,
   zFieldError: () => zFieldError,
   zGetBoardData: () => zGetBoardData,
   zGetBoardResponse: () => zGetBoardResponse,
   zGetConfigData: () => zGetConfigData,
   zGetConfigResponse: () => zGetConfigResponse,
+  zGetEpochHistoryData: () => zGetEpochHistoryData,
+  zGetEpochHistoryResponse: () => zGetEpochHistoryResponse,
+  zGetEpochWinnersData: () => zGetEpochWinnersData,
+  zGetEpochWinnersResponse: () => zGetEpochWinnersResponse,
+  zGetHashrateEarnedLeaderboardData: () => zGetHashrateEarnedLeaderboardData,
+  zGetHashrateEarnedLeaderboardResponse: () => zGetHashrateEarnedLeaderboardResponse,
+  zGetOneBtcHistoryData: () => zGetOneBtcHistoryData,
+  zGetOneBtcHistoryResponse: () => zGetOneBtcHistoryResponse,
+  zGetRoundsData: () => zGetRoundsData,
+  zGetRoundsPlayedLeaderboardData: () => zGetRoundsPlayedLeaderboardData,
+  zGetRoundsPlayedLeaderboardResponse: () => zGetRoundsPlayedLeaderboardResponse,
+  zGetRoundsResponse: () => zGetRoundsResponse,
+  zGetSatsEarnedLeaderboardData: () => zGetSatsEarnedLeaderboardData,
+  zGetSatsEarnedLeaderboardResponse: () => zGetSatsEarnedLeaderboardResponse,
+  zGetUserClaimsData: () => zGetUserClaimsData,
+  zGetUserClaimsResponse: () => zGetUserClaimsResponse,
   zGetUserDeploymentsData: () => zGetUserDeploymentsData,
   zGetUserDeploymentsResponse: () => zGetUserDeploymentsResponse,
+  zGetUserEpochEntriesData: () => zGetUserEpochEntriesData,
+  zGetUserEpochEntriesResponse: () => zGetUserEpochEntriesResponse,
+  zGetUserHashrateActionsData: () => zGetUserHashrateActionsData,
+  zGetUserHashrateActionsResponse: () => zGetUserHashrateActionsResponse,
+  zGetUserOneBtcEntriesData: () => zGetUserOneBtcEntriesData,
+  zGetUserOneBtcEntriesResponse: () => zGetUserOneBtcEntriesResponse,
   zGetUserProfileData: () => zGetUserProfileData,
   zGetUserProfileResponse: () => zGetUserProfileResponse,
+  zHashrateActionTypeDto: () => zHashrateActionTypeDto,
   zI128Dto: () => zI128Dto,
   zI64Dto: () => zI64Dto,
   zInternalErrorCodeErrorBody: () => zInternalErrorCodeErrorBody,
+  zLeaderboardEntryDto: () => zLeaderboardEntryDto,
+  zMinerClaimDto: () => zMinerClaimDto,
   zMinerDeploymentDto: () => zMinerDeploymentDto,
   zMinerDto: () => zMinerDto,
+  zMinerEpochEntryDto: () => zMinerEpochEntryDto,
+  zMinerHashrateActionDto: () => zMinerHashrateActionDto,
+  zMinerOneBtcEntryDto: () => zMinerOneBtcEntryDto,
   zNotificationEntity: () => zNotificationEntity,
+  zOneBtcHistoryApiError400Error: () => zOneBtcHistoryApiError400Error,
+  zOneBtcHistoryApiError400InvalidRange: () => zOneBtcHistoryApiError400InvalidRange,
+  zOneBtcHistoryApiError500Error: () => zOneBtcHistoryApiError500Error,
+  zOneBtcIterationHistoryDto: () => zOneBtcIterationHistoryDto,
   zOneBtcStateDto: () => zOneBtcStateDto,
   zOneBtcVaultDto: () => zOneBtcVaultDto,
   zOneBtcVaultEntryDto: () => zOneBtcVaultEntryDto,
@@ -75,7 +120,14 @@ __export(index_exports, {
   zPublicAutomationDto: () => zPublicAutomationDto,
   zPublicDeploymentDto: () => zPublicDeploymentDto,
   zRoundDto: () => zRoundDto,
+  zRoundHistoryDto: () => zRoundHistoryDto,
+  zRoundHistoryStateDto: () => zRoundHistoryStateDto,
   zRoundStateDto: () => zRoundStateDto,
+  zRoundsApiError400Error: () => zRoundsApiError400Error,
+  zRoundsApiError400InvalidBefore: () => zRoundsApiError400InvalidBefore,
+  zRoundsApiError400InvalidIsSatStrike: () => zRoundsApiError400InvalidIsSatStrike,
+  zRoundsApiError400InvalidRange: () => zRoundsApiError400InvalidRange,
+  zRoundsApiError500Error: () => zRoundsApiError500Error,
   zSatrushConfigDto: () => zSatrushConfigDto,
   zSatsVaultDto: () => zSatsVaultDto,
   zSnapshotDto: () => zSnapshotDto,
@@ -87,11 +139,29 @@ __export(index_exports, {
   zTileStakeDto: () => zTileStakeDto,
   zU128Dto: () => zU128Dto,
   zU64Dto: () => zU64Dto,
+  zUserClaimsApiError400Error: () => zUserClaimsApiError400Error,
+  zUserClaimsApiError400InvalidAddress: () => zUserClaimsApiError400InvalidAddress,
+  zUserClaimsApiError400InvalidBefore: () => zUserClaimsApiError400InvalidBefore,
+  zUserClaimsApiError400InvalidRange: () => zUserClaimsApiError400InvalidRange,
+  zUserClaimsApiError500Error: () => zUserClaimsApiError500Error,
   zUserDeploymentsApiError400Error: () => zUserDeploymentsApiError400Error,
   zUserDeploymentsApiError400InvalidAddress: () => zUserDeploymentsApiError400InvalidAddress,
+  zUserDeploymentsApiError400InvalidBefore: () => zUserDeploymentsApiError400InvalidBefore,
+  zUserDeploymentsApiError400InvalidRange: () => zUserDeploymentsApiError400InvalidRange,
   zUserDeploymentsApiError500Error: () => zUserDeploymentsApiError500Error,
+  zUserHashrateApiError400Error: () => zUserHashrateApiError400Error,
+  zUserHashrateApiError400InvalidAddress: () => zUserHashrateApiError400InvalidAddress,
+  zUserHashrateApiError400InvalidBefore: () => zUserHashrateApiError400InvalidBefore,
+  zUserHashrateApiError400InvalidRange: () => zUserHashrateApiError400InvalidRange,
+  zUserHashrateApiError500Error: () => zUserHashrateApiError500Error,
   zUserProfileApiError400Error: () => zUserProfileApiError400Error,
   zUserProfileApiError400InvalidAddress: () => zUserProfileApiError400InvalidAddress,
+  zUserVaultEntriesApiError400Error: () => zUserVaultEntriesApiError400Error,
+  zUserVaultEntriesApiError400InvalidAddress: () => zUserVaultEntriesApiError400InvalidAddress,
+  zUserVaultEntriesApiError400InvalidBefore: () => zUserVaultEntriesApiError400InvalidBefore,
+  zUserVaultEntriesApiError400InvalidRange: () => zUserVaultEntriesApiError400InvalidRange,
+  zUserVaultEntriesApiError400InvalidWinsOnly: () => zUserVaultEntriesApiError400InvalidWinsOnly,
+  zUserVaultEntriesApiError500Error: () => zUserVaultEntriesApiError500Error,
   zValidationErrorCodeErrorBody: () => zValidationErrorCodeErrorBody,
   zValidationErrorCodeValidationDetailsErrorBody: () => zValidationErrorCodeValidationDetailsErrorBody
 });
@@ -1086,6 +1156,8 @@ var epochVaultDtoSchemaResponseTransformer = (data) => {
   if (data.currentIteration) {
     data.currentIteration = epochVaultIterationDtoSchemaResponseTransformer(data.currentIteration);
   }
+  data.iterationEndsAt = new Date(data.iterationEndsAt);
+  data.iterationStartedAt = new Date(data.iterationStartedAt);
   data.lastTriggerSlot = u64DtoSchemaResponseTransformer(data.lastTriggerSlot);
   data.pendingUsdAmount = u64DtoSchemaResponseTransformer(data.pendingUsdAmount);
   data.poolBtcAmount = u64DtoSchemaResponseTransformer(data.poolBtcAmount);
@@ -1119,6 +1191,9 @@ var satsVaultDtoSchemaResponseTransformer = (data) => {
 };
 var strikeJackpotDtoSchemaResponseTransformer = (data) => {
   data.btcAmount = u64DtoSchemaResponseTransformer(data.btcAmount);
+  if (data.lastTriggerAt) {
+    data.lastTriggerAt = new Date(data.lastTriggerAt);
+  }
   data.pendingUsdAmount = u64DtoSchemaResponseTransformer(data.pendingUsdAmount);
   data.usdAmount = u64DtoSchemaResponseTransformer(data.usdAmount);
   return data;
@@ -1134,6 +1209,8 @@ var boardDtoSchemaResponseTransformer = (data) => {
   if (data.previousRound) {
     data.previousRound = roundDtoSchemaResponseTransformer(data.previousRound);
   }
+  data.roundEndsAt = new Date(data.roundEndsAt);
+  data.roundStartedAt = new Date(data.roundStartedAt);
   data.satsVault = satsVaultDtoSchemaResponseTransformer(data.satsVault);
   data.startSlot = u64DtoSchemaResponseTransformer(data.startSlot);
   data.strike = strikeJackpotDtoSchemaResponseTransformer(data.strike);
@@ -1151,6 +1228,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 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);
@@ -1160,10 +1329,6 @@ var publicAutomationDtoSchemaResponseTransformer = (data) => {
   data.totalUsdEarned = u64DtoSchemaResponseTransformer(data.totalUsdEarned);
   return data;
 };
-var publicDeploymentDtoSchemaResponseTransformer = (data) => {
-  data.deployedUsdAmount = u64DtoSchemaResponseTransformer(data.deployedUsdAmount);
-  return data;
-};
 var epochVaultEntryDtoSchemaResponseTransformer = (data) => {
   data.tickets = u64DtoSchemaResponseTransformer(data.tickets);
   return data;
@@ -1189,14 +1354,18 @@ var oneBtcVaultEntryDtoSchemaResponseTransformer = (data) => {
   data.ticketsCount = u64DtoSchemaResponseTransformer(data.ticketsCount);
   return data;
 };
+var publicDeploymentDtoSchemaResponseTransformer = (data) => {
+  data.deployedUsdAmount = u64DtoSchemaResponseTransformer(data.deployedUsdAmount);
+  return data;
+};
 var profileDtoSchemaResponseTransformer = (data) => {
   if (data.automation) {
     data.automation = publicAutomationDtoSchemaResponseTransformer(data.automation);
   }
-  data.deployments = data.deployments.map((item) => publicDeploymentDtoSchemaResponseTransformer(item));
   data.epochVaultEntries = data.epochVaultEntries.map((item) => epochVaultEntryDtoSchemaResponseTransformer(item));
   data.miner = minerDtoSchemaResponseTransformer(data.miner);
   data.oneBtcVaultEntries = data.oneBtcVaultEntries.map((item) => oneBtcVaultEntryDtoSchemaResponseTransformer(item));
+  data.unsettledDeployments = data.unsettledDeployments.map((item) => publicDeploymentDtoSchemaResponseTransformer(item));
   return data;
 };
 var snapshotDtoSchemaResponseTransformer = (data) => {
@@ -1222,6 +1391,26 @@ var getUserProfileResponseTransformer = async (data) => {
   data.data = profileDtoSchemaResponseTransformer(data.data);
   return data;
 };
+var minerClaimDtoSchemaResponseTransformer = (data) => {
+  if (data.btcReceived) {
+    data.btcReceived = u64DtoSchemaResponseTransformer(data.btcReceived);
+  }
+  data.claimedAt = new Date(data.claimedAt);
+  if (data.hashrateClaimed) {
+    data.hashrateClaimed = u64DtoSchemaResponseTransformer(data.hashrateClaimed);
+  }
+  if (data.satsClaimed) {
+    data.satsClaimed = u64DtoSchemaResponseTransformer(data.satsClaimed);
+  }
+  if (data.usdClaimed) {
+    data.usdClaimed = u64DtoSchemaResponseTransformer(data.usdClaimed);
+  }
+  return data;
+};
+var getUserClaimsResponseTransformer = async (data) => {
+  data.data = data.data.map((item) => minerClaimDtoSchemaResponseTransformer(item));
+  return data;
+};
 var minerDeploymentDtoSchemaResponseTransformer = (data) => {
   data.deployedAt = new Date(data.deployedAt);
   data.deployedUsdAmount = u64DtoSchemaResponseTransformer(data.deployedUsdAmount);
@@ -1238,6 +1427,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
 var z = __toESM(require("zod"), 1);
@@ -1253,28 +1483,91 @@ var zBadRequestErrorCodeErrorBody = z.object({
     "invalid_body"
   ])
 });
+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",
   "complete"
 ]);
 var zPreviousRoundDto = z.object({
+  roundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
   winningTile: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
 });
 var zPricesDto = z.object({
@@ -1282,14 +1575,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" }),
@@ -1335,7 +1682,9 @@ var zEpochVaultDto = z.object({
     z.null(),
     zEpochVaultIterationDto
   ])),
+  iterationEndsAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
   iterationId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  iterationStartedAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
   lastTriggerSlot: zU64Dto,
   pendingUsdAmount: zU64Dto,
   poolBtcAmount: zU64Dto,
@@ -1343,6 +1692,55 @@ 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({
+  authority: zPubkeyDto,
+  btcReceived: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  claimType: zClaimTypeDto,
+  claimedAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+  hashrateClaimed: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  id: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  satsClaimed: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ])),
+  signature: z.string(),
+  usdClaimed: z.optional(z.union([
+    z.null(),
+    zU64Dto
+  ]))
+});
 var zMinerDeploymentDto = z.object({
   authority: zPubkeyDto,
   deployedAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
@@ -1391,6 +1789,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" }),
@@ -1445,32 +1916,78 @@ var zProfileDto = z.object({
     z.null(),
     zPublicAutomationDto
   ])),
-  deployments: z.array(zPublicDeploymentDto),
   epochVaultEntries: z.array(zEpochVaultEntryDto),
   miner: zMinerDto,
-  oneBtcVaultEntries: z.array(zOneBtcVaultEntryDto)
+  oneBtcVaultEntries: z.array(zOneBtcVaultEntryDto),
+  unsettledDeployments: z.array(zPublicDeploymentDto)
 });
-var zSatrushConfigDto = z.object({
-  address: zPubkeyDto,
-  btcMint: zPubkeyDto,
-  epochFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  epochVaultIterationDuration: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  minDeployUsdAmount: zU64Dto,
-  oneBtcFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  protocolFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  satsVaultClaimFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  satsVaultRoundFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  strikeFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  unclaimedHashrateBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
-  usdMint: zPubkeyDto
-});
-var zSatsVaultDto = z.object({
-  address: zPubkeyDto,
+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,
+  epochFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  epochVaultIterationDuration: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  minDeployUsdAmount: zU64Dto,
+  oneBtcFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  protocolFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  satsVaultClaimFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  satsVaultRoundFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  strikeFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  unclaimedHashrateBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  usdMint: zPubkeyDto
+});
+var zSatsVaultDto = z.object({
+  address: zPubkeyDto,
   btcAmount: zU64Dto,
   btcShares: zU64Dto
 });
 var zStrikeJackpotDto = z.object({
   btcAmount: zU64Dto,
+  lastTriggerAt: z.optional(z.union([
+    z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
+    z.null()
+  ])),
   lastTriggerRoundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
   pendingUsdAmount: zU64Dto,
   usdAmount: zU64Dto
@@ -1516,7 +2033,9 @@ var zBoardDto = z.object({
   previousRounds: z.array(zPreviousRoundDto),
   prices: zPricesDto,
   roundDuration: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  roundEndsAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
   roundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  roundStartedAt: z.preprocess((value) => value instanceof Date ? value.toISOString() : value, z.iso.datetime()),
   satsVault: zSatsVaultDto,
   startSlot: zU64Dto,
   strike: zStrikeJackpotDto
@@ -1535,13 +2054,55 @@ var zSseResponseSnapshot = zSnapshotDto.and(z.object({
 var zSseResponse = z.object({
   entity: z.literal("state_snapshot")
 }).and(zSseResponseSnapshot);
+var zUserClaimsApiError400InvalidAddress = z.object({
+  code: z.enum(["invalid_address"])
+});
+var zUserClaimsApiError400InvalidBefore = z.object({
+  code: z.enum(["invalid_before"])
+});
+var zUserClaimsApiError400InvalidRange = z.object({
+  code: z.enum(["invalid_range"])
+});
+var zUserClaimsApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_address")
+  }).and(zUserClaimsApiError400InvalidAddress),
+  z.object({
+    code: z.literal("invalid_before")
+  }).and(zUserClaimsApiError400InvalidBefore),
+  z.object({
+    code: z.literal("invalid_range")
+  }).and(zUserClaimsApiError400InvalidRange),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zUserClaimsApiError500Error = z.object({
+  code: z.enum(["internal"])
+});
 var zUserDeploymentsApiError400InvalidAddress = z.object({
   code: z.enum(["invalid_address"])
 });
+var zUserDeploymentsApiError400InvalidBefore = z.object({
+  code: z.enum(["invalid_before"])
+});
+var zUserDeploymentsApiError400InvalidRange = z.object({
+  code: z.enum(["invalid_range"])
+});
 var zUserDeploymentsApiError400Error = z.union([
   z.object({
     code: z.literal("invalid_address")
   }).and(zUserDeploymentsApiError400InvalidAddress),
+  z.object({
+    code: z.literal("invalid_before")
+  }).and(zUserDeploymentsApiError400InvalidBefore),
+  z.object({
+    code: z.literal("invalid_range")
+  }).and(zUserDeploymentsApiError400InvalidRange),
   z.object({
     code: z.union([
       z.literal("invalid_body"),
@@ -1553,6 +2114,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"])
 });
@@ -1568,6 +2159,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({
@@ -1596,6 +2223,79 @@ var zGetConfigData = z.object({
 var zGetConfigResponse = z.object({
   data: zSatrushConfigDto
 });
+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 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()),
@@ -1614,6 +2314,20 @@ var zGetUserProfileData = z.object({
 var zGetUserProfileResponse = z.object({
   data: zProfileDto
 });
+var zGetUserClaimsData = 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 zGetUserClaimsResponse = z.object({
+  data: z.array(zMinerClaimDto)
+});
 var zGetUserDeploymentsData = z.object({
   body: z.optional(z.never()),
   path: z.object({
@@ -1621,12 +2335,57 @@ var zGetUserDeploymentsData = z.object({
   }),
   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 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 {
@@ -1679,6 +2438,115 @@ var SatrushBackendSdk = class _SatrushBackendSdk extends HeyApiClient {
       ...options
     });
   }
+  /**
+   * Request Epoch Vault history
+   */
+  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 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
    */
@@ -1707,6 +2575,25 @@ var SatrushBackendSdk = class _SatrushBackendSdk extends HeyApiClient {
       ...params
     });
   }
+  /**
+   * Request user claims
+   */
+  getUserClaims(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 zGetUserClaimsData.parseAsync(data),
+      responseTransformer: getUserClaimsResponseTransformer,
+      responseValidator: async (data) => await zGetUserClaimsResponse.parseAsync(data),
+      url: "/v1/users/{address}/claims",
+      ...options,
+      ...params
+    });
+  }
   /**
    * Request user deployments
    */
@@ -1714,6 +2601,7 @@ var SatrushBackendSdk = class _SatrushBackendSdk extends HeyApiClient {
     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({
@@ -1725,6 +2613,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
@@ -1733,18 +2680,27 @@ var AutomationStrategyDto = {
   RANDOM: "random",
   DISCRETIONARY: "discretionary"
 };
+var ClaimTypeDto = { USD: "usd", SATS: "sats" };
 var EpochStateDto = {
   OPEN: "open",
   SETTLING: "settling",
   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",
@@ -1799,9 +2755,12 @@ async function unwrap(promise) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AutomationStrategyDto,
+  ClaimTypeDto,
   EpochStateDto,
+  HashrateActionTypeDto,
   NotificationEntity,
   OneBtcStateDto,
+  RoundHistoryStateDto,
   RoundStateDto,
   SatrushBackendSdk,
   SatrushBackendSdkError,
@@ -1813,26 +2772,68 @@ async function unwrap(promise) {
   zAutomationStrategyDto,
   zBadRequestErrorCodeErrorBody,
   zBoardDto,
+  zClaimTypeDto,
+  zEpochHistoryApiError400Error,
+  zEpochHistoryApiError400InvalidRange,
+  zEpochHistoryApiError500Error,
+  zEpochIterationHistoryDto,
   zEpochStateDto,
   zEpochVaultDto,
   zEpochVaultEntryDto,
   zEpochVaultIterationDto,
   zEpochWinnerDto,
+  zEpochWinnerHistoryDto,
+  zEpochWinnersApiError400Error,
+  zEpochWinnersApiError400InvalidBefore,
+  zEpochWinnersApiError400InvalidRange,
+  zEpochWinnersApiError500Error,
   zFieldError,
   zGetBoardData,
   zGetBoardResponse,
   zGetConfigData,
   zGetConfigResponse,
+  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,
+  zLeaderboardEntryDto,
+  zMinerClaimDto,
   zMinerDeploymentDto,
   zMinerDto,
+  zMinerEpochEntryDto,
+  zMinerHashrateActionDto,
+  zMinerOneBtcEntryDto,
   zNotificationEntity,
+  zOneBtcHistoryApiError400Error,
+  zOneBtcHistoryApiError400InvalidRange,
+  zOneBtcHistoryApiError500Error,
+  zOneBtcIterationHistoryDto,
   zOneBtcStateDto,
   zOneBtcVaultDto,
   zOneBtcVaultEntryDto,
@@ -1844,7 +2845,14 @@ async function unwrap(promise) {
   zPublicAutomationDto,
   zPublicDeploymentDto,
   zRoundDto,
+  zRoundHistoryDto,
+  zRoundHistoryStateDto,
   zRoundStateDto,
+  zRoundsApiError400Error,
+  zRoundsApiError400InvalidBefore,
+  zRoundsApiError400InvalidIsSatStrike,
+  zRoundsApiError400InvalidRange,
+  zRoundsApiError500Error,
   zSatrushConfigDto,
   zSatsVaultDto,
   zSnapshotDto,
@@ -1856,11 +2864,29 @@ async function unwrap(promise) {
   zTileStakeDto,
   zU128Dto,
   zU64Dto,
+  zUserClaimsApiError400Error,
+  zUserClaimsApiError400InvalidAddress,
+  zUserClaimsApiError400InvalidBefore,
+  zUserClaimsApiError400InvalidRange,
+  zUserClaimsApiError500Error,
   zUserDeploymentsApiError400Error,
   zUserDeploymentsApiError400InvalidAddress,
+  zUserDeploymentsApiError400InvalidBefore,
+  zUserDeploymentsApiError400InvalidRange,
   zUserDeploymentsApiError500Error,
+  zUserHashrateApiError400Error,
+  zUserHashrateApiError400InvalidAddress,
+  zUserHashrateApiError400InvalidBefore,
+  zUserHashrateApiError400InvalidRange,
+  zUserHashrateApiError500Error,
   zUserProfileApiError400Error,
   zUserProfileApiError400InvalidAddress,
+  zUserVaultEntriesApiError400Error,
+  zUserVaultEntriesApiError400InvalidAddress,
+  zUserVaultEntriesApiError400InvalidBefore,
+  zUserVaultEntriesApiError400InvalidRange,
+  zUserVaultEntriesApiError400InvalidWinsOnly,
+  zUserVaultEntriesApiError500Error,
   zValidationErrorCodeErrorBody,
   zValidationErrorCodeValidationDetailsErrorBody
 });