@secretkeylabs/stacks-tools 0.4.0-98de979 → 0.4.0-da5eb9d

package/dist/index.js

@@ -151,6 +151,12 @@ async function latestNonce(opts) {
   return success(validationResult.output);
 }
 
+// src/stacks-api/accounts/index.ts
+var accounts = {
+  balances,
+  latestNonce
+};
+
 // src/stacks-api/types.ts
 import * as v3 from "valibot";
 var baseListResponseSchema = v3.object({
@@ -224,6 +230,52 @@ async function getBlock(opts) {
   return success(validationResult.output);
 }
 
+// src/stacks-api/blocks/index.ts
+var blocks = {
+  getBlock
+};
+
+// src/stacks-api/faucets/stx.ts
+async function stx(opts) {
+  const search = new URLSearchParams();
+  search.append("address", opts.address);
+  if (opts.stacking) search.append("stacking", "true");
+  const init = {};
+  if (opts.apiKeyConfig) {
+    init.headers = {
+      [opts.apiKeyConfig.header]: opts.apiKeyConfig.key
+    };
+  }
+  init.method = "POST";
+  const endpoint = `${opts.baseUrl}/extended/v1/faucets/stx?${search}`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchStxError",
+      message: "Failed to fetch STX.",
+      data: {
+        status: res.status,
+        statusText: res.statusText,
+        bodyParseResult: await safePromise(res.json())
+      }
+    });
+  }
+  const [jsonError, data] = await safePromise(res.json());
+  if (jsonError) {
+    return error({
+      name: "ParseBodyError",
+      message: "Failed to parse response body as JSON.",
+      data: jsonError
+    });
+  }
+  return success(data);
+}
+
+// src/stacks-api/faucets/index.ts
+var faucets = {
+  stx
+};
+
 // src/stacks-api/info/core-api.ts
 import * as v5 from "valibot";
 var CoreApiResponseSchema = v5.object({
@@ -376,6 +428,12 @@ async function poxDetails(args) {
   return success(validationResult.output);
 }
 
+// src/stacks-api/info/index.ts
+var info = {
+  coreApi,
+  poxDetails
+};
+
 // src/stacks-api/proof-of-transfer/cycle.ts
 import * as v7 from "valibot";
 var responseSchema4 = v7.object({
@@ -664,6 +722,15 @@ async function stackersForSignerInCycle(opts) {
   return success(validationResult.output);
 }
 
+// src/stacks-api/proof-of-transfer/index.ts
+var proofOfTransfer = {
+  cycle,
+  cycles,
+  signerInCycle,
+  signersInCycle,
+  stackersForSignerInCycle
+};
+
 // src/stacks-api/smart-contracts/read-only.ts
 import * as v12 from "valibot";
 var readOnlyResponseSchema = v12.variant("okay", [
@@ -726,6 +793,11 @@ async function readOnly(args) {
   return success(validationResult.output);
 }
 
+// src/stacks-api/smart-contracts/index.ts
+var smartContracts = {
+  readOnly
+};
+
 // src/stacks-api/stacking-pool/members.ts
 import * as v13 from "valibot";
 var memberSchema = v13.object({
@@ -742,22 +814,20 @@ var membersResponseSchema = v13.object({
   total: v13.number(),
   results: v13.array(memberSchema)
 });
-async function members(opts, apiOpts) {
+async function members(args) {
   const search = new URLSearchParams();
-  if (opts.afterBlock) search.append("after_block", opts.afterBlock.toString());
-  if (opts.unanchored) search.append("unanchored", "true");
-  if (opts.limit) search.append("limit", opts.limit.toString());
-  if (opts.offset) search.append("offset", opts.offset.toString());
+  if (args.afterBlock) search.append("after_block", args.afterBlock.toString());
+  if (args.unanchored) search.append("unanchored", "true");
+  if (args.limit) search.append("limit", args.limit.toString());
+  if (args.offset) search.append("offset", args.offset.toString());
   const init = {};
-  if (apiOpts.apiKeyConfig) {
+  if (args.apiKeyConfig) {
     init.headers = {
-      [apiOpts.apiKeyConfig.header]: apiOpts.apiKeyConfig.key
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
     };
   }
-  const res = await fetch(
-    `${apiOpts.baseUrl}/extended/beta/stacking/${opts.poolPrincipal}/delegations?${search}`,
-    init
-  );
+  const endpoint = `${args.baseUrl}/extended/v1/pox4/${args.poolPrincipal}/delegations?${search}`;
+  const res = await fetch(endpoint, init);
   if (!res.ok) {
     return error({
       name: "FetchMembersError",
@@ -788,6 +858,11 @@ async function members(opts, apiOpts) {
   return success(validationResult.output);
 }
 
+// src/stacks-api/stacking-pool/index.ts
+var stackingPool = {
+  members
+};
+
 // src/stacks-api/transactions/schemas.ts
 import * as v14 from "valibot";
 var baseTransactionSchema = v14.object({
@@ -991,20 +1066,89 @@ async function getTransaction(args) {
   return success(validationResult.output);
 }
 
+// src/stacks-api/transactions/index.ts
+var transactions = {
+  addressTransactions,
+  getTransaction
+};
+
 // src/stacks-api/index.ts
-var accounts = { balances, latestNonce };
-var blocks = { getBlock };
-var info = { coreApi, poxDetails };
-var proofOfTransfer = {
-  cycle,
-  cycles,
-  signerInCycle,
-  signersInCycle,
-  stackersForSignerInCycle
+var stacksApi = {
+  accounts,
+  blocks,
+  faucets,
+  info,
+  proofOfTransfer,
+  smartContracts,
+  stackingPool,
+  transactions
+};
+
+// src/stacks-rpc-api/smart-contracts/map-entry.ts
+import * as v17 from "valibot";
+var mapEntryResponseSchema = v17.object({
+  /**
+   * Hex-encoded string of clarity value. It is always an optional tuple.
+   */
+  data: v17.string(),
+  /**
+   * Hex-encoded string of the MARF proof for the data
+   */
+  proof: v17.optional(v17.string())
+});
+async function mapEntry(args) {
+  const search = new URLSearchParams();
+  if (args.proof === 0) search.append("proof", "0");
+  if (args.tip) search.append("tip", args.tip);
+  const init = {};
+  if (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  init.method = "POST";
+  init.body = args.mapKey;
+  const endpoint = `${args.baseUrl}/v2/map_entry/${args.contractAddress}/${args.contractName}/${args.mapName}?${search}`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchMapEntryError",
+      message: "Failed to fetch map entry.",
+      data: {
+        status: res.status,
+        statusText: res.statusText,
+        bodyParseResult: await safePromise(res.json())
+      }
+    });
+  }
+  const [jsonError, data] = await safePromise(res.json());
+  if (jsonError) {
+    return error({
+      name: "ParseBodyError",
+      message: "Failed to parse response body as JSON.",
+      data: jsonError
+    });
+  }
+  const validationResult = v17.safeParse(mapEntryResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate response data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-rpc-api/smart-contracts/index.ts
+var smartContracts2 = {
+  mapEntry
+};
+
+// src/stacks-rpc-api/index.ts
+var stacksRpcApi = {
+  smartContracts: smartContracts2
 };
-var smartContracts = { readOnly };
-var stackingPool = { members };
-var transactions = { addressTransactions, getTransaction };
 
 // src/utils/call-rate-limited-api.ts
 import { backOff } from "exponential-backoff";
@@ -1042,22 +1186,73 @@ async function safeCallRateLimitedApi(fn, options) {
   }
 }
 
-// src/index.ts
-var stacksApi = {
-  accounts,
-  blocks,
-  info,
-  proofOfTransfer,
-  smartContracts,
-  stackingPool,
-  transactions
+// src/queries/get-signer-stacked-amount.ts
+async function getSignerStackedAmount(args) {
+  let totalLocked = 0n;
+  const { identifier, ...rest } = args;
+  let hasMore = true;
+  let offset = 0;
+  let found = false;
+  const limit = 200;
+  while (hasMore && !found) {
+    const [error2, data] = await safeCallRateLimitedApi(
+      () => signersInCycle({
+        ...rest,
+        limit
+      })
+    );
+    if (error2) {
+      return error({
+        name: "GetSignerTotalLockedError",
+        message: "Failed to get signer total locked.",
+        data: {
+          error: error2
+        }
+      });
+    }
+    for (const signer of data.results) {
+      if (identifier.type === "address") {
+        if (signer.signer_address === identifier.signerAddress) {
+          totalLocked = BigInt(signer.stacked_amount);
+          found = true;
+          break;
+        }
+      } else {
+        if (signer.signing_key === identifier.signerPublicKey) {
+          totalLocked = BigInt(signer.stacked_amount);
+          found = true;
+          break;
+        }
+      }
+    }
+    offset += data.results.length;
+    hasMore = offset < data.total;
+  }
+  if (!found) {
+    return error({
+      name: "SignerNotFound",
+      message: "Signer not found.",
+      data: {
+        identifier,
+        cycle: args.cycleNumber
+      }
+    });
+  }
+  return success(totalLocked);
+}
+
+// src/queries/index.ts
+var queries = {
+  getSignerStackedAmount
 };
 export {
   callRateLimitedApi,
   error,
+  queries,
   safeCall,
   safeCallRateLimitedApi,
   safePromise,
   stacksApi,
+  stacksRpcApi,
   success
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@secretkeylabs/stacks-tools",
-  "version": "0.4.0-98de979",
+  "version": "0.4.0-da5eb9d",
   "type": "module",
   "files": [
     "dist"