@secretkeylabs/stacks-tools 0.2.0 → 0.3.0-6a691d3

package/dist/index.cjs

@@ -0,0 +1,681 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  stacksApi: () => stacks_api_exports
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/stacks-api/index.ts
+var stacks_api_exports = {};
+__export(stacks_api_exports, {
+  accounts: () => accounts_exports,
+  blocks: () => blocks_exports,
+  info: () => info_exports,
+  proofOfTransfer: () => proof_of_transfer_exports
+});
+
+// src/stacks-api/accounts/index.ts
+var accounts_exports = {};
+__export(accounts_exports, {
+  balances: () => balances
+});
+
+// src/utils/safe.ts
+function success(data) {
+  return [null, data];
+}
+function error(error2) {
+  return [error2, null];
+}
+async function safePromise(promise) {
+  try {
+    return success(await promise);
+  } catch (e) {
+    return error({
+      name: "SafePromiseError",
+      message: "Safe promise rejected.",
+      data: e
+    });
+  }
+}
+
+// src/stacks-api/accounts/balances.ts
+var v = __toESM(require("valibot"), 1);
+var responseSchema = v.object({
+  stx: v.object({
+    balance: v.string(),
+    total_sent: v.string(),
+    total_received: v.string(),
+    total_fees_sent: v.string(),
+    total_miner_rewards_received: v.string(),
+    lock_tx_id: v.string(),
+    locked: v.string(),
+    lock_height: v.number(),
+    burnchain_lock_height: v.number(),
+    burnchain_unlock_height: v.number()
+  }),
+  fungible_tokens: v.record(
+    v.string(),
+    v.object({
+      balance: v.string(),
+      total_sent: v.string(),
+      total_received: v.string()
+    })
+  ),
+  non_fungible_tokens: v.record(
+    v.string(),
+    v.object({
+      count: v.string(),
+      total_sent: v.string(),
+      total_received: v.string()
+    })
+  )
+});
+async function balances(opts) {
+  const search = new URLSearchParams();
+  if (opts.unanchored) search.append("unanchored", "true");
+  if (opts.untilBlock) search.append("until_block", opts.untilBlock.toString());
+  const init = {};
+  if (opts.apiKeyConfig) {
+    init.headers = {
+      [opts.apiKeyConfig.header]: opts.apiKeyConfig.key
+    };
+  }
+  const endpoint = `${opts.baseUrl}/extended/v1/address/${opts.principal}/balances?${search}`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchBalancesError",
+      message: "Failed to fetch balances.",
+      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 = v.safeParse(responseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/blocks/index.ts
+var blocks_exports = {};
+__export(blocks_exports, {
+  getBlock: () => getBlock
+});
+
+// src/stacks-api/types.ts
+var v2 = __toESM(require("valibot"), 1);
+var baseListResponseSchema = v2.object({
+  limit: v2.number(),
+  offset: v2.number(),
+  total: v2.number(),
+  results: v2.array(v2.unknown())
+});
+
+// src/stacks-api/blocks/get-block.ts
+var v3 = __toESM(require("valibot"), 1);
+var responseSchema2 = v3.object({
+  canonical: v3.boolean(),
+  height: v3.number(),
+  hash: v3.string(),
+  block_time: v3.number(),
+  block_time_iso: v3.string(),
+  index_block_hash: v3.string(),
+  parent_block_hash: v3.string(),
+  parent_index_block_hash: v3.string(),
+  burn_block_time: v3.number(),
+  burn_block_time_iso: v3.string(),
+  burn_block_hash: v3.string(),
+  burn_block_height: v3.number(),
+  miner_txid: v3.string(),
+  tx_count: v3.number(),
+  execution_cost_read_count: v3.number(),
+  execution_cost_read_length: v3.number(),
+  execution_cost_runtime: v3.number(),
+  execution_cost_write_count: v3.number(),
+  execution_cost_write_length: v3.number()
+});
+async function getBlock(opts) {
+  const init = {};
+  if (opts.apiKeyConfig) {
+    init.headers = {
+      [opts.apiKeyConfig.header]: opts.apiKeyConfig.key
+    };
+  }
+  const res = await fetch(
+    `${opts.baseUrl}/extended/v2/blocks/${opts.heightOrHash}`,
+    init
+  );
+  if (!res.ok) {
+    return error({
+      name: "FetchBlockError",
+      message: "Failed to fetch block.",
+      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 body.",
+      data: jsonError
+    });
+  }
+  const validationResult = v3.safeParse(responseSchema2, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/info/index.ts
+var info_exports = {};
+__export(info_exports, {
+  coreApi: () => coreApi,
+  poxDetails: () => poxDetails
+});
+
+// src/stacks-api/info/core-api.ts
+var v4 = __toESM(require("valibot"), 1);
+var CoreApiResponseSchema = v4.object({
+  peer_version: v4.number(),
+  pox_consensus: v4.string(),
+  burn_block_height: v4.number(),
+  stable_pox_consensus: v4.string(),
+  stable_burn_block_height: v4.number(),
+  server_version: v4.string(),
+  network_id: v4.number(),
+  parent_network_id: v4.number(),
+  stacks_tip_height: v4.number(),
+  stacks_tip: v4.string(),
+  stacks_tip_consensus_hash: v4.string(),
+  unanchored_tip: v4.string(),
+  exit_at_block_height: v4.number()
+});
+async function coreApi(apiOpts) {
+  const init = {};
+  if (apiOpts.apiKeyConfig) {
+    init.headers = {
+      [apiOpts.apiKeyConfig.header]: apiOpts.apiKeyConfig.key
+    };
+  }
+  const res = await fetch(`${apiOpts.baseUrl}/v2/info`, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchCoreApiError",
+      message: "Failed to fetch.",
+      data: {
+        status: res.status,
+        statusText: res.statusText,
+        bodyParseResult: await safePromise(res.json())
+      }
+    });
+  }
+  const [parseBodyError, data] = await safePromise(res.json());
+  if (parseBodyError) {
+    return error({
+      name: "ParseBodyError",
+      message: "Failed to parse response body as JSON.",
+      data: parseBodyError
+    });
+  }
+  const validationResult = v4.safeParse(CoreApiResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/info/pox-details.ts
+var v5 = __toESM(require("valibot"), 1);
+var poxDetailsResponseSchema = v5.object({
+  contract_id: v5.string(),
+  pox_activation_threshold_ustx: v5.number(),
+  first_burnchain_block_height: v5.number(),
+  current_burnchain_block_height: v5.number(),
+  prepare_phase_block_length: v5.number(),
+  reward_phase_block_length: v5.number(),
+  reward_slots: v5.number(),
+  rejection_fraction: v5.null(),
+  total_liquid_supply_ustx: v5.number(),
+  current_cycle: v5.object({
+    id: v5.number(),
+    min_threshold_ustx: v5.number(),
+    stacked_ustx: v5.number(),
+    is_pox_active: v5.boolean()
+  }),
+  next_cycle: v5.object({
+    id: v5.number(),
+    min_threshold_ustx: v5.number(),
+    min_increment_ustx: v5.number(),
+    stacked_ustx: v5.number(),
+    prepare_phase_start_block_height: v5.number(),
+    blocks_until_prepare_phase: v5.number(),
+    reward_phase_start_block_height: v5.number(),
+    blocks_until_reward_phase: v5.number(),
+    ustx_until_pox_rejection: v5.null()
+  }),
+  epochs: v5.array(
+    v5.object({
+      epoch_id: v5.string(),
+      start_height: v5.number(),
+      end_height: v5.number(),
+      block_limit: v5.object({
+        write_length: v5.number(),
+        write_count: v5.number(),
+        read_length: v5.number(),
+        read_count: v5.number(),
+        runtime: v5.number()
+      }),
+      network_epoch: v5.number()
+    })
+  ),
+  min_amount_ustx: v5.number(),
+  prepare_cycle_length: v5.number(),
+  reward_cycle_id: v5.number(),
+  reward_cycle_length: v5.number(),
+  rejection_votes_left_required: v5.null(),
+  next_reward_cycle_in: v5.number(),
+  contract_versions: v5.array(
+    v5.object({
+      contract_id: v5.string(),
+      activation_burnchain_block_height: v5.number(),
+      first_reward_cycle_id: v5.number()
+    })
+  )
+});
+async function poxDetails(args) {
+  const init = {};
+  if (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  const res = await fetch(`${args.baseUrl}/v2/pox`, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchPoxDetailsError",
+      message: "Failed to fetch pox details.",
+      data: {
+        status: res.status,
+        statusText: res.statusText,
+        bodyParseResult: await safePromise(res.json())
+      }
+    });
+  }
+  const [jsonParseError, data] = await safePromise(res.json());
+  if (jsonParseError) {
+    return error({
+      name: "ParseBodyError",
+      message: "Failed to parse pox details response.",
+      data: jsonParseError
+    });
+  }
+  const validationResult = v5.safeParse(poxDetailsResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to parse pox details response.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/proof-of-transfer/index.ts
+var proof_of_transfer_exports = {};
+__export(proof_of_transfer_exports, {
+  cycle: () => cycle,
+  cycles: () => cycles,
+  signerInCycle: () => signerInCycle,
+  signersInCycle: () => signersInCycle,
+  stackersForSignerInCycle: () => stackersForSignerInCycle
+});
+
+// src/stacks-api/proof-of-transfer/cycle.ts
+var v6 = __toESM(require("valibot"), 1);
+var responseSchema3 = v6.object({
+  block_height: v6.number(),
+  index_block_hash: v6.string(),
+  cycle_number: v6.number(),
+  total_weight: v6.number(),
+  total_stacked_amount: v6.string(),
+  total_signers: v6.number()
+});
+async function cycle(opts) {
+  const init = {};
+  if (opts.apiKeyConfig) {
+    init.headers = {
+      [opts.apiKeyConfig.header]: opts.apiKeyConfig.key
+    };
+  }
+  const endpoint = `${opts.baseUrl}/extended/v2/pox/cycles/${opts.cycleNumber}`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchCycleError",
+      message: "Failed to fetch cycle.",
+      data: {
+        endpoint,
+        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 = v6.safeParse(responseSchema3, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/proof-of-transfer/cycles.ts
+var v7 = __toESM(require("valibot"), 1);
+var cycleInfoSchema = v7.object({
+  block_height: v7.number(),
+  index_block_hash: v7.string(),
+  cycle_number: v7.number(),
+  total_weight: v7.number(),
+  total_stacked_amount: v7.string(),
+  total_signers: v7.number()
+});
+var resultsSchema = v7.array(cycleInfoSchema);
+var cyclesResponseSchema = v7.object({
+  ...baseListResponseSchema.entries,
+  results: resultsSchema
+});
+async function cycles(args) {
+  const search = new URLSearchParams();
+  if (args.limit) search.append("limit", args.limit.toString());
+  if (args.offset) search.append("offset", args.offset.toString());
+  const init = {};
+  if (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  const endpoint = `${args.baseUrl}/extended/v2/pox/cycles`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchCyclesError",
+      message: "Failed to fetch cycles.",
+      data: {
+        endpoint,
+        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 = v7.safeParse(cyclesResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate response data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/proof-of-transfer/signer-in-cycle.ts
+var v8 = __toESM(require("valibot"), 1);
+var signerInCycleResponseSchema = v8.object({
+  signing_key: v8.string(),
+  signer_address: v8.string(),
+  weight: v8.number(),
+  stacked_amount: v8.string(),
+  weight_percent: v8.number(),
+  stacked_amount_percent: v8.number(),
+  solo_stacker_count: v8.number(),
+  pooled_stacker_count: v8.number()
+});
+async function signerInCycle(args) {
+  const init = {};
+  if (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  const signerPublicKey = args.signerPublicKey.startsWith("0x") ? args.signerPublicKey : `0x${args.signerPublicKey}`;
+  const endpoint = `${args.baseUrl}/extended/v2/pox/cycles/${args.cycleId}/signers/${signerPublicKey}`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchSignerInCycleError",
+      message: "Failed to fetch signer in cycle.",
+      data: {
+        ...args,
+        endpoint,
+        status: res.status,
+        statusText: res.statusText
+      }
+    });
+  }
+  const [jsonError, data] = await safePromise(res.json());
+  if (jsonError) {
+    return error({
+      name: "ParseBodyError",
+      message: "Failed to parse response body.",
+      data: {
+        signerPublicKey: args.signerPublicKey,
+        cycleId: args.cycleId,
+        jsonError
+      }
+    });
+  }
+  const validationResult = v8.safeParse(signerInCycleResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate response data.",
+      data: validationResult.issues
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/proof-of-transfer/signers-in-cycle.ts
+var v9 = __toESM(require("valibot"), 1);
+var signerSchema = v9.object({
+  signing_key: v9.string(),
+  signer_address: v9.string(),
+  weight: v9.number(),
+  stacked_amount: v9.string(),
+  weight_percent: v9.number(),
+  stacked_amount_percent: v9.number(),
+  pooled_stacker_count: v9.number(),
+  solo_stacker_count: v9.number()
+});
+var resultsSchema2 = v9.array(signerSchema);
+var signersResponseSchema = v9.object({
+  ...baseListResponseSchema.entries,
+  results: resultsSchema2
+});
+async function signersInCycle(args) {
+  const search = new URLSearchParams();
+  if (args.limit) search.append("limit", args.limit.toString());
+  if (args.offset) search.append("offset", args.offset.toString());
+  const init = {};
+  if (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  const endpoint = `${args.baseUrl}/extended/v2/pox/cycles/${args.cycleNumber}/signers`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchSignersError",
+      message: "Failed to fetch signers.",
+      data: {
+        endpoint,
+        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: {
+        endpoint,
+        bodyParseResult: data
+      }
+    });
+  }
+  const validationResult = v9.safeParse(signersResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate response data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/proof-of-transfer/stackers-for-signer-in-cycle.ts
+var v10 = __toESM(require("valibot"), 1);
+var stackerInfoSchema = v10.object({
+  stacker_address: v10.string(),
+  stacked_amount: v10.string(),
+  pox_address: v10.string(),
+  stacker_type: v10.union([v10.literal("pooled"), v10.literal("solo")])
+});
+var resultsSchema3 = v10.array(stackerInfoSchema);
+var stackersForSignerInCycleResponseSchema = v10.object({
+  ...baseListResponseSchema.entries,
+  results: resultsSchema3
+});
+async function stackersForSignerInCycle(opts) {
+  const search = new URLSearchParams();
+  if (opts.limit) search.append("limit", opts.limit.toString());
+  if (opts.offset) search.append("offset", opts.offset.toString());
+  const init = {};
+  if (opts.apiKeyConfig) {
+    init.headers = {
+      [opts.apiKeyConfig.header]: opts.apiKeyConfig.key
+    };
+  }
+  const endpoint = `${opts.baseUrl}/extended/v2/pox/cycles/${opts.cycleNumber}/signers/${opts.signerPublicKey}/stackers?${search}`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchStackersForSignerInCycleError",
+      message: "Failed to fetch stackers for signer in cycle.",
+      data: {
+        endpoint,
+        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 = v10.safeParse(
+    stackersForSignerInCycleResponseSchema,
+    data
+  );
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate response data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stacksApi
+});