@satrush/api 0.1.0 → 0.1.2

package/dist/index.js

@@ -18,6 +18,140 @@ var extraPrefixesMap = {
   $query_: "query"
 };
 var extraPrefixes = Object.entries(extraPrefixesMap);
+var buildKeyMap = (fields, map) => {
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+  }
+  for (const config of fields) {
+    if ("in" in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map
+        });
+      }
+    } else if ("key" in config) {
+      map.set(config.key, {
+        map: config.map
+      });
+    } else if (config.args) {
+      buildKeyMap(config.args, map);
+    }
+  }
+  return map;
+};
+var stripEmptySlots = (params) => {
+  for (const [slot, value] of Object.entries(params)) {
+    if (value && typeof value === "object" && !Object.keys(value).length) {
+      delete params[slot];
+    }
+  }
+};
+var buildClientParams = (args, fields) => {
+  const params = {
+    body: {},
+    headers: {},
+    path: {},
+    query: {}
+  };
+  const map = buildKeyMap(fields);
+  let config;
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index];
+    }
+    if (!config) {
+      continue;
+    }
+    if ("in" in config) {
+      if (config.key) {
+        const field = map.get(config.key);
+        const name = field.map || config.key;
+        if (field.in) {
+          params[field.in][name] = arg;
+        }
+      } else {
+        params.body = arg;
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key);
+        if (field) {
+          if (field.in) {
+            const name = field.map || key;
+            params[field.in][name] = value;
+          } else {
+            params[field.map] = value;
+          }
+        } else {
+          const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
+          if (extra) {
+            const [prefix, slot] = extra;
+            params[slot][key.slice(prefix.length)] = value;
+          } else if ("allowExtra" in config && config.allowExtra) {
+            for (const [slot, allowed] of Object.entries(config.allowExtra)) {
+              if (allowed) {
+                params[slot][key] = value;
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  stripEmptySlots(params);
+  return params;
+};
+
+// src/utils/sse.ts
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var applySseResponseTransforms = async (payload) => {
+  if (!isRecord(payload)) return payload;
+  return payload;
+};
+
+// src/utils/transforms.ts
+var snakeToCamel = (value) => value.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+var camelToSnake = (value) => value.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+var isPlainObject = (value) => !!value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+var mapKeysDeep = (value, mapKey) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => mapKeysDeep(item, mapKey));
+  }
+  if (isPlainObject(value)) {
+    const next = {};
+    for (const [key, val] of Object.entries(value)) {
+      next[mapKey(key)] = mapKeysDeep(val, mapKey);
+    }
+    return next;
+  }
+  return value;
+};
+var shouldTransformBody = (value) => isPlainObject(value) || Array.isArray(value);
+var snakecaseQuerySerializerParams = (value) => {
+  if (!isPlainObject(value)) return value;
+  if (!isPlainObject(value.parameters)) return value;
+  const nextParameters = {};
+  for (const [key, param] of Object.entries(value.parameters)) {
+    nextParameters[camelToSnake(key)] = param;
+  }
+  return { ...value, parameters: nextParameters };
+};
+var applyRequestCaseTransforms = (options) => {
+  const next = { ...options };
+  if ("query" in next && isPlainObject(next.query)) {
+    next.query = mapKeysDeep(next.query, camelToSnake);
+  }
+  if ("querySerializer" in next && next.querySerializer) {
+    next.querySerializer = snakecaseQuerySerializerParams(next.querySerializer);
+  }
+  if ("body" in next && shouldTransformBody(next.body)) {
+    next.body = mapKeysDeep(next.body, camelToSnake);
+  }
+  return next;
+};
+var applyResponseCaseTransforms = (value) => mapKeysDeep(value, snakeToCamel);
 
 // src/generated/core/serverSentEvents.gen.ts
 var createSseClient = ({
@@ -109,9 +243,11 @@ var createSseClient = ({
                 }
               }
               if (parsedJson) {
+                data = applyResponseCaseTransforms(data);
                 if (responseValidator) {
                   await responseValidator(data);
                 }
+                data = await applySseResponseTransforms(data);
                 if (responseTransformer) {
                   data = await responseTransformer(data);
                 }
@@ -367,48 +503,6 @@ function getValidRequestBody(options) {
   return void 0;
 }
 
-// src/utils/transforms.ts
-var snakeToCamel = (value) => value.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
-var camelToSnake = (value) => value.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
-var isPlainObject = (value) => !!value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
-var mapKeysDeep = (value, mapKey) => {
-  if (Array.isArray(value)) {
-    return value.map((item) => mapKeysDeep(item, mapKey));
-  }
-  if (isPlainObject(value)) {
-    const next = {};
-    for (const [key, val] of Object.entries(value)) {
-      next[mapKey(key)] = mapKeysDeep(val, mapKey);
-    }
-    return next;
-  }
-  return value;
-};
-var shouldTransformBody = (value) => isPlainObject(value) || Array.isArray(value);
-var snakecaseQuerySerializerParams = (value) => {
-  if (!isPlainObject(value)) return value;
-  if (!isPlainObject(value.parameters)) return value;
-  const nextParameters = {};
-  for (const [key, param] of Object.entries(value.parameters)) {
-    nextParameters[camelToSnake(key)] = param;
-  }
-  return { ...value, parameters: nextParameters };
-};
-var applyRequestCaseTransforms = (options) => {
-  const next = { ...options };
-  if ("query" in next && isPlainObject(next.query)) {
-    next.query = mapKeysDeep(next.query, camelToSnake);
-  }
-  if ("querySerializer" in next && next.querySerializer) {
-    next.querySerializer = snakecaseQuerySerializerParams(next.querySerializer);
-  }
-  if ("body" in next && shouldTransformBody(next.body)) {
-    next.body = mapKeysDeep(next.body, camelToSnake);
-  }
-  return next;
-};
-var applyResponseCaseTransforms = (value) => mapKeysDeep(value, snakeToCamel);
-
 // src/generated/core/auth.gen.ts
 var getAuthToken = async (auth, callback) => {
   const token = typeof callback === "function" ? await callback(auth) : callback;
@@ -895,14 +989,64 @@ var getBoardResponseTransformer = async (data) => {
   data.data = boardDtoSchemaResponseTransformer(data.data);
   return data;
 };
+var publicDeploymentDtoSchemaResponseTransformer = (data) => {
+  data.deployedUsdAmount = u64DtoSchemaResponseTransformer(data.deployedUsdAmount);
+  return data;
+};
+var minerDtoSchemaResponseTransformer = (data) => {
+  data.hashrateAmount = u64DtoSchemaResponseTransformer(data.hashrateAmount);
+  data.unclaimedBtcShares = u64DtoSchemaResponseTransformer(data.unclaimedBtcShares);
+  data.unclaimedUsdAmount = u64DtoSchemaResponseTransformer(data.unclaimedUsdAmount);
+  return data;
+};
+var profileDtoSchemaResponseTransformer = (data) => {
+  data.deployments = data.deployments.map((item) => publicDeploymentDtoSchemaResponseTransformer(item));
+  data.miner = minerDtoSchemaResponseTransformer(data.miner);
+  return data;
+};
+var snapshotDtoSchemaResponseTransformer = (data) => {
+  data.board = boardDtoSchemaResponseTransformer(data.board);
+  if (data.profile) {
+    data.profile = profileDtoSchemaResponseTransformer(data.profile);
+  }
+  return data;
+};
+var sseResponseSnapshotSchemaResponseTransformer = (data) => {
+  data = snapshotDtoSchemaResponseTransformer(data);
+  return data;
+};
+var sseResponseSchemaResponseTransformer = (data) => {
+  data = sseResponseSnapshotSchemaResponseTransformer(data);
+  return data;
+};
+var sseResponseTransformer = async (data) => {
+  data = sseResponseSchemaResponseTransformer(data);
+  return data;
+};
+var getUserProfileResponseTransformer = async (data) => {
+  data.data = profileDtoSchemaResponseTransformer(data.data);
+  return data;
+};
 
 // src/generated/zod.gen.ts
 import * as z from "zod";
+var zBadRequestErrorCodeErrorBody = z.object({
+  code: z.enum([
+    "invalid_path",
+    "invalid_query",
+    "invalid_body"
+  ])
+});
+var zFieldError = z.object({
+  field: z.string(),
+  message: z.string()
+});
 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 zPubkeyDto = z.string().regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
 var zRoundStateDto = z.enum([
   "active",
@@ -910,8 +1054,37 @@ var zRoundStateDto = z.enum([
   "settled",
   "finished"
 ]);
+var zSatrushConfigDto = z.object({
+  address: zPubkeyDto,
+  btcMint: zPubkeyDto,
+  epochFeeBps: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  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" }),
+  usdMint: zPubkeyDto
+});
 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 zMinerDto = z.object({
+  authority: zPubkeyDto,
+  currentStreakCount: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  hashrateAmount: zU64Dto,
+  lastMinedRoundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  unclaimedBtcShares: zU64Dto,
+  unclaimedUsdAmount: zU64Dto
+});
+var zPublicDeploymentDto = z.object({
+  address: zPubkeyDto,
+  deployedUsdAmount: zU64Dto,
+  roundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
+  selectionMask: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" })
+});
+var zProfileDto = z.object({
+  deployments: z.array(zPublicDeploymentDto),
+  miner: zMinerDto
+});
 var zStrikeJackpotDto = z.object({
   btcAmount: zU64Dto,
   lastTriggerRoundId: z.int().gte(0).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
@@ -959,6 +1132,47 @@ var zBoardDto = z.object({
   startSlot: zU64Dto,
   strike: zStrikeJackpotDto
 });
+var zSnapshotDto = z.object({
+  board: zBoardDto,
+  entity: zNotificationEntity,
+  profile: z.optional(z.union([
+    z.null(),
+    zProfileDto
+  ]))
+});
+var zSseResponseSnapshot = zSnapshotDto.and(z.object({
+  entity: z.enum(["state_snapshot"])
+}));
+var zSseResponse = z.object({
+  entity: z.literal("state_snapshot")
+}).and(zSseResponseSnapshot);
+var zUserProfileApiError400InvalidAddress = z.object({
+  code: z.enum(["invalid_address"])
+});
+var zUserProfileApiError400Error = z.union([
+  z.object({
+    code: z.literal("invalid_address")
+  }).and(zUserProfileApiError400InvalidAddress),
+  z.object({
+    code: z.union([
+      z.literal("invalid_body"),
+      z.literal("invalid_path"),
+      z.literal("invalid_query")
+    ])
+  }).and(zBadRequestErrorCodeErrorBody)
+]);
+var zValidationErrorCodeErrorBody = z.object({
+  code: z.enum(["validation_failed"]),
+  data: z.optional(z.object({
+    errors: z.array(zFieldError)
+  }))
+});
+var zValidationErrorCodeValidationDetailsErrorBody = z.object({
+  code: z.enum(["validation_failed"]),
+  data: z.optional(z.object({
+    errors: z.array(zFieldError)
+  }))
+});
 var zGetBoardData = z.object({
   body: z.optional(z.never()),
   path: z.optional(z.never()),
@@ -967,6 +1181,32 @@ var zGetBoardData = z.object({
 var zGetBoardResponse = z.object({
   data: zBoardDto
 });
+var zGetConfigData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.never())
+});
+var zGetConfigResponse = z.object({
+  data: zSatrushConfigDto
+});
+var zSseData = z.object({
+  body: z.optional(z.never()),
+  path: z.optional(z.never()),
+  query: z.optional(z.object({
+    wallet: z.optional(z.string())
+  }))
+});
+var zSseResponse2 = zSseResponse;
+var zGetUserProfileData = z.object({
+  body: z.optional(z.never()),
+  path: z.object({
+    address: z.string()
+  }),
+  query: z.optional(z.never())
+});
+var zGetUserProfileResponse = z.object({
+  data: zProfileDto
+});
 
 // src/generated/sdk.gen.ts
 var HeyApiClient = class {
@@ -1007,9 +1247,49 @@ var SatrushBackendSdk = class _SatrushBackendSdk extends HeyApiClient {
       ...options
     });
   }
+  /**
+   * Request config
+   */
+  getConfig(options) {
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetConfigData.parseAsync(data),
+      responseValidator: async (data) => await zGetConfigResponse.parseAsync(data),
+      url: "/v1/config",
+      ...options
+    });
+  }
+  /**
+   * Subscribe for SSE stream
+   */
+  sse(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "wallet" }] }]);
+    return (options?.client ?? this.client).sse.get({
+      requestValidator: async (data) => await zSseData.parseAsync(data),
+      responseTransformer: sseResponseTransformer,
+      responseValidator: async (data) => await zSseResponse2.parseAsync(data),
+      url: "/v1/streams/sse",
+      ...options,
+      ...params
+    });
+  }
+  /**
+   * Request user profile
+   */
+  getUserProfile(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "address" }] }]);
+    return (options?.client ?? this.client).get({
+      requestValidator: async (data) => await zGetUserProfileData.parseAsync(data),
+      responseTransformer: getUserProfileResponseTransformer,
+      responseValidator: async (data) => await zGetUserProfileResponse.parseAsync(data),
+      url: "/v1/user/{address}/profile",
+      ...options,
+      ...params
+    });
+  }
 };
 
 // src/generated/types.gen.ts
