@satrush/api 0.1.0 → 0.1.1

package/README.md

@@ -14,16 +14,14 @@ pnpm add @satrush/api
 ## Usage
 
 ```ts
-import {SatrushBackendSdk, createClient, unwrap} from "@satrush/api";
+import { SatrushBackendSdk, createClient, unwrap } from '@satrush/api';
 
 const client = createClient({
-    baseUrl: "https://api.satrush.io/api",
+  baseUrl: 'https://api.satrush.io/api'
 });
-const sdk = new SatrushBackendSdk({client});
+const sdk = new SatrushBackendSdk({ client });
 
-const board = await unwrap(
-    sdk.getBoard(),
-);
+const board = await unwrap(sdk.getBoard());
 ```
 
 ## How the SDK works
@@ -32,10 +30,10 @@ const board = await unwrap(
 - Pre-processing: `scripts/camelizeOpenapi.mjs` produces `openapi.camel.yaml` (converts snake_case into cameCase).
 - Code generation: `@hey-api/openapi-ts` generates `src/generated/**`.
 - Post-processing: `scripts/postprocessOpenapi.mjs` patches the generated client to:
-    - snake_case request payloads/params
-    - camelCase response payloads
-    - apply response transforms before validators where needed
-    - apply custom SSE transforms (see below)
+  - snake_case request payloads/params
+  - camelCase response payloads
+  - apply response transforms before validators where needed
+  - apply custom SSE transforms (see below)
 
 ## Case transforms and scalar transforms
 
@@ -59,15 +57,19 @@ To throw on non-2xx responses for all SDK calls, set `throwOnError: true` on the
 and attach the built-in interceptor that wraps errors as `SatRushSdkError`:
 
 ```ts
-import {SatRushBackendSdk, createClient, satrushSdkErrorInterceptor} from "@satrush/api";
+import {
+  SatRushBackendSdk,
+  createClient,
+  satrushSdkErrorInterceptor
+} from '@satrush/api';
 
 const client = createClient({
-    baseUrl: "https://api.satrush.io/api",
-    throwOnError: true,
+  baseUrl: 'https://api.satrush.io/api',
+  throwOnError: true
 });
 client.interceptors.error.use(satrushSdkErrorInterceptor);
 
-const sdk = new SatRushBackendSdk({client});
+const sdk = new SatRushBackendSdk({ client });
 ```
 
 `SatRushSdkError` includes the HTTP status and the original error payload in `cause`.
@@ -75,9 +77,9 @@ const sdk = new SatRushBackendSdk({client});
 If you already have a client, you can also enable it later:
 
 ```ts
-import {client, satrushSdkErrorInterceptor} from "@satrush/api";
+import { client, satrushSdkErrorInterceptor } from '@satrush/api';
 
-client.setConfig({throwOnError: true});
+client.setConfig({ throwOnError: true });
 client.interceptors.error.use(satrushSdkErrorInterceptor);
 ```
 
@@ -85,13 +87,13 @@ When `responseStyle` is set to `"data"`, SDK calls return only the response payl
 (no `{ data, error, request, response }` wrapper). This is useful for simpler call sites:
 
 ```ts
-import {SatRushBackendSdk, createClient} from "@satrush/api";
+import { SatRushBackendSdk, createClient } from '@satrush/api';
 
 const client = createClient({
-    baseUrl: "https://api.satrush.io/api",
-    responseStyle: "data",
+  baseUrl: 'https://api.satrush.io/api',
+  responseStyle: 'data'
 });
 
-const sdk = new SatrushBackendSdk({client});
+const sdk = new SatrushBackendSdk({ client });
 const board = await sdk.getBoard();
 ```

package/dist/index.cjs

@@ -37,19 +37,33 @@ __export(index_exports, {
   isSatrushSdkError: () => isSatrushSdkError,
   satrushSdkErrorInterceptor: () => satrushSdkErrorInterceptor,
   unwrap: () => unwrap,
+  zBadRequestErrorCodeErrorBody: () => zBadRequestErrorCodeErrorBody,
   zBoardDto: () => zBoardDto,
+  zFieldError: () => zFieldError,
   zGetBoardData: () => zGetBoardData,
   zGetBoardResponse: () => zGetBoardResponse,
+  zGetConfigData: () => zGetConfigData,
+  zGetConfigResponse: () => zGetConfigResponse,
+  zGetUserProfileData: () => zGetUserProfileData,
+  zGetUserProfileResponse: () => zGetUserProfileResponse,
   zI128Dto: () => zI128Dto,
   zI64Dto: () => zI64Dto,
   zInternalErrorCodeErrorBody: () => zInternalErrorCodeErrorBody,
+  zMinerDto: () => zMinerDto,
+  zProfileDto: () => zProfileDto,
   zPubkeyDto: () => zPubkeyDto,
+  zPublicDeploymentDto: () => zPublicDeploymentDto,
   zRoundDto: () => zRoundDto,
   zRoundStateDto: () => zRoundStateDto,
+  zSatrushConfigDto: () => zSatrushConfigDto,
   zStrikeJackpotDto: () => zStrikeJackpotDto,
   zTileStakeDto: () => zTileStakeDto,
   zU128Dto: () => zU128Dto,
-  zU64Dto: () => zU64Dto
+  zU64Dto: () => zU64Dto,
+  zUserProfileApiError400Error: () => zUserProfileApiError400Error,
+  zUserProfileApiError400InvalidAddress: () => zUserProfileApiError400InvalidAddress,
+  zValidationErrorCodeErrorBody: () => zValidationErrorCodeErrorBody,
+  zValidationErrorCodeValidationDetailsErrorBody: () => zValidationErrorCodeValidationDetailsErrorBody
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -73,6 +87,91 @@ 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/generated/core/serverSentEvents.gen.ts
 var createSseClient = ({
@@ -950,9 +1049,39 @@ 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 getUserProfileResponseTransformer = async (data) => {
+  data.data = profileDtoSchemaResponseTransformer(data.data);
+  return data;
+};
 
 // src/generated/zod.gen.ts
 var z = __toESM(require("zod"), 1);
+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({
@@ -965,8 +1094,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" }),
@@ -1014,6 +1172,33 @@ var zBoardDto = z.object({
   startSlot: zU64Dto,
   strike: zStrikeJackpotDto
 });
+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()),
@@ -1022,6 +1207,24 @@ 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 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 {
@@ -1062,6 +1265,31 @@ 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
+    });
+  }
+  /**
+   * 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
@@ -1104,7 +1332,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);
@@ -1122,17 +1354,31 @@ async function unwrap(promise) {
   isSatrushSdkError,
   satrushSdkErrorInterceptor,
   unwrap,
+  zBadRequestErrorCodeErrorBody,
   zBoardDto,
+  zFieldError,
   zGetBoardData,
   zGetBoardResponse,
+  zGetConfigData,
+  zGetConfigResponse,
+  zGetUserProfileData,
+  zGetUserProfileResponse,
   zI128Dto,
   zI64Dto,
   zInternalErrorCodeErrorBody,
+  zMinerDto,
+  zProfileDto,
   zPubkeyDto,
+  zPublicDeploymentDto,
   zRoundDto,
   zRoundStateDto,
+  zSatrushConfigDto,
   zStrikeJackpotDto,
   zTileStakeDto,
   zU128Dto,
-  zU64Dto
+  zU64Dto,
+  zUserProfileApiError400Error,
+  zUserProfileApiError400InvalidAddress,
+  zValidationErrorCodeErrorBody,
+  zValidationErrorCodeValidationDetailsErrorBody
 });