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

package/dist/index.js

@@ -1,3 +1,650 @@
-export { stacksApi } from "./stacks-api/index.js";
-export { queries } from "./queries/index.js";
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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
+import * as v from "valibot";
+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
+import * as v2 from "valibot";
+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
+import * as v3 from "valibot";
+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
+import * as v4 from "valibot";
+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
+import * as v5 from "valibot";
+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
+import * as v6 from "valibot";
+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
+import * as v7 from "valibot";
+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
+import * as v8 from "valibot";
+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
+import * as v9 from "valibot";
+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
+import * as v10 from "valibot";
+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);
+}
+export {
+  stacks_api_exports as stacksApi
+};

package/package.json

@@ -1,23 +1,31 @@
 {
   "name": "@secretkeylabs/stacks-tools",
-  "version": "0.2.0",
+  "version": "0.3.0-6a691d3",
   "type": "module",
   "files": [
     "dist"
   ],
   "main": "dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.js",
+      "default": "./dist/index.cjs"
+    }
+  },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup",
     "check-format": "prettier --check .",
     "format": "prettier --write .",
     "check-types": "tsc --noEmit",
-    "check-exports": "attw --pack . --ignore-rules=cjs-resolves-to-esm",
-    "ci": "bun run build && bun run check-format && bun run check-exports"
+    "check-exports": "attw --pack .",
+    "ci": "bun run check-types && bun run check-format && bun run build && bun run check-exports"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.15.4",
     "@types/bun": "latest",
-    "prettier": "^3.3.3"
+    "prettier": "^3.3.3",
+    "tsup": "^8.2.4"
   },
   "peerDependencies": {
     "typescript": "^5.0.0",

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/pox4-api/burn-height-to-reward-cycle.d.ts

@@ -1,7 +0,0 @@
-import type { ApiRequestOptions } from "../stacks-api/types.js";
-import { type Result } from "../utils/safe.js";
-type Args = {
-    burnHeight: number;
-} & ApiRequestOptions;
-export declare function burnHeightToRewardCycle(_args: Args): Promise<Result<number>>;
-export {};

package/dist/pox4-api/burn-height-to-reward-cycle.js

@@ -1,6 +0,0 @@
-import { success } from "../utils/safe.js";
-export async function burnHeightToRewardCycle(_args) {
-    // TODO
-    return success(0);
-}
-//# sourceMappingURL=burn-height-to-reward-cycle.js.map

package/dist/pox4-api/burn-height-to-reward-cycle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"burn-height-to-reward-cycle.js","sourceRoot":"","sources":["../../src/pox4-api/burn-height-to-reward-cycle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAe,MAAM,kBAAkB,CAAC;AAMxD,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,KAAW;IAEX,OAAO;IACP,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC"}