+var NotificationEntity = { STATE_SNAPSHOT: "state_snapshot" };
 var RoundStateDto = {
   ACTIVE: "active",
   REVEALED: "revealed",
@@ -1049,7 +1329,11 @@ async function unwrap(promise) {
   if (res && typeof res === "object" && "response" in res) {
     const sdkRes = res;
     if ("error" in sdkRes && sdkRes.error !== void 0) {
-      throw new SatrushBackendSdkError(String(sdkRes.error), sdkRes.response?.status ?? 0, sdkRes.error);
+      throw new SatrushBackendSdkError(
+        String(sdkRes.error),
+        sdkRes.response?.status ?? 0,
+        sdkRes.error
+      );
     }
     if ("data" in sdkRes) {
       return unwrapData(sdkRes.data);
@@ -1058,6 +1342,7 @@ async function unwrap(promise) {
   return unwrapData(res);
 }
 export {
+  NotificationEntity,
   RoundStateDto,
   SatrushBackendSdk,
   SatrushBackendSdkError,
@@ -1066,17 +1351,37 @@ export {
   isSatrushSdkError,
   satrushSdkErrorInterceptor,
   unwrap,
+  zBadRequestErrorCodeErrorBody,
   zBoardDto,
+  zFieldError,
   zGetBoardData,
   zGetBoardResponse,
+  zGetConfigData,
+  zGetConfigResponse,
+  zGetUserProfileData,
+  zGetUserProfileResponse,
   zI128Dto,
   zI64Dto,
   zInternalErrorCodeErrorBody,
+  zMinerDto,
+  zNotificationEntity,
+  zProfileDto,
   zPubkeyDto,
+  zPublicDeploymentDto,
   zRoundDto,
   zRoundStateDto,
+  zSatrushConfigDto,
+  zSnapshotDto,
+  zSseData,
+  zSseResponse,
+  zSseResponse2,
+  zSseResponseSnapshot,
   zStrikeJackpotDto,
   zTileStakeDto,
   zU128Dto,
-  zU64Dto
+  zU64Dto,
+  zUserProfileApiError400Error,
+  zUserProfileApiError400InvalidAddress,
+  zValidationErrorCodeErrorBody,
+  zValidationErrorCodeValidationDetailsErrorBody
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@satrush/api",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -24,6 +24,7 @@
     "decimal.js": "^10.5.0",
     "dotenv": "^17.4.2",
     "eslint": "^10.6.0",
+    "globals": "^17.7.0",
     "tsup": "^8.3.5",
     "typescript": "6.0.3",
     "vite-tsconfig-paths": "^6.1.1",
@@ -44,6 +45,8 @@
     "eslint:fix": "eslint \"**/*.ts\" --fix",
     "type-check": "tsc -p .",
     "lint": "pnpm eslint && pnpm type-check",
+    "prettier": "prettier . --write",
+    "format": "pnpm prettier && pnpm eslint:fix",
     "test": "vitest run --disable-console-intercept",
     "test:start-server": "node scripts/startTestsServer.mjs",
     "test:watch": "vitest watch"