@satrush/api 0.1.0 → 0.1.1

package/dist/index.js

@@ -18,6 +18,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 = ({
@@ -895,9 +980,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
 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({
@@ -910,8 +1025,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 +1103,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()),
@@ -967,6 +1138,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 {
@@ -1007,6 +1196,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
@@ -1049,7 +1263,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);
@@ -1066,17 +1284,31 @@ export {
   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
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@satrush/api",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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"