@secretkeylabs/stacks-tools 0.3.0-6f23618 → 0.3.0-9a0fdf3

package/dist/index.js

@@ -1,3 +1,1160 @@
-export { stacksApi } from "./stacks-api/index.js";
-export { queries } from "./queries/index.js";
-//# sourceMappingURL=index.js.map
+// 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/accounts/index.ts
+var accounts = {
+  balances
+};
+
+// 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/blocks/index.ts
+var blocks = {
+  getBlock
+};
+
+// 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/info/index.ts
+var info = {
+  coreApi,
+  poxDetails
+};
+
+// 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 signerPublicKey = opts.signerPublicKey.startsWith("0x") ? opts.signerPublicKey : `0x${opts.signerPublicKey}`;
+  const endpoint = `${opts.baseUrl}/extended/v2/pox/cycles/${opts.cycleNumber}/signers/${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);
+}
+
+// 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 v11 from "valibot";
+var readOnlyResponseSchema = v11.variant("okay", [
+  v11.object({
+    okay: v11.literal(true),
+    result: v11.string()
+  }),
+  v11.object({
+    okay: v11.literal(false),
+    cause: v11.unknown()
+  })
+]);
+async function readOnly(args) {
+  const init = {};
+  if (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  const res = await fetch(
+    `${args.baseUrl}/v2/contracts/call-read/${args.contractAddress}/${args.contractName}/${args.functionName}`,
+    init
+  );
+  if (!res.ok) {
+    return error({
+      name: "FetchReadOnlyError",
+      message: "Failed to fetch.",
+      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: error
+    });
+  }
+  const validationResult = v11.safeParse(readOnlyResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/smart-contracts/index.ts
+var smartContracts = {
+  readOnly
+};
+
+// src/stacks-api/stacking-pool/members.ts
+import * as v12 from "valibot";
+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 membersResponseSchema = v12.object({
+  limit: v12.number(),
+  offset: v12.number(),
+  total: v12.number(),
+  results: v12.array(memberSchema)
+});
+async function members(args) {
+  const search = new URLSearchParams();
+  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 (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  const endpoint = `${args.baseUrl}/extended/v1/pox4/${args.poolPrincipal}/delegations?${search}`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchMembersError",
+      message: "Failed to fetch members.",
+      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 response body as JSON.",
+      data: jsonParseError
+    });
+  }
+  const validationResult = v12.safeParse(membersResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/stacking-pool/index.ts
+var stackingPool = {
+  members
+};
+
+// src/stacks-api/transactions/schemas.ts
+import * as v13 from "valibot";
+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.string(),
+  tx_result: v13.object({
+    hex: v13.string(),
+    repr: v13.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()
+});
+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()
+      })
+    )
+  }),
+  ...baseTransactionSchema.entries
+});
+var smartContractTransactionSchema = v13.object({
+  tx_type: v13.literal("smart_contract"),
+  smart_contract: v13.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()
+  }),
+  ...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()
+  }),
+  ...baseTransactionSchema.entries
+});
+var transactionSchema = v13.variant("tx_type", [
+  contractCallTransactionSchema,
+  smartContractTransactionSchema,
+  tokenTransferSchema
+]);
+
+// src/stacks-api/transactions/address-transactions.ts
+import * as v14 from "valibot";
+var resultSchema = v14.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()
+    }),
+    ft: v14.object({
+      transfer: v14.number(),
+      mint: v14.number(),
+      burn: v14.number()
+    }),
+    nft: v14.object({
+      transfer: v14.number(),
+      mint: v14.number(),
+      burn: v14.number()
+    })
+  })
+});
+var resultsSchema4 = v14.array(resultSchema);
+var addressTransactionsResponseSchema = v14.object({
+  ...baseListResponseSchema.entries,
+  results: resultsSchema4
+});
+async function addressTransactions(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 res = await fetch(
+    `${args.baseUrl}/extended/v2/addresses/${args.address}/transactions?${search}`,
+    init
+  );
+  if (!res.ok) {
+    return error({
+      name: "FetchAddressTransactionsError",
+      message: "Failed to fetch address transactions.",
+      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 response body as JSON.",
+      data: jsonParseError
+    });
+  }
+  const validationResult = v14.safeParse(addressTransactionsResponseSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate data.",
+      data: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/transactions/get-transaction.ts
+import * as v15 from "valibot";
+async function getTransaction(args) {
+  const init = {};
+  if (args.apiKeyConfig) {
+    init.headers = {
+      [args.apiKeyConfig.header]: args.apiKeyConfig.key
+    };
+  }
+  const endpoint = `${args.baseUrl}/extended/v1/tx/${args.transactionId}`;
+  const res = await fetch(endpoint, init);
+  if (!res.ok) {
+    return error({
+      name: "FetchTransactionError",
+      message: `Failed to fetch transaction ${args.transactionId}`,
+      response: {
+        status: res.status,
+        statusText: res.statusText,
+        body: await safePromise(res.json())
+      }
+    });
+  }
+  const [jsonParseError, data] = await safePromise(res.json());
+  if (jsonParseError) {
+    return error({
+      name: "ParseBodyError",
+      message: "Failed to parse response body as JSON.",
+      error: jsonParseError
+    });
+  }
+  const validationResult = v15.safeParse(transactionSchema, data);
+  if (!validationResult.success) {
+    return error({
+      name: "ValidateDataError",
+      message: "Failed to validate data.",
+      error: validationResult
+    });
+  }
+  return success(validationResult.output);
+}
+
+// src/stacks-api/transactions/index.ts
+var transactions = {
+  addressTransactions,
+  getTransaction
+};
+
+// 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/index.ts
+var stacksApi = {
+  accounts,
+  blocks,
+  faucets,
+  info,
+  proofOfTransfer,
+  smartContracts,
+  stackingPool,
+  transactions
+};
+
+// src/stacks-rpc-api/smart-contracts/map-entry.ts
+import * as v16 from "valibot";
+var mapEntryResponseSchema = v16.object({
+  /**
+   * Hex-encoded string of clarity value. It is always an optional tuple.
+   */
+  data: v16.string(),
+  /**
+   * Hex-encoded string of the MARF proof for the data
+   */
+  proof: v16.optional(v16.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 = v16.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
+};
+
+// src/utils/call-rate-limited-api.ts
+import { backOff } from "exponential-backoff";
+async function safeCallRateLimitedApi(fn, options) {
+  try {
+    return await backOff(() => fn(), {
+      startingDelay: options?.startingDelay ?? 15e3,
+      numOfAttempts: options?.numOfAttempts ?? 5
+    });
+  } catch (error2) {
+    return error({
+      name: "MaxRetriesExceeded",
+      message: "Failed to call rate limited API.",
+      data: {
+        error: error2
+      }
+    });
+  }
+}
+
+// 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 += limit + 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 {
+  queries,
+  stacksApi,
+  stacksRpcApi
+};