@secretkeylabs/stacks-tools 0.4.0 → 0.5.0-5d800c5

package/dist/index.d.cts

@@ -1,4 +1,6 @@
+import { MempoolTransaction, OperationResponse } from '@stacks/blockchain-api-client';
 import * as v from 'valibot';
+import { OptionalCV, TupleCV, BufferCV, UIntCV, PrincipalCV, ListCV } from '@stacks/transactions';
 
 type SafeError<TName extends string = string, TData = unknown> = {
     readonly name: TName;
@@ -23,6 +25,13 @@ type ApiRequestOptions = {
     baseUrl: string;
     apiKeyConfig?: ApiKeyConfig;
 };
+type ProofAndTip = {
+    /**
+     * Returns object without the proof field when set to 0.
+     */
+    proof?: number;
+    tip?: "latest" | string;
+};
 type ApiPaginationOptions = {
     /**
      * The number of items to return. Each endpoint has its own maximum allowed
@@ -33,6 +42,45 @@ type ApiPaginationOptions = {
     limit?: number;
     offset?: number;
 };
+type ListResponse<T = unknown> = {
+    limit: number;
+    offset: number;
+    total: number;
+    results: T[];
+};
+
+type Args$j = {
+    /**
+     * Filter to only return transactions with this sender address.
+     */
+    senderAddress?: string;
+    /**
+     * Filter to only return transactions with this recipient address (only
+     * applicable for STX transfer tx types).
+     */
+    recipientAddress?: string;
+    /**
+     * Filter to only return transactions with this address as the sender or
+     * recipient (recipient only applicable for STX transfer tx types).
+     */
+    address?: string;
+    /**
+     * Option to sort results by transaction age, size, or fee rate.
+     */
+    orderBy?: "age" | "size" | "fee";
+    /**
+     * Option to sort results in ascending or descending order.
+     */
+    order?: "asc" | "desc";
+} & ApiRequestOptions & ApiPaginationOptions;
+type MempoolTransactionsResponse = ListResponse<MempoolTransaction>;
+declare function mempoolTransactions(args: Args$j): Promise<Result$1<MempoolTransactionsResponse, SafeError<"FetchMempoolTransactionsError" | "ParseBodyError" | "ValidateDataError">>>;
+
+type mempoolTransactions$1_MempoolTransactionsResponse = MempoolTransactionsResponse;
+declare const mempoolTransactions$1_mempoolTransactions: typeof mempoolTransactions;
+declare namespace mempoolTransactions$1 {
+  export { type mempoolTransactions$1_MempoolTransactionsResponse as MempoolTransactionsResponse, mempoolTransactions$1_mempoolTransactions as mempoolTransactions };
+}
 
 declare const baseTransactionSchema: v.ObjectSchema<{
     readonly tx_id: v.StringSchema<undefined>;
@@ -373,17 +421,17 @@ declare namespace schemas {
   export { type schemas_ContractCallTransaction as ContractCallTransaction, type schemas_SmartContractTransaction as SmartContractTransaction, type schemas_Transaction as Transaction, schemas_baseTransactionSchema as baseTransactionSchema, schemas_contractCallTransactionSchema as contractCallTransactionSchema, schemas_smartContractTransactionSchema as smartContractTransactionSchema, schemas_tokenTransferSchema as tokenTransferSchema, schemas_transactionSchema as transactionSchema };
 }
 
-type Args$b = {
+type Args$i = {
     transactionId: string;
 } & ApiRequestOptions;
-declare function getTransaction(args: Args$b): Promise<Result$1<Transaction>>;
+declare function getTransaction(args: Args$i): Promise<Result$1<Transaction>>;
 
 declare const getTransaction$1_getTransaction: typeof getTransaction;
 declare namespace getTransaction$1 {
   export { getTransaction$1_getTransaction as getTransaction };
 }
 
-type Args$a = {
+type Args$h = {
     address: string;
 } & ApiRequestOptions & ApiPaginationOptions;
 declare const resultSchema: v.ObjectSchema<{
@@ -865,7 +913,7 @@ declare const addressTransactionsResponseSchema: v.ObjectSchema<{
     readonly total: v.NumberSchema<undefined>;
 }, undefined>;
 type AddressTransactionsResponse = v.InferOutput<typeof addressTransactionsResponseSchema>;
-declare function addressTransactions(args: Args$a): Promise<Result$1<AddressTransactionsResponse, SafeError<"FetchAddressTransactionsError" | "ParseBodyError" | "ValidateDataError">>>;
+declare function addressTransactions(args: Args$h): Promise<Result$1<AddressTransactionsResponse, SafeError<"FetchAddressTransactionsError" | "ParseBodyError" | "ValidateDataError">>>;
 
 type addressTransactions$1_AddressTransactionsResponse = AddressTransactionsResponse;
 type addressTransactions$1_Result = Result;
@@ -874,13 +922,13 @@ declare namespace addressTransactions$1 {
   export { type addressTransactions$1_AddressTransactionsResponse as AddressTransactionsResponse, type addressTransactions$1_Result as Result, type Results$3 as Results, addressTransactions$1_addressTransactions as addressTransactions };
 }
 
-type Options$1 = {
+type Args$g = {
     poolPrincipal: string;
     afterBlock?: number;
     unanchored?: boolean;
     limit?: number;
     offset?: number;
-};
+} & ApiRequestOptions & ApiPaginationOptions;
 declare const memberSchema: v.ObjectSchema<{
     readonly stacker: v.StringSchema<undefined>;
     readonly pox_addr: v.OptionalSchema<v.StringSchema<undefined>, never>;
@@ -904,7 +952,7 @@ declare const membersResponseSchema: v.ObjectSchema<{
     }, undefined>, undefined>;
 }, undefined>;
 type MembersResponse = v.InferOutput<typeof membersResponseSchema>;
-declare function members(opts: Options$1, apiOpts: ApiRequestOptions): Promise<Result$1<MembersResponse>>;
+declare function members(args: Args$g): Promise<Result$1<MembersResponse>>;
 
 type members$1_Member = Member;
 type members$1_MembersResponse = MembersResponse;
@@ -912,37 +960,10 @@ declare const members$1_memberSchema: typeof memberSchema;
 declare const members$1_members: typeof members;
 declare const members$1_membersResponseSchema: typeof membersResponseSchema;
 declare namespace members$1 {
-  export { type members$1_Member as Member, type members$1_MembersResponse as MembersResponse, type Options$1 as Options, members$1_memberSchema as memberSchema, members$1_members as members, members$1_membersResponseSchema as membersResponseSchema };
+  export { type Args$g as Args, type members$1_Member as Member, type members$1_MembersResponse as MembersResponse, members$1_memberSchema as memberSchema, members$1_members as members, members$1_membersResponseSchema as membersResponseSchema };
 }
 
-type Args$9 = {
-    sender: string;
-    arguments: string[];
-    contractAddress: string;
-    contractName: string;
-    functionName: string;
-} & ApiRequestOptions;
-declare const readOnlyResponseSchema: v.VariantSchema<"okay", [v.ObjectSchema<{
-    readonly okay: v.LiteralSchema<true, undefined>;
-    /**
-     * A Clarity value as a hex-encoded string.
-     */
-    readonly result: v.StringSchema<undefined>;
-}, undefined>, v.ObjectSchema<{
-    readonly okay: v.LiteralSchema<false, undefined>;
-    readonly cause: v.UnknownSchema;
-}, undefined>], undefined>;
-type ReadOnlyResponse = v.InferOutput<typeof readOnlyResponseSchema>;
-declare function readOnly(args: Args$9): Promise<Result$1<ReadOnlyResponse>>;
-
-type readOnly$1_ReadOnlyResponse = ReadOnlyResponse;
-declare const readOnly$1_readOnly: typeof readOnly;
-declare const readOnly$1_readOnlyResponseSchema: typeof readOnlyResponseSchema;
-declare namespace readOnly$1 {
-  export { type Args$9 as Args, type readOnly$1_ReadOnlyResponse as ReadOnlyResponse, readOnly$1_readOnly as readOnly, readOnly$1_readOnlyResponseSchema as readOnlyResponseSchema };
-}
-
-type Args$8 = {
+type Args$f = {
     cycleNumber: number;
     signerPublicKey: string;
 } & ApiRequestOptions & ApiPaginationOptions;
@@ -972,7 +993,7 @@ declare const stackersForSignerInCycleResponseSchema: v.ObjectSchema<{
     readonly total: v.NumberSchema<undefined>;
 }, undefined>;
 type StackersForSignerInCycleResponse = v.InferOutput<typeof stackersForSignerInCycleResponseSchema>;
-declare function stackersForSignerInCycle(opts: Args$8): Promise<Result$1<StackersForSignerInCycleResponse, SafeError<"FetchStackersForSignerInCycleError" | "ParseBodyError" | "ValidateDataError">>>;
+declare function stackersForSignerInCycle(opts: Args$f): Promise<Result$1<StackersForSignerInCycleResponse, SafeError<"FetchStackersForSignerInCycleError" | "ParseBodyError" | "ValidateDataError">>>;
 
 type stackersForSignerInCycle$1_StackerInfo = StackerInfo;
 type stackersForSignerInCycle$1_StackersForSignerInCycleResponse = StackersForSignerInCycleResponse;
@@ -980,10 +1001,10 @@ declare const stackersForSignerInCycle$1_stackerInfoSchema: typeof stackerInfoSc
 declare const stackersForSignerInCycle$1_stackersForSignerInCycle: typeof stackersForSignerInCycle;
 declare const stackersForSignerInCycle$1_stackersForSignerInCycleResponseSchema: typeof stackersForSignerInCycleResponseSchema;
 declare namespace stackersForSignerInCycle$1 {
-  export { type Args$8 as Args, type Results$2 as Results, type stackersForSignerInCycle$1_StackerInfo as StackerInfo, type stackersForSignerInCycle$1_StackersForSignerInCycleResponse as StackersForSignerInCycleResponse, resultsSchema$2 as resultsSchema, stackersForSignerInCycle$1_stackerInfoSchema as stackerInfoSchema, stackersForSignerInCycle$1_stackersForSignerInCycle as stackersForSignerInCycle, stackersForSignerInCycle$1_stackersForSignerInCycleResponseSchema as stackersForSignerInCycleResponseSchema };
+  export { type Args$f as Args, type Results$2 as Results, type stackersForSignerInCycle$1_StackerInfo as StackerInfo, type stackersForSignerInCycle$1_StackersForSignerInCycleResponse as StackersForSignerInCycleResponse, resultsSchema$2 as resultsSchema, stackersForSignerInCycle$1_stackerInfoSchema as stackerInfoSchema, stackersForSignerInCycle$1_stackersForSignerInCycle as stackersForSignerInCycle, stackersForSignerInCycle$1_stackersForSignerInCycleResponseSchema as stackersForSignerInCycleResponseSchema };
 }
 
-type Args$7 = {
+type Args$e = {
     cycleNumber: number;
 } & ApiRequestOptions & ApiPaginationOptions;
 declare const signerSchema: v.ObjectSchema<{
@@ -1024,7 +1045,7 @@ declare const signersResponseSchema: v.ObjectSchema<{
     readonly total: v.NumberSchema<undefined>;
 }, undefined>;
 type SignersResponse = v.InferOutput<typeof signersResponseSchema>;
-declare function signersInCycle(args: Args$7): Promise<Result$1<SignersResponse, SafeError<"FetchSignersError" | "ParseBodyError" | "ValidateDataError">>>;
+declare function signersInCycle(args: Args$e): Promise<Result$1<SignersResponse, SafeError<"FetchSignersError" | "ParseBodyError" | "ValidateDataError">>>;
 
 type signersInCycle$1_Signer = Signer;
 type signersInCycle$1_SignersResponse = SignersResponse;
@@ -1032,10 +1053,10 @@ declare const signersInCycle$1_signerSchema: typeof signerSchema;
 declare const signersInCycle$1_signersInCycle: typeof signersInCycle;
 declare const signersInCycle$1_signersResponseSchema: typeof signersResponseSchema;
 declare namespace signersInCycle$1 {
-  export { type Args$7 as Args, type Results$1 as Results, type signersInCycle$1_Signer as Signer, type signersInCycle$1_SignersResponse as SignersResponse, resultsSchema$1 as resultsSchema, signersInCycle$1_signerSchema as signerSchema, signersInCycle$1_signersInCycle as signersInCycle, signersInCycle$1_signersResponseSchema as signersResponseSchema };
+  export { type Args$e as Args, type Results$1 as Results, type signersInCycle$1_Signer as Signer, type signersInCycle$1_SignersResponse as SignersResponse, resultsSchema$1 as resultsSchema, signersInCycle$1_signerSchema as signerSchema, signersInCycle$1_signersInCycle as signersInCycle, signersInCycle$1_signersResponseSchema as signersResponseSchema };
 }
 
-type Args$6 = {
+type Args$d = {
     /**
      * The signers public key as a hex string, with or without a '0x' prefix.
      */
@@ -1053,16 +1074,16 @@ declare const signerInCycleResponseSchema: v.ObjectSchema<{
     readonly pooled_stacker_count: v.NumberSchema<undefined>;
 }, undefined>;
 type SignerInCycleResponse = v.InferOutput<typeof signerInCycleResponseSchema>;
-declare function signerInCycle(args: Args$6): Promise<Result$1<SignerInCycleResponse>>;
+declare function signerInCycle(args: Args$d): Promise<Result$1<SignerInCycleResponse>>;
 
 type signerInCycle$1_SignerInCycleResponse = SignerInCycleResponse;
 declare const signerInCycle$1_signerInCycle: typeof signerInCycle;
 declare const signerInCycle$1_signerInCycleResponseSchema: typeof signerInCycleResponseSchema;
 declare namespace signerInCycle$1 {
-  export { type Args$6 as Args, type signerInCycle$1_SignerInCycleResponse as SignerInCycleResponse, signerInCycle$1_signerInCycle as signerInCycle, signerInCycle$1_signerInCycleResponseSchema as signerInCycleResponseSchema };
+  export { type Args$d as Args, type signerInCycle$1_SignerInCycleResponse as SignerInCycleResponse, signerInCycle$1_signerInCycle as signerInCycle, signerInCycle$1_signerInCycleResponseSchema as signerInCycleResponseSchema };
 }
 
-type Args$5 = ApiRequestOptions & ApiPaginationOptions;
+type Args$c = ApiRequestOptions & ApiPaginationOptions;
 declare const cycleInfoSchema: v.ObjectSchema<{
     readonly block_height: v.NumberSchema<undefined>;
     readonly index_block_hash: v.StringSchema<undefined>;
@@ -1095,7 +1116,7 @@ declare const cyclesResponseSchema: v.ObjectSchema<{
     readonly total: v.NumberSchema<undefined>;
 }, undefined>;
 type CyclesResponse = v.InferOutput<typeof cyclesResponseSchema>;
-declare function cycles(args: Args$5): Promise<Result$1<CyclesResponse>>;
+declare function cycles(args: Args$c): Promise<Result$1<CyclesResponse>>;
 
 type cycles$1_CycleInfo = CycleInfo;
 type cycles$1_CyclesResponse = CyclesResponse;
@@ -1105,13 +1126,13 @@ declare const cycles$1_cycles: typeof cycles;
 declare const cycles$1_cyclesResponseSchema: typeof cyclesResponseSchema;
 declare const cycles$1_resultsSchema: typeof resultsSchema;
 declare namespace cycles$1 {
-  export { type Args$5 as Args, type cycles$1_CycleInfo as CycleInfo, type cycles$1_CyclesResponse as CyclesResponse, type cycles$1_Results as Results, cycles$1_cycleInfoSchema as cycleInfoSchema, cycles$1_cycles as cycles, cycles$1_cyclesResponseSchema as cyclesResponseSchema, cycles$1_resultsSchema as resultsSchema };
+  export { type Args$c as Args, type cycles$1_CycleInfo as CycleInfo, type cycles$1_CyclesResponse as CyclesResponse, type cycles$1_Results as Results, cycles$1_cycleInfoSchema as cycleInfoSchema, cycles$1_cycles as cycles, cycles$1_cyclesResponseSchema as cyclesResponseSchema, cycles$1_resultsSchema as resultsSchema };
 }
 
-type Args$4 = {
+type Args$b = {
     cycleNumber: number;
 } & ApiRequestOptions;
-declare const responseSchema$3: v.ObjectSchema<{
+declare const responseSchema$2: v.ObjectSchema<{
     readonly block_height: v.NumberSchema<undefined>;
     readonly index_block_hash: v.StringSchema<undefined>;
     readonly cycle_number: v.NumberSchema<undefined>;
@@ -1119,73 +1140,12 @@ declare const responseSchema$3: v.ObjectSchema<{
     readonly total_stacked_amount: v.StringSchema<undefined>;
     readonly total_signers: v.NumberSchema<undefined>;
 }, undefined>;
-type Response$3 = v.InferOutput<typeof responseSchema$3>;
-declare function cycle(opts: Args$4): Promise<Result$1<Response$3, SafeError<"FetchCycleError" | "ParseBodyError" | "ValidateDataError">>>;
+type Response$2 = v.InferOutput<typeof responseSchema$2>;
+declare function cycle(opts: Args$b): Promise<Result$1<Response$2, SafeError<"FetchCycleError" | "ParseBodyError" | "ValidateDataError">>>;
 
 declare const cycle$1_cycle: typeof cycle;
 declare namespace cycle$1 {
-  export { type Args$4 as Args, type Response$3 as Response, cycle$1_cycle as cycle, responseSchema$3 as responseSchema };
-}
-
-type Args$3 = ApiRequestOptions;
-declare const poxDetailsResponseSchema: v.ObjectSchema<{
-    readonly contract_id: v.StringSchema<undefined>;
-    readonly pox_activation_threshold_ustx: v.NumberSchema<undefined>;
-    readonly first_burnchain_block_height: v.NumberSchema<undefined>;
-    readonly current_burnchain_block_height: v.NumberSchema<undefined>;
-    readonly prepare_phase_block_length: v.NumberSchema<undefined>;
-    readonly reward_phase_block_length: v.NumberSchema<undefined>;
-    readonly reward_slots: v.NumberSchema<undefined>;
-    readonly rejection_fraction: v.NullSchema<undefined>;
-    readonly total_liquid_supply_ustx: v.NumberSchema<undefined>;
-    readonly current_cycle: v.ObjectSchema<{
-        readonly id: v.NumberSchema<undefined>;
-        readonly min_threshold_ustx: v.NumberSchema<undefined>;
-        readonly stacked_ustx: v.NumberSchema<undefined>;
-        readonly is_pox_active: v.BooleanSchema<undefined>;
-    }, undefined>;
-    readonly next_cycle: v.ObjectSchema<{
-        readonly id: v.NumberSchema<undefined>;
-        readonly min_threshold_ustx: v.NumberSchema<undefined>;
-        readonly min_increment_ustx: v.NumberSchema<undefined>;
-        readonly stacked_ustx: v.NumberSchema<undefined>;
-        readonly prepare_phase_start_block_height: v.NumberSchema<undefined>;
-        readonly blocks_until_prepare_phase: v.NumberSchema<undefined>;
-        readonly reward_phase_start_block_height: v.NumberSchema<undefined>;
-        readonly blocks_until_reward_phase: v.NumberSchema<undefined>;
-        readonly ustx_until_pox_rejection: v.NullSchema<undefined>;
-    }, undefined>;
-    readonly epochs: v.ArraySchema<v.ObjectSchema<{
-        readonly epoch_id: v.StringSchema<undefined>;
-        readonly start_height: v.NumberSchema<undefined>;
-        readonly end_height: v.NumberSchema<undefined>;
-        readonly block_limit: v.ObjectSchema<{
-            readonly write_length: v.NumberSchema<undefined>;
-            readonly write_count: v.NumberSchema<undefined>;
-            readonly read_length: v.NumberSchema<undefined>;
-            readonly read_count: v.NumberSchema<undefined>;
-            readonly runtime: v.NumberSchema<undefined>;
-        }, undefined>;
-        readonly network_epoch: v.NumberSchema<undefined>;
-    }, undefined>, undefined>;
-    readonly min_amount_ustx: v.NumberSchema<undefined>;
-    readonly prepare_cycle_length: v.NumberSchema<undefined>;
-    readonly reward_cycle_id: v.NumberSchema<undefined>;
-    readonly reward_cycle_length: v.NumberSchema<undefined>;
-    readonly rejection_votes_left_required: v.NullSchema<undefined>;
-    readonly next_reward_cycle_in: v.NumberSchema<undefined>;
-    readonly contract_versions: v.ArraySchema<v.ObjectSchema<{
-        readonly contract_id: v.StringSchema<undefined>;
-        readonly activation_burnchain_block_height: v.NumberSchema<undefined>;
-        readonly first_reward_cycle_id: v.NumberSchema<undefined>;
-    }, undefined>, undefined>;
-}, undefined>;
-type PoxDetailsResponse = v.InferOutput<typeof poxDetailsResponseSchema>;
-declare function poxDetails(args: Args$3): Promise<Result$1<PoxDetailsResponse>>;
-
-declare const poxDetails$1_poxDetails: typeof poxDetails;
-declare namespace poxDetails$1 {
-  export { poxDetails$1_poxDetails as poxDetails };
+  export { type Args$b as Args, type Response$2 as Response, cycle$1_cycle as cycle, responseSchema$2 as responseSchema };
 }
 
 declare const CoreApiResponseSchema: v.ObjectSchema<{
@@ -1213,10 +1173,21 @@ declare namespace coreApi$1 {
   export { type coreApi$1_CoreApiResponse as CoreApiResponse, coreApi$1_coreApi as coreApi };
 }
 
-type Args$2 = {
+type Args$a = {
+    address: string;
+    stacking?: boolean;
+} & ApiRequestOptions;
+declare function stx(opts: Args$a): Promise<Result$1<any>>;
+
+declare const stx$1_stx: typeof stx;
+declare namespace stx$1 {
+  export { type Args$a as Args, stx$1_stx as stx };
+}
+
+type Args$9 = {
     heightOrHash: string | number;
 } & ApiRequestOptions;
-declare const responseSchema$2: v.ObjectSchema<{
+declare const responseSchema$1: v.ObjectSchema<{
     readonly canonical: v.BooleanSchema<undefined>;
     readonly height: v.NumberSchema<undefined>;
     readonly hash: v.StringSchema<undefined>;
@@ -1237,112 +1208,44 @@ declare const responseSchema$2: v.ObjectSchema<{
     readonly execution_cost_write_count: v.NumberSchema<undefined>;
     readonly execution_cost_write_length: v.NumberSchema<undefined>;
 }, undefined>;
-type Response$2 = v.InferOutput<typeof responseSchema$2>;
-declare function getBlock(opts: Args$2): Promise<Result$1<Response$2, SafeError<"FetchBlockError" | "ParseBodyError" | "ValidateDataError">>>;
+type Response$1 = v.InferOutput<typeof responseSchema$1>;
+declare function getBlock(opts: Args$9): Promise<Result$1<Response$1, SafeError<"FetchBlockError" | "ParseBodyError" | "ValidateDataError">>>;
 
 declare const getBlock$1_getBlock: typeof getBlock;
 declare namespace getBlock$1 {
-  export { type Args$2 as Args, type Response$2 as Response, getBlock$1_getBlock as getBlock, responseSchema$2 as responseSchema };
+  export { type Args$9 as Args, type Response$1 as Response, getBlock$1_getBlock as getBlock, responseSchema$1 as responseSchema };
 }
 
-type Args$1 = {
+type Args$8 = {
     principal: string;
 } & ApiRequestOptions;
-declare const responseSchema$1: v.ObjectSchema<{
+declare const responseSchema: v.ObjectSchema<{
     readonly last_mempool_tx_nonce: v.NullableSchema<v.NumberSchema<undefined>, never>;
     readonly last_executed_tx_nonce: v.NullableSchema<v.NumberSchema<undefined>, never>;
     readonly possible_next_nonce: v.NumberSchema<undefined>;
     readonly detected_missing_nonces: v.ArraySchema<v.NumberSchema<undefined>, undefined>;
     readonly detected_mempool_nonces: v.ArraySchema<v.NumberSchema<undefined>, undefined>;
 }, undefined>;
-type Response$1 = v.InferOutput<typeof responseSchema$1>;
-declare function latestNonce(opts: Args$1): Promise<Result$1<Response$1, SafeError<"FetchLatestNonceError" | "ParseBodyError" | "ValidateDataError">>>;
+type Response = v.InferOutput<typeof responseSchema>;
+declare function latestNonce(opts: Args$8): Promise<Result$1<Response, SafeError<"FetchLatestNonceError" | "ParseBodyError" | "ValidateDataError">>>;
 
+type latestNonce$1_Response = Response;
 declare const latestNonce$1_latestNonce: typeof latestNonce;
+declare const latestNonce$1_responseSchema: typeof responseSchema;
 declare namespace latestNonce$1 {
-  export { type Args$1 as Args, type Response$1 as Response, latestNonce$1_latestNonce as latestNonce, responseSchema$1 as responseSchema };
+  export { type Args$8 as Args, type latestNonce$1_Response as Response, latestNonce$1_latestNonce as latestNonce, latestNonce$1_responseSchema as responseSchema };
 }
 
-type Args = {
+type Args$7 = {
     principal: string;
     unanchored?: boolean;
     untilBlock?: number;
 } & ApiRequestOptions;
-declare const responseSchema: v.ObjectSchema<{
-    readonly stx: v.ObjectSchema<{
-        readonly balance: v.StringSchema<undefined>;
-        readonly total_sent: v.StringSchema<undefined>;
-        readonly total_received: v.StringSchema<undefined>;
-        readonly total_fees_sent: v.StringSchema<undefined>;
-        readonly total_miner_rewards_received: v.StringSchema<undefined>;
-        readonly lock_tx_id: v.StringSchema<undefined>;
-        readonly locked: v.StringSchema<undefined>;
-        readonly lock_height: v.NumberSchema<undefined>;
-        readonly burnchain_lock_height: v.NumberSchema<undefined>;
-        readonly burnchain_unlock_height: v.NumberSchema<undefined>;
-    }, undefined>;
-    readonly fungible_tokens: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
-        readonly balance: v.StringSchema<undefined>;
-        readonly total_sent: v.StringSchema<undefined>;
-        readonly total_received: v.StringSchema<undefined>;
-    }, undefined>, undefined>;
-    readonly non_fungible_tokens: v.RecordSchema<v.StringSchema<undefined>, v.ObjectSchema<{
-        readonly count: v.StringSchema<undefined>;
-        readonly total_sent: v.StringSchema<undefined>;
-        readonly total_received: v.StringSchema<undefined>;
-    }, undefined>, undefined>;
-}, undefined>;
-type Response = v.InferOutput<typeof responseSchema>;
-declare function balances(opts: Args): Promise<Result$1<Response, SafeError<"FetchBalancesError" | "ParseBodyError" | "ValidateDataError">>>;
+declare function balances(opts: Args$7): Promise<Result$1<OperationResponse["get_account_balance"], SafeError<"FetchBalancesError" | "ParseBodyError" | "ValidateDataError">>>;
 
-type balances$1_Args = Args;
-type balances$1_Response = Response;
 declare const balances$1_balances: typeof balances;
-declare const balances$1_responseSchema: typeof responseSchema;
 declare namespace balances$1 {
-  export { type balances$1_Args as Args, type balances$1_Response as Response, balances$1_balances as balances, balances$1_responseSchema as responseSchema };
-}
-
-declare const index$7_balances: typeof balances;
-declare const index$7_latestNonce: typeof latestNonce;
-declare namespace index$7 {
-  export { balances$1 as Balances, latestNonce$1 as LatestNonce, index$7_balances as balances, index$7_latestNonce as latestNonce };
-}
-
-declare const index$6_getBlock: typeof getBlock;
-declare namespace index$6 {
-  export { getBlock$1 as GetBlock, index$6_getBlock as getBlock };
-}
-
-declare const index$5_coreApi: typeof coreApi;
-declare const index$5_poxDetails: typeof poxDetails;
-declare namespace index$5 {
-  export { coreApi$1 as CoreApi, poxDetails$1 as PoxDetails, index$5_coreApi as coreApi, index$5_poxDetails as poxDetails };
-}
-
-declare const index$4_cycle: typeof cycle;
-declare const index$4_cycles: typeof cycles;
-declare const index$4_signerInCycle: typeof signerInCycle;
-declare const index$4_signersInCycle: typeof signersInCycle;
-declare const index$4_stackersForSignerInCycle: typeof stackersForSignerInCycle;
-declare namespace index$4 {
-  export { cycle$1 as Cycle, cycles$1 as Cycles, signerInCycle$1 as SignerInCycle, signersInCycle$1 as SignersInCycle, stackersForSignerInCycle$1 as StackersForSignerInCycle, index$4_cycle as cycle, index$4_cycles as cycles, index$4_signerInCycle as signerInCycle, index$4_signersInCycle as signersInCycle, index$4_stackersForSignerInCycle as stackersForSignerInCycle };
-}
-
-declare const index$3_readOnly: typeof readOnly;
-declare namespace index$3 {
-  export { readOnly$1 as ReadOnly, index$3_readOnly as readOnly };
-}
-
-declare const index$2_members: typeof members;
-declare namespace index$2 {
-  export { members$1 as Members, index$2_members as members };
-}
-
-declare const index$1_addressTransactions: typeof addressTransactions;
-declare const index$1_getTransaction: typeof getTransaction;
-declare namespace index$1 {
-  export { addressTransactions$1 as AddressTransactions, schemas as Common, getTransaction$1 as GetTransaction, index$1_addressTransactions as addressTransactions, index$1_getTransaction as getTransaction };
+  export { type Args$7 as Args, balances$1_balances as balances };
 }
 
 declare const accounts: {
@@ -1350,15 +1253,38 @@ declare const accounts: {
     latestNonce: typeof latestNonce;
 };
 
+declare const index$d_accounts: typeof accounts;
+declare namespace index$d {
+  export { balances$1 as Balances, latestNonce$1 as LatestNonce, index$d_accounts as accounts };
+}
+
 declare const blocks: {
     getBlock: typeof getBlock;
 };
 
+declare const index$c_blocks: typeof blocks;
+declare namespace index$c {
+  export { getBlock$1 as GetBlock, index$c_blocks as blocks };
+}
+
+declare const faucets: {
+    stx: typeof stx;
+};
+
+declare const index$b_faucets: typeof faucets;
+declare namespace index$b {
+  export { stx$1 as Stx, index$b_faucets as faucets };
+}
+
 declare const info: {
     coreApi: typeof coreApi;
-    poxDetails: typeof poxDetails;
 };
 
+declare const index$a_info: typeof info;
+declare namespace index$a {
+  export { coreApi$1 as CoreApi, index$a_info as info };
+}
+
 declare const proofOfTransfer: {
     cycle: typeof cycle;
     cycles: typeof cycles;
@@ -1367,37 +1293,31 @@ declare const proofOfTransfer: {
     stackersForSignerInCycle: typeof stackersForSignerInCycle;
 };
 
-declare const smartContracts: {
-    readOnly: typeof readOnly;
-};
+declare const index$9_proofOfTransfer: typeof proofOfTransfer;
+declare namespace index$9 {
+  export { cycle$1 as Cycle, cycles$1 as Cycles, signerInCycle$1 as SignerInCycle, signersInCycle$1 as SignersInCycle, stackersForSignerInCycle$1 as StackersForSignerInCycle, index$9_proofOfTransfer as proofOfTransfer };
+}
 
 declare const stackingPool: {
     members: typeof members;
 };
 
+declare const index$8_stackingPool: typeof stackingPool;
+declare namespace index$8 {
+  export { members$1 as Members, index$8_stackingPool as stackingPool };
+}
+
 declare const transactions: {
     addressTransactions: typeof addressTransactions;
     getTransaction: typeof getTransaction;
+    mempoolTransactions: typeof mempoolTransactions;
 };
 
-declare const index_accounts: typeof accounts;
-declare const index_blocks: typeof blocks;
-declare const index_info: typeof info;
-declare const index_proofOfTransfer: typeof proofOfTransfer;
-declare const index_smartContracts: typeof smartContracts;
-declare const index_stackingPool: typeof stackingPool;
-declare const index_transactions: typeof transactions;
-declare namespace index {
-  export { index$7 as Accounts, index$6 as Blocks, index$5 as Info, index$4 as ProofOfTransfer, index$3 as SmartContracts, index$2 as StackingPool, index$1 as Transactions, index_accounts as accounts, index_blocks as blocks, index_info as info, index_proofOfTransfer as proofOfTransfer, index_smartContracts as smartContracts, index_stackingPool as stackingPool, index_transactions as transactions };
+declare const index$7_transactions: typeof transactions;
+declare namespace index$7 {
+  export { addressTransactions$1 as AddressTransactions, schemas as Common, getTransaction$1 as GetTransaction, mempoolTransactions$1 as MempoolTransactions, index$7_transactions as transactions };
 }
 
-type Options = {
-    startingDelay?: number;
-    numOfAttempts?: number;
-};
-declare function callRateLimitedApi<T>(fn: () => Promise<T>, options?: Options): Promise<T>;
-declare function safeCallRateLimitedApi<T>(fn: () => Promise<Result$1<T>>, options?: Options): Promise<Result$1<T, SafeError<"MaxRetriesExceeded" | string>>>;
-
 declare const stacksApi: {
     accounts: {
         balances: typeof balances;
@@ -1406,9 +1326,11 @@ declare const stacksApi: {
     blocks: {
         getBlock: typeof getBlock;
     };
+    faucets: {
+        stx: typeof stx;
+    };
     info: {
         coreApi: typeof coreApi;
-        poxDetails: typeof poxDetails;
     };
     proofOfTransfer: {
         cycle: typeof cycle;
@@ -1417,16 +1339,396 @@ declare const stacksApi: {
         signersInCycle: typeof signersInCycle;
         stackersForSignerInCycle: typeof stackersForSignerInCycle;
     };
-    smartContracts: {
-        readOnly: typeof readOnly;
-    };
     stackingPool: {
         members: typeof members;
     };
     transactions: {
         addressTransactions: typeof addressTransactions;
         getTransaction: typeof getTransaction;
+        mempoolTransactions: typeof mempoolTransactions;
+    };
+};
+
+declare const index$6_stacksApi: typeof stacksApi;
+declare namespace index$6 {
+  export { index$d as Accounts, index$c as Blocks, index$b as Faucets, index$a as Info, index$9 as ProofOfTransfer, index$8 as StackingPool, index$7 as Transactions, index$6_stacksApi as stacksApi };
+}
+
+type Args$6 = {
+    sender: string;
+    arguments: string[];
+    contractAddress: string;
+    contractName: string;
+    functionName: string;
+} & ApiRequestOptions;
+interface ReadOnlyContractCallSuccessResponse {
+    okay: true;
+    result: string;
+}
+interface ReadOnlyContractCallFailResponse {
+    okay: false;
+    cause: string;
+}
+type ReadOnlyContractCallResponse = ReadOnlyContractCallSuccessResponse | ReadOnlyContractCallFailResponse;
+type ReadOnlyResponse = ReadOnlyContractCallResponse;
+declare function readOnly$1(args: Args$6): Promise<Result$1<ReadOnlyResponse>>;
+
+type readOnly$2_ReadOnlyContractCallResponse = ReadOnlyContractCallResponse;
+type readOnly$2_ReadOnlyResponse = ReadOnlyResponse;
+declare namespace readOnly$2 {
+  export { type Args$6 as Args, type readOnly$2_ReadOnlyContractCallResponse as ReadOnlyContractCallResponse, type readOnly$2_ReadOnlyResponse as ReadOnlyResponse, readOnly$1 as readOnly };
+}
+
+type Args$5 = {
+    contractAddress: string;
+    contractName: string;
+    mapName: string;
+    /**
+     * Hex-encoded string of the map key Clarity value.
+     */
+    mapKey: string;
+} & ApiRequestOptions & ProofAndTip;
+declare const mapEntryResponseSchema: v.ObjectSchema<{
+    /**
+     * Hex-encoded string of clarity value. It is always an optional tuple.
+     */
+    readonly data: v.StringSchema<undefined>;
+    /**
+     * Hex-encoded string of the MARF proof for the data
+     */
+    readonly proof: v.OptionalSchema<v.StringSchema<undefined>, never>;
+}, undefined>;
+type MapEntryResponse = v.InferOutput<typeof mapEntryResponseSchema>;
+declare function mapEntry(args: Args$5): Promise<Result$1<MapEntryResponse>>;
+
+type mapEntry$1_MapEntryResponse = MapEntryResponse;
+declare const mapEntry$1_mapEntry: typeof mapEntry;
+declare namespace mapEntry$1 {
+  export { type Args$5 as Args, type mapEntry$1_MapEntryResponse as MapEntryResponse, mapEntry$1_mapEntry as mapEntry };
+}
+
+type Args$4 = ApiRequestOptions;
+/**
+ * Get Proof of Transfer (PoX) information
+ */
+interface CoreNodePoxResponse {
+    /**
+     * The contract identifier for the PoX contract
+     */
+    contract_id: string;
+    /**
+     * The first burn block evaluated in this Stacks chain
+     */
+    first_burnchain_block_height: number;
+    /**
+     * The latest Bitcoin chain block height
+     */
+    current_burnchain_block_height: number;
+    /**
+     * The threshold of stacking participation that must be reached for PoX to
+     * activate in any cycle
+     */
+    pox_activation_threshold_ustx: number;
+    /**
+     * The fraction of liquid STX that must vote to reject PoX in order to prevent
+     * the next reward cycle from activating.
+     */
+    rejection_fraction: number;
+    /**
+     * The length in burn blocks of the reward phase
+     */
+    reward_phase_block_length: number;
+    /**
+     * The length in burn blocks of the prepare phase
+     */
+    prepare_phase_block_length: number;
+    /**
+     * The number of reward slots in a reward cycle
+     */
+    reward_slots: number;
+    /**
+     * The current total amount of liquid microstacks.
+     */
+    total_liquid_supply_ustx: number;
+    /**
+     * The length in burn blocks of a whole PoX cycle (reward phase and prepare
+     * phase)
+     */
+    reward_cycle_length: number;
+    current_cycle: {
+        /**
+         * The reward cycle number
+         */
+        id: number;
+        /**
+         * The threshold amount for obtaining a slot in this reward cycle.
+         */
+        min_threshold_ustx: number;
+        /**
+         * The total amount of stacked microstacks in this reward cycle.
+         */
+        stacked_ustx: number;
+        /**
+         * Whether or not PoX is active during this reward cycle.
+         */
+        is_pox_active: boolean;
+    };
+    next_cycle: {
+        /**
+         * The reward cycle number
+         */
+        id: number;
+        /**
+         * The threshold amount for obtaining a slot in this reward cycle.
+         */
+        min_threshold_ustx: number;
+        /**
+         * The total amount of stacked microstacks in this reward cycle.
+         */
+        stacked_ustx: number;
+        /**
+         * The minimum amount that can be used to submit a `stack-stx` call.
+         */
+        min_increment_ustx: number;
+        /**
+         * The burn block height when the prepare phase for this cycle begins. Any
+         * eligible stacks must be stacked before this block.
+         */
+        prepare_phase_start_block_height: number;
+        /**
+         * The number of burn blocks until the prepare phase for this cycle starts.
+         * If the prepare phase for this cycle already started, this value will be
+         * negative.
+         */
+        blocks_until_prepare_phase: number;
+        /**
+         * The burn block height when the reward phase for this cycle begins. Any
+         * eligible stacks must be stacked before this block.
+         */
+        reward_phase_start_block_height: number;
+        /**
+         * The number of burn blocks until this reward phase starts.
+         */
+        blocks_until_reward_phase: number;
+        /**
+         * The remaining amount of liquid STX that must vote to reject the next
+         * reward cycle to prevent the next reward cycle from activating.
+         */
+        ustx_until_pox_rejection: number;
+    };
+    /**
+     * @deprecated
+     * The active reward cycle number
+     */
+    reward_cycle_id: number;
+    /**
+     * @deprecated
+     */
+    min_amount_ustx: number;
+    /**
+     * @deprecated
+     */
+    prepare_cycle_length: number;
+    /**
+     * @deprecated
+     */
+    rejection_votes_left_required: number;
+    /**
+     * Versions of each PoX
+     */
+    contract_versions: {
+        /**
+         * The contract identifier for the PoX contract
+         */
+        contract_id: string;
+        /**
+         * The burn block height at which this version of PoX is activated
+         */
+        activation_burnchain_block_height: number;
+        /**
+         * The first reward cycle number that uses this version of PoX
+         */
+        first_reward_cycle_id: number;
+    }[];
+}
+type PoxDetailsResponse = CoreNodePoxResponse;
+declare function poxDetails(args: Args$4): Promise<Result$1<PoxDetailsResponse>>;
+
+type poxDetails$1_CoreNodePoxResponse = CoreNodePoxResponse;
+type poxDetails$1_PoxDetailsResponse = PoxDetailsResponse;
+declare const poxDetails$1_poxDetails: typeof poxDetails;
+declare namespace poxDetails$1 {
+  export { type poxDetails$1_CoreNodePoxResponse as CoreNodePoxResponse, type poxDetails$1_PoxDetailsResponse as PoxDetailsResponse, poxDetails$1_poxDetails as poxDetails };
+}
+
+declare const smartContracts: {
+    mapEntry: typeof mapEntry;
+    readOnly: typeof readOnly$1;
+};
+
+declare const index$5_smartContracts: typeof smartContracts;
+declare namespace index$5 {
+  export { mapEntry$1 as MapEntry, readOnly$2 as ReadOnly, index$5_smartContracts as smartContracts };
+}
+
+declare const pox: {
+    poxDetails: typeof poxDetails;
+};
+
+declare const index$4_pox: typeof pox;
+declare namespace index$4 {
+  export { poxDetails$1 as PoxDetails, index$4_pox as pox };
+}
+
+declare const stacksRpcApi: {
+    pox: {
+        poxDetails: typeof poxDetails;
     };
+    smartContracts: {
+        mapEntry: typeof mapEntry;
+        readOnly: typeof readOnly$1;
+    };
+};
+
+declare const index$3_stacksRpcApi: typeof stacksRpcApi;
+declare namespace index$3 {
+  export { index$4 as Pox, index$5 as SmartContracts, index$3_stacksRpcApi as stacksRpcApi };
+}
+
+type Identifier = {
+    type: "address";
+    signerAddress: string;
+} | {
+    type: "publicKey";
+    signerPublicKey: string;
+};
+type Args$3 = {
+    identifier: Identifier;
+} & {
+    cycleNumber: number;
+} & ApiRequestOptions;
+/**
+ * Return the total locked amount for a signer in a PoX cycle.
+ */
+declare function getSignerStackedAmount(args: Args$3): Promise<Result$1<bigint, SafeError<"SignerNotFound" | string>>>;
+
+declare const queries: {
+    getSignerStackedAmount: typeof getSignerStackedAmount;
+};
+
+type Options = {
+    startingDelay?: number;
+    numOfAttempts?: number;
 };
+declare function callRateLimitedApi<T>(fn: () => Promise<T>, options?: Options): Promise<T>;
+declare function safeCallRateLimitedApi<T>(fn: () => Promise<Result$1<T>>, options?: Options): Promise<Result$1<T, SafeError<"MaxRetriesExceeded" | string>>>;
+
+type Network = "mainnet" | "testnet";
+
+type PoxAddr = OptionalCV<TupleCV<{
+    version: BufferCV;
+    hashbytes: BufferCV;
+}>>;
+
+type Args$2 = {
+    principal: string;
+    network: Network;
+} & ApiRequestOptions;
+type GetCheckDelegationReturn = OptionalCV<TupleCV<{
+    "amount-ustx": UIntCV;
+    "delegated-to": PrincipalCV;
+    "until-burn-ht": OptionalCV<UIntCV>;
+    "pox-addr": OptionalCV<PoxAddr>;
+}>>;
+declare function getCheckDelegation({ principal, network, baseUrl, apiKeyConfig, }: Args$2): Promise<Result$1<GetCheckDelegationReturn>>;
+
+type getCheckDelegation$1_GetCheckDelegationReturn = GetCheckDelegationReturn;
+declare const getCheckDelegation$1_getCheckDelegation: typeof getCheckDelegation;
+declare namespace getCheckDelegation$1 {
+  export { type getCheckDelegation$1_GetCheckDelegationReturn as GetCheckDelegationReturn, getCheckDelegation$1_getCheckDelegation as getCheckDelegation };
+}
+
+type Args$1 = {
+    principal: string;
+    network: Network;
+} & ApiRequestOptions;
+type GetStackerInfoReturn = OptionalCV<TupleCV<{
+    "pox-addr": PoxAddr;
+    "lock-period": UIntCV;
+    "first-reward-cycle": UIntCV;
+    "reward-set-indexes": ListCV<UIntCV>;
+    "delegated-to": OptionalCV<PrincipalCV>;
+}>>;
+declare function getStackerInfo({ principal, network, baseUrl, apiKeyConfig, }: Args$1): Promise<Result$1<GetStackerInfoReturn>>;
+
+type getStackerInfo$1_GetStackerInfoReturn = GetStackerInfoReturn;
+declare const getStackerInfo$1_getStackerInfo: typeof getStackerInfo;
+declare namespace getStackerInfo$1 {
+  export { type Args$1 as Args, type getStackerInfo$1_GetStackerInfoReturn as GetStackerInfoReturn, getStackerInfo$1_getStackerInfo as getStackerInfo };
+}
+
+type StackingStateKey = TupleCV<{
+    stacker: PrincipalCV;
+}>;
+type StackingStateValue = TupleCV<{
+    "pox-addr": TupleCV<{
+        version: BufferCV;
+        hashbytes: BufferCV;
+    }>;
+    "lock-period": UIntCV;
+    "first-reward-cycle": UIntCV;
+    "reward-set-indexes": ListCV<UIntCV>;
+    "delegated-to": OptionalCV<PrincipalCV>;
+}>;
+type Args = {
+    key: StackingStateKey;
+    network: Network;
+} & ApiRequestOptions & ProofAndTip;
+declare function stackingState({ key, network, baseUrl, apiKeyConfig, proof, tip, }: Args): Promise<Result$1<{
+    data: StackingStateValue;
+    proof?: string;
+}>>;
+
+type stackingState$1_Args = Args;
+type stackingState$1_StackingStateKey = StackingStateKey;
+type stackingState$1_StackingStateValue = StackingStateValue;
+declare const stackingState$1_stackingState: typeof stackingState;
+declare namespace stackingState$1 {
+  export { type stackingState$1_Args as Args, type stackingState$1_StackingStateKey as StackingStateKey, type stackingState$1_StackingStateValue as StackingStateValue, stackingState$1_stackingState as stackingState };
+}
+
+declare const maps: {
+    stackingState: typeof stackingState;
+};
+
+declare const index$2_maps: typeof maps;
+declare namespace index$2 {
+  export { stackingState$1 as StackingState, index$2_maps as maps };
+}
+
+declare const readOnly: {
+    getStackerInfo: typeof getStackerInfo;
+    getCheckDelegation: typeof getCheckDelegation;
+};
+
+declare const index$1_readOnly: typeof readOnly;
+declare namespace index$1 {
+  export { getCheckDelegation$1 as GetCheckDelegation, getStackerInfo$1 as GetStackerInfo, index$1_readOnly as readOnly };
+}
+
+declare const pox4Api: {
+    maps: {
+        stackingState: typeof stackingState;
+    };
+    readOnly: {
+        getStackerInfo: typeof getStackerInfo;
+        getCheckDelegation: typeof getCheckDelegation;
+    };
+};
+
+declare const index_pox4Api: typeof pox4Api;
+declare namespace index {
+  export { index$2 as Maps, index$1 as ReadOnly, index_pox4Api as pox4Api };
+}
 
-export { type Result$1 as Result, type SafeError, index as StacksApi, callRateLimitedApi, error, safeCall, safeCallRateLimitedApi, safePromise, stacksApi, success };
+export { index as Pox4Api, type Result$1 as Result, type SafeError, index$6 as StacksApi, index$3 as StacksRpcApi, callRateLimitedApi, error, pox4Api, queries, safeCall, safeCallRateLimitedApi, safePromise, stacksApi, stacksRpcApi, success };