@secretkeylabs/stacks-tools 0.5.0 → 0.6.0-4cfe719

package/dist/index.cjs

@@ -32,6 +32,7 @@ var src_exports = {};
 __export(src_exports, {
   callRateLimitedApi: () => callRateLimitedApi,
   error: () => error,
+  pox4Api: () => pox4Api,
   queries: () => queries,
   safeCall: () => safeCall,
   safeCallRateLimitedApi: () => safeCallRateLimitedApi,
@@ -73,37 +74,6 @@ function safeCall(fn) {
 }
 
 // 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");
@@ -123,7 +93,7 @@ async function balances(opts) {
       data: {
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -135,25 +105,17 @@ async function balances(opts) {
       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);
+  return success(data);
 }
 
 // src/stacks-api/accounts/latest-nonce.ts
-var v2 = __toESM(require("valibot"), 1);
-var responseSchema2 = v2.object({
-  last_mempool_tx_nonce: v2.nullable(v2.number()),
-  last_executed_tx_nonce: v2.nullable(v2.number()),
-  possible_next_nonce: v2.number(),
-  detected_missing_nonces: v2.array(v2.number()),
-  detected_mempool_nonces: v2.array(v2.number())
+var v = __toESM(require("valibot"), 1);
+var responseSchema = v.object({
+  last_mempool_tx_nonce: v.nullable(v.number()),
+  last_executed_tx_nonce: v.nullable(v.number()),
+  possible_next_nonce: v.number(),
+  detected_missing_nonces: v.array(v.number()),
+  detected_mempool_nonces: v.array(v.number())
 });
 async function latestNonce(opts) {
   const init = {};
@@ -172,7 +134,7 @@ async function latestNonce(opts) {
         endpoint,
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -184,7 +146,7 @@ async function latestNonce(opts) {
       data: jsonError
     });
   }
-  const validationResult = v2.safeParse(responseSchema2, data);
+  const validationResult = v.safeParse(responseSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -202,36 +164,36 @@ var accounts = {
 };
 
 // src/stacks-api/types.ts
-var v3 = __toESM(require("valibot"), 1);
-var baseListResponseSchema = v3.object({
-  limit: v3.number(),
-  offset: v3.number(),
-  total: v3.number(),
-  results: v3.array(v3.unknown())
+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 v4 = __toESM(require("valibot"), 1);
-var responseSchema3 = v4.object({
-  canonical: v4.boolean(),
-  height: v4.number(),
-  hash: v4.string(),
-  block_time: v4.number(),
-  block_time_iso: v4.string(),
-  index_block_hash: v4.string(),
-  parent_block_hash: v4.string(),
-  parent_index_block_hash: v4.string(),
-  burn_block_time: v4.number(),
-  burn_block_time_iso: v4.string(),
-  burn_block_hash: v4.string(),
-  burn_block_height: v4.number(),
-  miner_txid: v4.string(),
-  tx_count: v4.number(),
-  execution_cost_read_count: v4.number(),
-  execution_cost_read_length: v4.number(),
-  execution_cost_runtime: v4.number(),
-  execution_cost_write_count: v4.number(),
-  execution_cost_write_length: v4.number()
+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 = {};
@@ -251,7 +213,7 @@ async function getBlock(opts) {
       data: {
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -263,7 +225,7 @@ async function getBlock(opts) {
       data: jsonError
     });
   }
-  const validationResult = v4.safeParse(responseSchema3, data);
+  const validationResult = v3.safeParse(responseSchema2, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -300,7 +262,7 @@ async function stx(opts) {
       data: {
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -321,22 +283,22 @@ var faucets = {
 };
 
 // src/stacks-api/info/core-api.ts
-var v5 = __toESM(require("valibot"), 1);
-var CoreApiResponseSchema = v5.object({
-  peer_version: v5.number(),
-  pox_consensus: v5.string(),
-  burn_block_height: v5.number(),
-  stable_pox_consensus: v5.string(),
-  stable_burn_block_height: v5.number(),
-  server_version: v5.string(),
-  network_id: v5.number(),
-  parent_network_id: v5.number(),
-  stacks_tip_height: v5.number(),
-  stacks_tip: v5.string(),
-  stacks_tip_consensus_hash: v5.string(),
-  unanchored_tip: v5.nullable(v5.string()),
-  unanchored_seq: v5.nullable(v5.string()),
-  exit_at_block_height: v5.nullable(v5.number())
+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.nullable(v4.string()),
+  unanchored_seq: v4.nullable(v4.string()),
+  exit_at_block_height: v4.nullable(v4.number())
 });
 async function coreApi(apiOpts) {
   const init = {};
@@ -353,7 +315,7 @@ async function coreApi(apiOpts) {
       data: {
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -365,7 +327,7 @@ async function coreApi(apiOpts) {
       data: parseBodyError
     });
   }
-  const validationResult = v5.safeParse(CoreApiResponseSchema, data);
+  const validationResult = v4.safeParse(CoreApiResponseSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -376,117 +338,20 @@ async function coreApi(apiOpts) {
   return success(validationResult.output);
 }
 
-// src/stacks-api/info/pox-details.ts
-var v6 = __toESM(require("valibot"), 1);
-var poxDetailsResponseSchema = v6.object({
-  contract_id: v6.string(),
-  pox_activation_threshold_ustx: v6.number(),
-  first_burnchain_block_height: v6.number(),
-  current_burnchain_block_height: v6.number(),
-  prepare_phase_block_length: v6.number(),
-  reward_phase_block_length: v6.number(),
-  reward_slots: v6.number(),
-  rejection_fraction: v6.null(),
-  total_liquid_supply_ustx: v6.number(),
-  current_cycle: v6.object({
-    id: v6.number(),
-    min_threshold_ustx: v6.number(),
-    stacked_ustx: v6.number(),
-    is_pox_active: v6.boolean()
-  }),
-  next_cycle: v6.object({
-    id: v6.number(),
-    min_threshold_ustx: v6.number(),
-    min_increment_ustx: v6.number(),
-    stacked_ustx: v6.number(),
-    prepare_phase_start_block_height: v6.number(),
-    blocks_until_prepare_phase: v6.number(),
-    reward_phase_start_block_height: v6.number(),
-    blocks_until_reward_phase: v6.number(),
-    ustx_until_pox_rejection: v6.null()
-  }),
-  epochs: v6.array(
-    v6.object({
-      epoch_id: v6.string(),
-      start_height: v6.number(),
-      end_height: v6.number(),
-      block_limit: v6.object({
-        write_length: v6.number(),
-        write_count: v6.number(),
-        read_length: v6.number(),
-        read_count: v6.number(),
-        runtime: v6.number()
-      }),
-      network_epoch: v6.number()
-    })
-  ),
-  min_amount_ustx: v6.number(),
-  prepare_cycle_length: v6.number(),
-  reward_cycle_id: v6.number(),
-  reward_cycle_length: v6.number(),
-  rejection_votes_left_required: v6.null(),
-  next_reward_cycle_in: v6.number(),
-  contract_versions: v6.array(
-    v6.object({
-      contract_id: v6.string(),
-      activation_burnchain_block_height: v6.number(),
-      first_reward_cycle_id: v6.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 = v6.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/info/index.ts
 var info = {
-  coreApi,
-  poxDetails
+  coreApi
 };
 
 // src/stacks-api/proof-of-transfer/cycle.ts
-var v7 = __toESM(require("valibot"), 1);
-var responseSchema4 = 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 v5 = __toESM(require("valibot"), 1);
+var responseSchema3 = v5.object({
+  block_height: v5.number(),
+  index_block_hash: v5.string(),
+  cycle_number: v5.number(),
+  total_weight: v5.number(),
+  total_stacked_amount: v5.string(),
+  total_signers: v5.number()
 });
 async function cycle(opts) {
   const init = {};
@@ -505,7 +370,7 @@ async function cycle(opts) {
         endpoint,
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -517,7 +382,7 @@ async function cycle(opts) {
       data: jsonError
     });
   }
-  const validationResult = v7.safeParse(responseSchema4, data);
+  const validationResult = v5.safeParse(responseSchema3, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -529,17 +394,17 @@ async function cycle(opts) {
 }
 
 // src/stacks-api/proof-of-transfer/cycles.ts
-var v8 = __toESM(require("valibot"), 1);
-var cycleInfoSchema = v8.object({
-  block_height: v8.number(),
-  index_block_hash: v8.string(),
-  cycle_number: v8.number(),
-  total_weight: v8.number(),
-  total_stacked_amount: v8.string(),
-  total_signers: v8.number()
+var v6 = __toESM(require("valibot"), 1);
+var cycleInfoSchema = 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()
 });
-var resultsSchema = v8.array(cycleInfoSchema);
-var cyclesResponseSchema = v8.object({
+var resultsSchema = v6.array(cycleInfoSchema);
+var cyclesResponseSchema = v6.object({
   ...baseListResponseSchema.entries,
   results: resultsSchema
 });
@@ -563,7 +428,7 @@ async function cycles(args) {
         endpoint,
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -575,7 +440,7 @@ async function cycles(args) {
       data: jsonError
     });
   }
-  const validationResult = v8.safeParse(cyclesResponseSchema, data);
+  const validationResult = v6.safeParse(cyclesResponseSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -587,16 +452,16 @@ async function cycles(args) {
 }
 
 // src/stacks-api/proof-of-transfer/signer-in-cycle.ts
-var v9 = __toESM(require("valibot"), 1);
-var signerInCycleResponseSchema = 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(),
-  solo_stacker_count: v9.number(),
-  pooled_stacker_count: v9.number()
+var v7 = __toESM(require("valibot"), 1);
+var signerInCycleResponseSchema = v7.object({
+  signing_key: v7.string(),
+  signer_address: v7.string(),
+  weight: v7.number(),
+  stacked_amount: v7.string(),
+  weight_percent: v7.number(),
+  stacked_amount_percent: v7.number(),
+  solo_stacker_count: v7.number(),
+  pooled_stacker_count: v7.number()
 });
 async function signerInCycle(args) {
   const init = {};
@@ -632,7 +497,7 @@ async function signerInCycle(args) {
       }
     });
   }
-  const validationResult = v9.safeParse(signerInCycleResponseSchema, data);
+  const validationResult = v7.safeParse(signerInCycleResponseSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -644,19 +509,19 @@ async function signerInCycle(args) {
 }
 
 // src/stacks-api/proof-of-transfer/signers-in-cycle.ts
-var v10 = __toESM(require("valibot"), 1);
-var signerSchema = v10.object({
-  signing_key: v10.string(),
-  signer_address: v10.string(),
-  weight: v10.number(),
-  stacked_amount: v10.string(),
-  weight_percent: v10.number(),
-  stacked_amount_percent: v10.number(),
-  pooled_stacker_count: v10.number(),
-  solo_stacker_count: v10.number()
+var v8 = __toESM(require("valibot"), 1);
+var signerSchema = 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(),
+  pooled_stacker_count: v8.number(),
+  solo_stacker_count: v8.number()
 });
-var resultsSchema2 = v10.array(signerSchema);
-var signersResponseSchema = v10.object({
+var resultsSchema2 = v8.array(signerSchema);
+var signersResponseSchema = v8.object({
   ...baseListResponseSchema.entries,
   results: resultsSchema2
 });
@@ -680,7 +545,7 @@ async function signersInCycle(args) {
         endpoint,
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -695,7 +560,7 @@ async function signersInCycle(args) {
       }
     });
   }
-  const validationResult = v10.safeParse(signersResponseSchema, data);
+  const validationResult = v8.safeParse(signersResponseSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -707,15 +572,15 @@ async function signersInCycle(args) {
 }
 
 // src/stacks-api/proof-of-transfer/stackers-for-signer-in-cycle.ts
-var v11 = __toESM(require("valibot"), 1);
-var stackerInfoSchema = v11.object({
-  stacker_address: v11.string(),
-  stacked_amount: v11.string(),
-  pox_address: v11.string(),
-  stacker_type: v11.union([v11.literal("pooled"), v11.literal("solo")])
+var v9 = __toESM(require("valibot"), 1);
+var stackerInfoSchema = v9.object({
+  stacker_address: v9.string(),
+  stacked_amount: v9.string(),
+  pox_address: v9.string(),
+  stacker_type: v9.union([v9.literal("pooled"), v9.literal("solo")])
 });
-var resultsSchema3 = v11.array(stackerInfoSchema);
-var stackersForSignerInCycleResponseSchema = v11.object({
+var resultsSchema3 = v9.array(stackerInfoSchema);
+var stackersForSignerInCycleResponseSchema = v9.object({
   ...baseListResponseSchema.entries,
   results: resultsSchema3
 });
@@ -740,7 +605,7 @@ async function stackersForSignerInCycle(opts) {
         endpoint,
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -752,7 +617,7 @@ async function stackersForSignerInCycle(opts) {
       data: jsonError
     });
   }
-  const validationResult = v11.safeParse(
+  const validationResult = v9.safeParse(
     stackersForSignerInCycleResponseSchema,
     data
   );
@@ -776,20 +641,20 @@ var proofOfTransfer = {
 };
 
 // src/stacks-api/stacking-pool/members.ts
-var v12 = __toESM(require("valibot"), 1);
-var memberSchema = v12.object({
-  stacker: v12.string(),
-  pox_addr: v12.optional(v12.string()),
-  amount_ustx: v12.string(),
-  burn_block_unlock_height: v12.optional(v12.number()),
-  block_height: v12.number(),
-  tx_id: v12.string()
+var v10 = __toESM(require("valibot"), 1);
+var memberSchema = v10.object({
+  stacker: v10.string(),
+  pox_addr: v10.optional(v10.string()),
+  amount_ustx: v10.string(),
+  burn_block_unlock_height: v10.optional(v10.number()),
+  block_height: v10.number(),
+  tx_id: v10.string()
 });
-var membersResponseSchema = v12.object({
-  limit: v12.number(),
-  offset: v12.number(),
-  total: v12.number(),
-  results: v12.array(memberSchema)
+var membersResponseSchema = v10.object({
+  limit: v10.number(),
+  offset: v10.number(),
+  total: v10.number(),
+  results: v10.array(memberSchema)
 });
 async function members(args) {
   const search = new URLSearchParams();
@@ -812,7 +677,7 @@ async function members(args) {
       data: {
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -824,7 +689,7 @@ async function members(args) {
       data: jsonParseError
     });
   }
-  const validationResult = v12.safeParse(membersResponseSchema, data);
+  const validationResult = v10.safeParse(membersResponseSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -841,120 +706,120 @@ var stackingPool = {
 };
 
 // src/stacks-api/transactions/schemas.ts
-var v13 = __toESM(require("valibot"), 1);
-var baseTransactionSchema = v13.object({
-  tx_id: v13.string(),
-  nonce: v13.number(),
-  fee_rate: v13.string(),
-  sender_address: v13.string(),
-  sponsored: v13.boolean(),
-  post_condition_mode: v13.string(),
-  post_conditions: v13.array(v13.unknown()),
-  anchor_mode: v13.string(),
-  is_unanchored: v13.boolean(),
-  block_hash: v13.string(),
-  parent_block_hash: v13.string(),
-  block_height: v13.number(),
-  block_time: v13.number(),
-  block_time_iso: v13.string(),
-  burn_block_height: v13.number(),
-  burn_block_time: v13.number(),
-  burn_block_time_iso: v13.string(),
-  parent_burn_block_time: v13.number(),
-  parent_burn_block_time_iso: v13.string(),
-  canonical: v13.boolean(),
-  tx_index: v13.number(),
-  tx_status: v13.union([
-    v13.literal("success"),
-    v13.literal("abort_by_response"),
-    v13.literal("abort_by_post_condition")
+var v11 = __toESM(require("valibot"), 1);
+var baseTransactionSchema = v11.object({
+  tx_id: v11.string(),
+  nonce: v11.number(),
+  fee_rate: v11.string(),
+  sender_address: v11.string(),
+  sponsored: v11.boolean(),
+  post_condition_mode: v11.string(),
+  post_conditions: v11.array(v11.unknown()),
+  anchor_mode: v11.string(),
+  is_unanchored: v11.boolean(),
+  block_hash: v11.string(),
+  parent_block_hash: v11.string(),
+  block_height: v11.number(),
+  block_time: v11.number(),
+  block_time_iso: v11.string(),
+  burn_block_height: v11.number(),
+  burn_block_time: v11.number(),
+  burn_block_time_iso: v11.string(),
+  parent_burn_block_time: v11.number(),
+  parent_burn_block_time_iso: v11.string(),
+  canonical: v11.boolean(),
+  tx_index: v11.number(),
+  tx_status: v11.union([
+    v11.literal("success"),
+    v11.literal("abort_by_response"),
+    v11.literal("abort_by_post_condition")
   ]),
-  tx_result: v13.object({
-    hex: v13.string(),
-    repr: v13.string()
+  tx_result: v11.object({
+    hex: v11.string(),
+    repr: v11.string()
   }),
-  microblock_hash: v13.string(),
-  microblock_sequence: v13.number(),
-  microblock_canonical: v13.boolean(),
-  event_count: v13.number(),
-  events: v13.array(v13.unknown()),
-  execution_cost_read_count: v13.number(),
-  execution_cost_read_length: v13.number(),
-  execution_cost_runtime: v13.number(),
-  execution_cost_write_count: v13.number(),
-  execution_cost_write_length: v13.number()
+  microblock_hash: v11.string(),
+  microblock_sequence: v11.number(),
+  microblock_canonical: v11.boolean(),
+  event_count: v11.number(),
+  events: v11.array(v11.unknown()),
+  execution_cost_read_count: v11.number(),
+  execution_cost_read_length: v11.number(),
+  execution_cost_runtime: v11.number(),
+  execution_cost_write_count: v11.number(),
+  execution_cost_write_length: v11.number()
 });
-var contractCallTransactionSchema = v13.object({
-  tx_type: v13.literal("contract_call"),
-  contract_call: v13.object({
-    contract_id: v13.string(),
-    function_name: v13.string(),
-    function_signature: v13.string(),
-    function_args: v13.array(
-      v13.object({
-        hex: v13.string(),
-        repr: v13.string(),
-        name: v13.string(),
-        type: v13.string()
+var contractCallTransactionSchema = v11.object({
+  tx_type: v11.literal("contract_call"),
+  contract_call: v11.object({
+    contract_id: v11.string(),
+    function_name: v11.string(),
+    function_signature: v11.string(),
+    function_args: v11.array(
+      v11.object({
+        hex: v11.string(),
+        repr: v11.string(),
+        name: v11.string(),
+        type: v11.string()
       })
     )
   }),
   ...baseTransactionSchema.entries
 });
-var smartContractTransactionSchema = v13.object({
-  tx_type: v13.literal("smart_contract"),
-  smart_contract: v13.object({
+var smartContractTransactionSchema = v11.object({
+  tx_type: v11.literal("smart_contract"),
+  smart_contract: v11.object({
     /**
      * NOTE: The types may be wrong, not sure what type of value is used when
      * the version is not `null`.
      */
-    clarity_version: v13.union([v13.null(), v13.number()]),
-    contract_id: v13.string(),
-    source_code: v13.string()
+    clarity_version: v11.union([v11.null(), v11.number()]),
+    contract_id: v11.string(),
+    source_code: v11.string()
   }),
   ...baseTransactionSchema.entries
 });
-var tokenTransferSchema = v13.object({
-  tx_type: v13.literal("token_transfer"),
-  token_transfer: v13.object({
-    recipient_address: v13.string(),
-    amount: v13.string(),
-    memo: v13.string()
+var tokenTransferSchema = v11.object({
+  tx_type: v11.literal("token_transfer"),
+  token_transfer: v11.object({
+    recipient_address: v11.string(),
+    amount: v11.string(),
+    memo: v11.string()
   }),
   ...baseTransactionSchema.entries
 });
-var transactionSchema = v13.variant("tx_type", [
+var transactionSchema = v11.variant("tx_type", [
   contractCallTransactionSchema,
   smartContractTransactionSchema,
   tokenTransferSchema
 ]);
 
 // src/stacks-api/transactions/address-transactions.ts
-var v14 = __toESM(require("valibot"), 1);
-var resultSchema = v14.object({
+var v12 = __toESM(require("valibot"), 1);
+var resultSchema = v12.object({
   tx: transactionSchema,
-  stx_sent: v14.string(),
-  stx_received: v14.string(),
-  events: v14.object({
-    stx: v14.object({
-      transfer: v14.number(),
-      mint: v14.number(),
-      burn: v14.number()
+  stx_sent: v12.string(),
+  stx_received: v12.string(),
+  events: v12.object({
+    stx: v12.object({
+      transfer: v12.number(),
+      mint: v12.number(),
+      burn: v12.number()
     }),
-    ft: v14.object({
-      transfer: v14.number(),
-      mint: v14.number(),
-      burn: v14.number()
+    ft: v12.object({
+      transfer: v12.number(),
+      mint: v12.number(),
+      burn: v12.number()
     }),
-    nft: v14.object({
-      transfer: v14.number(),
-      mint: v14.number(),
-      burn: v14.number()
+    nft: v12.object({
+      transfer: v12.number(),
+      mint: v12.number(),
+      burn: v12.number()
     })
   })
 });
-var resultsSchema4 = v14.array(resultSchema);
-var addressTransactionsResponseSchema = v14.object({
+var resultsSchema4 = v12.array(resultSchema);
+var addressTransactionsResponseSchema = v12.object({
   ...baseListResponseSchema.entries,
   results: resultsSchema4
 });
@@ -979,7 +844,7 @@ async function addressTransactions(args) {
       data: {
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -991,7 +856,7 @@ async function addressTransactions(args) {
       data: jsonParseError
     });
   }
-  const validationResult = v14.safeParse(addressTransactionsResponseSchema, data);
+  const validationResult = v12.safeParse(addressTransactionsResponseSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -1003,7 +868,7 @@ async function addressTransactions(args) {
 }
 
 // src/stacks-api/transactions/get-transaction.ts
-var v15 = __toESM(require("valibot"), 1);
+var v13 = __toESM(require("valibot"), 1);
 async function getTransaction(args) {
   const init = {};
   if (args.apiKeyConfig) {
@@ -1020,7 +885,7 @@ async function getTransaction(args) {
       response: {
         status: res.status,
         statusText: res.statusText,
-        body: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -1032,7 +897,7 @@ async function getTransaction(args) {
       error: jsonParseError
     });
   }
-  const validationResult = v15.safeParse(transactionSchema, data);
+  const validationResult = v13.safeParse(transactionSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -1043,10 +908,91 @@ async function getTransaction(args) {
   return success(validationResult.output);
 }
 
+// src/stacks-api/transactions/mempool-transactions.ts
+async function mempoolTransactions(args) {
+  const search = new URLSearchParams();
+  if (args.limit) search.append("limit", args.limit.toString());
+  if (args.offset) search.append("offset", args.offset.toString());
+  if (args.senderAddress) search.append("sender_address", args.senderAddress);
+  if (args.recipientAddress)
+    search.append("recipient_address", args.recipientAddress);
+  if (args.address) search.append("address", args.address);
+  if (args.orderBy) search.append("order_by", args.orderBy);
+  if (args.order) search.append("order", args.order);
+  const init = {};
+  if (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  const res = await fetch(
+    `${args.baseUrl}/extended/v1/tx/mempool?${search}`,
+    init
+  );
+  if (!res.ok) {
+    return error({
+      name: "FetchMempoolTransactionsError",
+      message: "Failed to fetch mempool transactions.",
+      data: {
+        status: res.status,
+        statusText: res.statusText,
+        bodyText: await safePromise(res.text())
+      }
+    });
+  }
+  const [jsonParseError, data] = await safePromise(res.json());
+  if (jsonParseError) {
+    return error({
+      name: "ParseBodyError",
+      message: "Failed to parse response body.",
+      data: jsonParseError
+    });
+  }
+  return success(data);
+}
+
 // src/stacks-api/transactions/index.ts
 var transactions = {
   addressTransactions,
-  getTransaction
+  getTransaction,
+  mempoolTransactions
+};
+
+// src/stacks-api/mempool/transaction-fee-priorities.ts
+async function transactionFeePriorities(opts) {
+  const init = {};
+  if (opts.apiKeyConfig) {
+    init.headers = {
+      [opts.apiKeyConfig.header]: opts.apiKeyConfig.key
+    };
+  }
+  const endpoint = `${opts.baseUrl}/extended/v2/mempool/fees`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchFeePrioritiesError",
+      message: "Failed to fetch transaction fee priorities.",
+      data: {
+        status: res.status,
+        statusText: res.statusText,
+        bodyParseResult: await safePromise(res.text())
+      }
+    });
+  }
+  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/mempool/index.ts
+var mempool = {
+  transactionFeePriorities
 };
 
 // src/stacks-api/index.ts
@@ -1055,22 +1001,23 @@ var stacksApi = {
   blocks,
   faucets,
   info,
+  mempool,
   proofOfTransfer,
   stackingPool,
   transactions
 };
 
 // src/stacks-rpc-api/smart-contracts/map-entry.ts
-var v16 = __toESM(require("valibot"), 1);
-var mapEntryResponseSchema = v16.object({
+var v14 = __toESM(require("valibot"), 1);
+var mapEntryResponseSchema = v14.object({
   /**
    * Hex-encoded string of clarity value. It is always an optional tuple.
    */
-  data: v16.string(),
+  data: v14.string(),
   /**
    * Hex-encoded string of the MARF proof for the data
    */
-  proof: v16.optional(v16.string())
+  proof: v14.optional(v14.string())
 });
 async function mapEntry(args) {
   const search = new URLSearchParams();
@@ -1098,7 +1045,7 @@ async function mapEntry(args) {
         status: res.status,
         statusText: res.statusText,
         endpoint,
-        bodyParseResult: await safePromise(res.text())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -1110,7 +1057,7 @@ async function mapEntry(args) {
       data: jsonError
     });
   }
-  const validationResult = v16.safeParse(mapEntryResponseSchema, data);
+  const validationResult = v14.safeParse(mapEntryResponseSchema, data);
   if (!validationResult.success) {
     return error({
       name: "ValidateDataError",
@@ -1122,20 +1069,6 @@ async function mapEntry(args) {
 }
 
 // src/stacks-rpc-api/smart-contracts/read-only.ts
-var v17 = __toESM(require("valibot"), 1);
-var readOnlyResponseSchema = v17.variant("okay", [
-  v17.object({
-    okay: v17.literal(true),
-    /**
-     * A Clarity value as a hex-encoded string.
-     */
-    result: v17.string()
-  }),
-  v17.object({
-    okay: v17.literal(false),
-    cause: v17.unknown()
-  })
-]);
 async function readOnly(args) {
   const headers = {
     "Content-Type": "application/json"
@@ -1160,7 +1093,7 @@ async function readOnly(args) {
       data: {
         status: res.status,
         statusText: res.statusText,
-        bodyParseResult: await safePromise(res.json())
+        bodyText: await safePromise(res.text())
       }
     });
   }
@@ -1172,15 +1105,7 @@ async function readOnly(args) {
       data: error
     });
   }
-  const validationResult = v17.safeParse(readOnlyResponseSchema, data);
-  if (!validationResult.success) {
-    return error({
-      name: "ValidateDataError",
-      message: "Failed to validate data.",
-      data: validationResult
-    });
-  }
-  return success(validationResult.output);
+  return success(data);
 }
 
 // src/stacks-rpc-api/smart-contracts/index.ts
@@ -1189,8 +1114,45 @@ var smartContracts = {
   readOnly
 };
 
+// src/stacks-rpc-api/pox/pox-details.ts
+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,
+        bodyText: await safePromise(res.text())
+      }
+    });
+  }
+  const [jsonParseError, data] = await safePromise(res.json());
+  if (jsonParseError) {
+    return error({
+      name: "ParseBodyError",
+      message: "Failed to parse pox details response.",
+      data: jsonParseError
+    });
+  }
+  return success(data);
+}
+
+// src/stacks-rpc-api/pox/index.ts
+var pox = {
+  poxDetails
+};
+
 // src/stacks-rpc-api/index.ts
 var stacksRpcApi = {
+  pox,
   smartContracts
 };
 
@@ -1289,10 +1251,140 @@ async function getSignerStackedAmount(args) {
 var queries = {
   getSignerStackedAmount
 };
+
+// src/pox4-api/maps/stacking-state.ts
+var import_transactions2 = require("@stacks/transactions");
+
+// src/pox4-api/constants.ts
+var netValueMap = {
+  mainnet: {
+    pox4ContractAddress: "SP000000000000000000002Q6VF78",
+    pox4ContractName: "pox-4"
+  },
+  testnet: {
+    pox4ContractAddress: "ST000000000000000000002AMW42H",
+    pox4ContractName: "pox-4"
+  }
+};
+function networkDependentValues(network) {
+  return netValueMap[network];
+}
+
+// src/pox4-api/maps/stacking-state.ts
+async function stackingState({
+  key,
+  network,
+  baseUrl,
+  apiKeyConfig,
+  proof,
+  tip
+}) {
+  const [mapEntryError, mapEntryData] = await mapEntry({
+    contractAddress: networkDependentValues(network).pox4ContractAddress,
+    contractName: networkDependentValues(network).pox4ContractName,
+    mapKey: (0, import_transactions2.cvToHex)(key),
+    mapName: "stacking-state",
+    apiKeyConfig,
+    proof,
+    tip,
+    baseUrl
+  });
+  if (mapEntryError)
+    return error({
+      name: "FetchStackingStateError",
+      message: "Failed to fetch stacking state.",
+      data: mapEntryError
+    });
+  return success({
+    data: (0, import_transactions2.hexToCV)(mapEntryData.data),
+    proof: mapEntryData.proof
+  });
+}
+
+// src/pox4-api/maps/index.ts
+var maps = { stackingState };
+
+// src/pox4-api/read-only/get-stacker-info.ts
+var import_transactions3 = require("@stacks/transactions");
+async function getStackerInfo({
+  principal,
+  network,
+  baseUrl,
+  apiKeyConfig
+}) {
+  const [readOnlyError, readOnlyData] = await stacksRpcApi.smartContracts.readOnly({
+    contractAddress: networkDependentValues(network).pox4ContractAddress,
+    contractName: networkDependentValues(network).pox4ContractName,
+    functionName: "get-stacker-info",
+    arguments: [(0, import_transactions3.cvToHex)((0, import_transactions3.principalCV)(principal))],
+    baseUrl,
+    apiKeyConfig,
+    sender: principal
+  });
+  if (readOnlyError) {
+    return error({
+      name: "GetStackerInfoError",
+      message: "Failed to get stacker info.",
+      data: readOnlyError
+    });
+  }
+  if (!readOnlyData.okay) {
+    return error({
+      name: "GetStackerInfoFunctionCallError",
+      message: "Call to `get-stacker-info` failed.",
+      data: readOnlyData
+    });
+  }
+  return success((0, import_transactions3.hexToCV)(readOnlyData.result));
+}
+
+// src/pox4-api/read-only/get-check-delegation.ts
+var import_transactions4 = require("@stacks/transactions");
+async function getCheckDelegation({
+  principal,
+  network,
+  baseUrl,
+  apiKeyConfig
+}) {
+  const [readOnlyError, readOnlyData] = await stacksRpcApi.smartContracts.readOnly({
+    contractAddress: networkDependentValues(network).pox4ContractAddress,
+    contractName: networkDependentValues(network).pox4ContractName,
+    functionName: "get-check-delegation",
+    arguments: [(0, import_transactions4.cvToHex)((0, import_transactions4.principalCV)(principal))],
+    baseUrl,
+    apiKeyConfig,
+    sender: principal
+  });
+  if (readOnlyError) {
+    return error({
+      name: "GetCheckDelegationError",
+      message: "Failed to get check delegation.",
+      data: readOnlyError
+    });
+  }
+  if (!readOnlyData.okay) {
+    return error({
+      name: "GetCheckDelegationFunctionCallError",
+      message: "Call to `get-check-delegation` failed.",
+      data: readOnlyData
+    });
+  }
+  return success((0, import_transactions4.hexToCV)(readOnlyData.result));
+}
+
+// src/pox4-api/read-only/index.ts
+var readOnly2 = {
+  getStackerInfo,
+  getCheckDelegation
+};
+
+// src/pox4-api/index.ts
+var pox4Api = { maps, readOnly: readOnly2 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   callRateLimitedApi,
   error,
+  pox4Api,
   queries,
   safeCall,
   safeCallRateLimitedApi,