/** Account derived from a local private key (mnemonic or raw key). */
type LocalAccount = {
	type: "local"
	address: string
	/** Compressed public key (hex) */
	publicKey: string
	/** Raw ECDSA sign over a hash */
	sign(hash: Uint8Array): Uint8Array
	/** Sign a raw UTF-8 / byte message (`sha256(bytes)`). Not SIP-018. */
	signMessage(message: string | Uint8Array): string
};
/** Account with a user-provided signing function (sync or async). */
type CustomAccount = {
	type: "custom"
	address: string
	publicKey: string
	sign(hash: Uint8Array): Promise<Uint8Array> | Uint8Array
};
/** Browser wallet provider interface (e.g. Leather, Xverse). */
type StacksProvider = {
	request(method: string, params?: any): Promise<any>
};
/** Account backed by a browser wallet {@link StacksProvider}. */
type ProviderAccount = {
	type: "provider"
	address: string
	publicKey: string
	provider: StacksProvider
};
type IntCV = {
	readonly type: "int"
	readonly value: bigint
};
type UIntCV = {
	readonly type: "uint"
	readonly value: bigint
};
type BooleanCV = TrueCV | FalseCV;
type TrueCV = {
	readonly type: "true"
};
type FalseCV = {
	readonly type: "false"
};
type BufferCV = {
	readonly type: "buffer"
	readonly value: string
};
type NoneCV = {
	readonly type: "none"
};
type SomeCV = {
	readonly type: "some"
	readonly value: ClarityValue
};
type ResponseOkCV = {
	readonly type: "ok"
	readonly value: ClarityValue
};
type ResponseErrorCV = {
	readonly type: "err"
	readonly value: ClarityValue
};
type StandardPrincipalCV = {
	readonly type: "address"
	readonly value: string
};
type ContractPrincipalCV = {
	readonly type: "contract"
	readonly value: string
};
type ListCV = {
	type: "list"
	value: ClarityValue[]
};
type TupleData = {
	[key: string]: ClarityValue
};
type TupleCV = {
	type: "tuple"
	value: TupleData
};
type StringAsciiCV = {
	readonly type: "ascii"
	readonly value: string
};
type StringUtf8CV = {
	readonly type: "utf8"
	readonly value: string
};
type ClarityValue = IntCV | UIntCV | BooleanCV | BufferCV | NoneCV | SomeCV | ResponseOkCV | ResponseErrorCV | StandardPrincipalCV | ContractPrincipalCV | ListCV | TupleCV | StringAsciiCV | StringUtf8CV;
declare const AuthType: {
	readonly Standard: 0x04
	readonly Sponsored: 0x05
};
type AuthType = (typeof AuthType)[keyof typeof AuthType];
declare const PayloadType: {
	readonly TokenTransfer: 0x00
	readonly SmartContract: 0x01
	readonly ContractCall: 0x02
	readonly PoisonMicroblock: 0x03
	readonly Coinbase: 0x04
	readonly CoinbaseToAltRecipient: 0x05
	readonly VersionedSmartContract: 0x06
	readonly TenureChange: 0x07
	readonly NakamotoCoinbase: 0x08
};
type PayloadType = (typeof PayloadType)[keyof typeof PayloadType];
declare const ClarityVersion: {
	readonly Clarity1: 1
	readonly Clarity2: 2
	readonly Clarity3: 3
	readonly Clarity4: 4
	readonly Clarity5: 5
	readonly Clarity6: 6
};
type ClarityVersion = (typeof ClarityVersion)[keyof typeof ClarityVersion];
declare const AnchorMode: {
	readonly OnChainOnly: 0x01
	readonly OffChainOnly: 0x02
	readonly Any: 0x03
};
type AnchorMode = (typeof AnchorMode)[keyof typeof AnchorMode];
declare const PostConditionModeWire: {
	readonly Allow: 0x01
	readonly Deny: 0x02
	readonly Originator: 0x03
};
type PostConditionModeWire = (typeof PostConditionModeWire)[keyof typeof PostConditionModeWire];
declare const AddressHashMode: {
	readonly P2PKH: 0x00
	readonly P2SH: 0x01
	readonly P2WPKH: 0x02
	readonly P2WSH: 0x03
	readonly P2SH_NonSequential: 0x05
	readonly P2WSH_P2SH_NonSequential: 0x07
};
type AddressHashMode = (typeof AddressHashMode)[keyof typeof AddressHashMode];
declare const PubKeyEncoding: {
	readonly Compressed: 0x00
	readonly Uncompressed: 0x01
};
type PubKeyEncoding = (typeof PubKeyEncoding)[keyof typeof PubKeyEncoding];
declare const PoxConditionCode: {
	readonly WillNotPerform: 0x30
	readonly MayPerform: 0x31
	readonly WillPerform: 0x32
};
type PoxConditionCode = (typeof PoxConditionCode)[keyof typeof PoxConditionCode];
declare const TenureChangeCause: {
	readonly BlockFound: 0x00
	readonly Extended: 0x01
	readonly ExtendedRuntime: 0x02
	readonly ExtendedReadCount: 0x03
	readonly ExtendedReadLength: 0x04
	readonly ExtendedWriteCount: 0x05
	readonly ExtendedWriteLength: 0x06
};
type TenureChangeCause = (typeof TenureChangeCause)[keyof typeof TenureChangeCause];
type TokenTransferPayload = {
	payloadType: typeof PayloadType.TokenTransfer
	recipient: ClarityValue
	amount: bigint
	memo: string
};
type ContractCallPayload = {
	payloadType: typeof PayloadType.ContractCall
	contractAddress: string
	contractName: string
	functionName: string
	functionArgs: ClarityValue[]
};
type SmartContractPayload = {
	payloadType: typeof PayloadType.SmartContract | typeof PayloadType.VersionedSmartContract
	clarityVersion?: ClarityVersion
	contractName: string
	codeBody: string
};
type CoinbasePayload = {
	payloadType: typeof PayloadType.Coinbase
	coinbaseBuffer: string
};
type CoinbaseToAltRecipientPayload = {
	payloadType: typeof PayloadType.CoinbaseToAltRecipient
	coinbaseBuffer: string
	recipient: ClarityValue
};
type PoisonMicroblockPayload = {
	payloadType: typeof PayloadType.PoisonMicroblock
	header1: string
	header2: string
};
type TenureChangePayload = {
	payloadType: typeof PayloadType.TenureChange
	tenureConsensusHash: string
	prevTenureConsensusHash: string
	burnViewConsensusHash: string
	previousTenureEnd: string
	previousTenureBlocks: number
	cause: TenureChangeCause
	pubkeyHash: string
};
type NakamotoCoinbasePayload = {
	payloadType: typeof PayloadType.NakamotoCoinbase
	coinbaseBuffer: string
	recipient: ClarityValue | null
	vrfProof: string
};
type TransactionPayload = TokenTransferPayload | ContractCallPayload | SmartContractPayload | CoinbasePayload | CoinbaseToAltRecipientPayload | PoisonMicroblockPayload | TenureChangePayload | NakamotoCoinbasePayload;
type SingleSigSpendingCondition = {
	hashMode: typeof AddressHashMode.P2PKH | typeof AddressHashMode.P2WPKH
	signer: string
	nonce: bigint
	fee: bigint
	keyEncoding: PubKeyEncoding
	signature: string
};
type TransactionAuthField = {
	pubKeyEncoding: PubKeyEncoding
	type: "publicKey" | "signature"
	data: string
};
type MultiSigHashMode = typeof AddressHashMode.P2SH | typeof AddressHashMode.P2WSH | typeof AddressHashMode.P2SH_NonSequential | typeof AddressHashMode.P2WSH_P2SH_NonSequential;
type MultiSigSpendingCondition = {
	hashMode: MultiSigHashMode
	signer: string
	nonce: bigint
	fee: bigint
	fields: TransactionAuthField[]
	signaturesRequired: number
};
type SpendingCondition = SingleSigSpendingCondition | MultiSigSpendingCondition;
type StandardAuthorization = {
	authType: typeof AuthType.Standard
	spendingCondition: SpendingCondition
};
type SponsoredAuthorization = {
	authType: typeof AuthType.Sponsored
	spendingCondition: SpendingCondition
	sponsorSpendingCondition: SpendingCondition
};
type Authorization = StandardAuthorization | SponsoredAuthorization;
type StacksTransaction = {
	version: number
	chainId: number
	auth: Authorization
	anchorMode: AnchorMode
	postConditionMode: PostConditionModeWire
	postConditions: PostConditionWire[]
	payload: TransactionPayload
	/** Multi-sig signer metadata — not part of the wire format, preserved
	*  through serialize/deserialize round-trip for auto-detection. */
	_multisig?: {
		publicKeys: string[]
	}
};
type PostConditionWire = StxPostConditionWire | FtPostConditionWire | NftPostConditionWire | StakingPostConditionWire | PoxPostConditionWire;
type StxPostConditionWire = {
	type: "stx"
	principal: PostConditionPrincipalWire
	conditionCode: number
	amount: bigint
};
type FtPostConditionWire = {
	type: "ft"
	principal: PostConditionPrincipalWire
	asset: AssetInfoWire
	conditionCode: number
	amount: bigint
};
type NftPostConditionWire = {
	type: "nft"
	principal: PostConditionPrincipalWire
	asset: AssetInfoWire
	conditionCode: number
	assetId: ClarityValue
};
type StakingPostConditionWire = {
	type: "staking"
	principal: PostConditionPrincipalWire
	conditionCode: number
	amount: bigint
};
type PoxPostConditionWire = {
	type: "pox"
	principal: PostConditionPrincipalWire
	conditionCode: PoxConditionCode
};
type PostConditionPrincipalWire = {
	type: "origin"
} | {
	type: "standard"
	address: string
} | {
	type: "contract"
	address: string
	contractName: string
};
type AssetInfoWire = {
	address: string
	contractName: string
	assetName: string
};
/** Allocates mempool-safe sequential nonces across rapid broadcasts from one account. */
type NonceManager = {
	consume(params: {
		client: Client
		address: string
	}): Promise<bigint>
	reset(params: {
		client: Client
		address: string
	}): void | Promise<void>
	/**
	* Give back a nonce from {@link NonceManager.consume} whose transaction
	* was never accepted by the node. No-op unless it is the latest issued.
	*/
	release(params: {
		client: Client
		address: string
		nonce: bigint
	}): void | Promise<void>
	/** Next nonce that {@link NonceManager.consume} would return without consuming it, or `undefined` if untracked. */
	peek(params: {
		client: Client
		address: string
	}): Promise<bigint | undefined>
};
/** Full chain descriptor used by clients and transports for network-aware operations. */
type StacksChain = {
	/** Chain ID (e.g. 0x00000001 for mainnet) */
	id: number
	/** Human-readable name */
	name: string
	/** Network type */
	network: "mainnet" | "testnet"
	/** Transaction version byte for serialization */
	transactionVersion: number
	/** Peer network ID for P2P broadcasting */
	peerNetworkId: number
	/** Address version bytes */
	addressVersion: {
		singleSig: number
		multiSig: number
	}
	/** Magic bytes for network identification */
	magicBytes: string
	/** Boot address (system contracts deployer) */
	bootAddress: string
	/** Native currency info */
	nativeCurrency: {
		name: string
		symbol: string
		decimals: number
	}
	/** Default RPC URLs */
	rpcUrls: {
		default: {
			http: string[]
			ws?: string[]
		}
	}
	/** Block explorer URLs */
	blockExplorers?: {
		default: {
			name: string
			url: string
		}
	}
};
/** Function that sends an HTTP request to a Stacks node API path. */
type RequestFn = (path: string, options?: RequestOptions) => Promise<any>;
/** Options for a transport-level HTTP request. */
type RequestOptions = {
	method?: "GET" | "POST" | "PUT" | "DELETE"
	body?: unknown
	headers?: Record<string, string>
	/**
	* Cancel the request from the caller's side. An aborted signal rejects
	* with the signal's reason immediately and never retries; it is combined
	* with the transport's own per-attempt timeout.
	*/
	signal?: AbortSignal
	/**
	* Override the transport's retry budget for this one request. Broadcasts
	* pass `0`: re-sending a transaction the node may already hold trades a
	* transient failure for a confusing nonce conflict.
	*/
	retryCount?: number
};
/** Shared configuration for all transport types. */
type TransportConfig = {
	url?: string
	/**
	* Per-attempt deadline in ms covering headers AND body. A stalled body
	* rejects with `TimeoutError` instead of hanging. Default 30_000.
	*/
	timeout?: number
	retryCount?: number
	retryDelay?: number
	fetchOptions?: RequestInit
	/** Sent as `x-api-key`. Held in the request closure and stripped from
	*  `Transport.config` so it never prints with the client. */
	apiKey?: string
};
/** A resolved transport instance with a bound request function. */
type Transport = {
	type: string
	request: RequestFn
	config: TransportConfig
	destroy?: () => void
};
/** Union of all supported account types (local key, custom signer, or browser provider). */
type Account = LocalAccount | CustomAccount | ProviderAccount;
/**
* Core client instance that holds chain context, transport, and extensible actions.
* Created via {@link createClient}, {@link createPublicClient}, or {@link createWalletClient}.
*/
type Client<TExtended extends Record<string, unknown> = Record<string, unknown>> = {
	chain?: StacksChain
	account?: Account
	transport: Transport
	request: RequestFn
	/** Optional nonce manager for mempool-safe sequential nonces across rapid broadcasts. */
	nonceManager?: NonceManager
	extend: <const TNew extends Record<string, unknown>>(fn: (client: Client<TExtended>) => TNew) => Client<TExtended & TNew> & TNew
} & TExtended;
type GetNonceParams = {
	address: string
};
declare function getNonce(client: Client, params: GetNonceParams): Promise<bigint>;
type GetBalanceParams = {
	address: string
};
declare function getBalance(client: Client, params: GetBalanceParams): Promise<bigint>;
type GetAccountInfoParams = {
	address: string
};
type AccountInfo = {
	balance: bigint
	nonce: bigint
	balanceProof: string
	nonceProof: string
};
declare function getAccountInfo(client: Client, params: GetAccountInfoParams): Promise<AccountInfo>;
type GetBlockParams = {
	height?: number
	hash?: string
};
/**
* Fetch one block by hash or height, or the chain tip when both are omitted.
* Every path resolves to a single block object: the tip read unwraps the
* list envelope the extended API returns for `?limit=1`.
*/
declare function getBlock(client: Client, params?: GetBlockParams): Promise<any>;
type GetRawBlockParams = {
	height: number
};
/**
* Raw node RPC block shape (`/v2/blocks/{height}`) — distinct from
* {@link getBlock}'s Hiro extended-API shape. Carries consensus/identity
* fields (`index_block_hash`, `miner_txid`, ...) that the indexed API doesn't
* expose, for trust-minimized use cases (e.g. block-header proofs) that can't
* rely on a third-party indexer.
*/
type RawBlockResponse = {
	hash: string
	height: number
	parent_block_hash: string
	burn_block_height: number
	burn_block_hash: string
	burn_block_time: number
	index_block_hash: string
	parent_index_block_hash: string
	miner_txid: string
	txs: string[]
};
/**
* Fetch a block by height directly from a stacks-node (not Hiro's extended
* API — see {@link getBlock} for that). Returns `null` when the node has no
* block at that height.
*/
declare function getRawBlock(client: Client, params: GetRawBlockParams): Promise<RawBlockResponse | null>;
declare function getBlockHeight(client: Client): Promise<number>;
type ReadContractParams = {
	contract: string
	functionName: string
	args?: ClarityValue[]
	sender?: string
	/**
	* Nakamoto StacksBlockId to evaluate against. Without it the node answers
	* at its own moving tip, which makes a read non-deterministic — the same
	* reindex of the same block can return a different value.
	*/
	tip?: string
};
declare function readContract<T extends ClarityValue = ClarityValue>(client: Client, params: ReadContractParams): Promise<T>;
type GetContractAbiParams = {
	contract: string
};
declare function getContractAbi(client: Client, params: GetContractAbiParams): Promise<any>;
type GetContractSourceParams = {
	contract: string
};
type ContractSourceResponse = {
	source: string
	publish_height: number
	marf_proof?: string
};
/**
* Fetch a deployed contract's Clarity source. Node-RPC only (`/v2/contracts/source`)
* — not available through Hiro's extended API or a tenant proxy, so `client`
* must be configured against a direct node transport. Returns `null` when the
* node has no source for the contract.
*/
declare function getContractSource(client: Client, params: GetContractSourceParams): Promise<ContractSourceResponse | null>;
type GetDataVarParams = {
	contract: string
	varName: string
};
declare function getDataVar<T extends ClarityValue = ClarityValue>(client: Client, params: GetDataVarParams): Promise<T>;
type GetMapEntryParams = {
	contract: string
	mapName: string
	key: ClarityValue
};
declare function getMapEntry<T extends ClarityValue = ClarityValue>(client: Client, params: GetMapEntryParams): Promise<T>;
type EstimateFeeParams = {
	transaction: StacksTransaction
};
type FeeEstimation = {
	feeRate: number
	fee: number
};
declare function estimateFee(client: Client, params: EstimateFeeParams): Promise<FeeEstimation[]>;
type MulticallCall = {
	contract: string
	functionName: string
	args?: ClarityValue[]
	sender?: string
};
type MulticallParams<TAllowFailure extends boolean = true> = {
	calls: readonly MulticallCall[]
	allowFailure?: TAllowFailure
	/**
	* Reads in flight at once. Default 8. Each call is its own
	* `/v2/contracts/call-read` request (Stacks nodes have no batch RPC), so
	* an uncapped fan-out turns one multicall into a burst that trips rate
	* limits and then retries in lockstep.
	*/
	concurrency?: number
};
type MulticallSuccessResult = {
	status: "success"
	result: ClarityValue
};
type MulticallFailureResult = {
	status: "failure"
	error: Error
};
type MulticallResult<T extends boolean> = T extends true ? (MulticallSuccessResult | MulticallFailureResult)[] : ClarityValue[];
declare function multicall<TAllowFailure extends boolean = true>(client: Client, params: MulticallParams<TAllowFailure>): Promise<MulticallResult<TAllowFailure>>;
declare class BaseError extends Error {
	private;
	name: string;
	shortMessage: string;
	details?: string;
	constructor(shortMessage: string, options?: {
		cause?: Error
		details?: string
		code?: string
	});
	/**
	* Stable identifier for programmatic handling; survives message
	* rewording and minification. An explicit `code` option wins, else it
	* is derived from `name` (`TimeoutError` gives `TIMEOUT_ERROR`).
	*/
	get code(): string;
	set code(value: string);
	toJSON(): {
		name: string
		code: string
		message: string
		shortMessage: string
		details: string | undefined
		cause: string | undefined
	};
}
declare class SimulationError extends BaseError {
	name: string;
	writesDetected: boolean;
	constructor(message: string, options: {
		writesDetected: boolean
		details?: string
	});
}
type SimulateCallParams = {
	contract: string
	functionName: string
	args?: ClarityValue[]
	sender?: string
	tip?: string
};
type SimulateCallSuccess = {
	success: true
	result: ClarityValue
};
type SimulateCallFailure = {
	success: false
	error: SimulationError
};
type SimulateCallResult = SimulateCallSuccess | SimulateCallFailure;
declare function simulateCall(client: Client, params: SimulateCallParams): Promise<SimulateCallResult>;
type SimulateTransactionParams = {
	transaction: StacksTransaction
	sender?: string
	tip?: string
};
type SimulateContractCallResult = {
	type: "contract-call"
	execution: SimulateCallResult
	fees: FeeEstimation[]
};
type SimulateTransferResult = {
	type: "token-transfer"
	fees: FeeEstimation[]
};
type SimulateDeployResult = {
	type: "contract-deploy"
	fees: FeeEstimation[]
};
type SimulateTransactionResult = SimulateContractCallResult | SimulateTransferResult | SimulateDeployResult;
declare function simulateTransaction(client: Client, params: SimulateTransactionParams): Promise<SimulateTransactionResult>;
/**
* Pluggable transaction-status sources for {@link getTransaction} /
* `waitForTransactionReceipt`.
*
* A bare stacks-node has no confirmed-transaction endpoint, so status reads
* need a host that indexes transactions. Where that data comes from is
* pluggable, mirroring the nonce sources:
*
*   - {@link extendedApiSource} — default; `/extended/v1/tx/{txid}` on the
*     client's transport host (Hiro API or any extended-API-compatible host).
*   - {@link indexTxSource}: a Secondlayer instance's
*     `/v1/index/transactions/{txid}`; returns the chain tip in the same
*     response, so N-confirmation waits need no second request.
*/
type TransactionStatus = "pending" | "success" | "abort_by_response" | "abort_by_post_condition" | "dropped";
type TransactionReceipt = {
	txid: string
	status: TransactionStatus
	/** Anchor block height; absent while pending. */
	blockHeight?: number
	blockHash?: string
	/** Decoded Clarity result; absent while pending or when the source omits it. */
	result?: ClarityValue
	resultHex?: string
	events: unknown[]
	/** The source's unnormalized response, for fields the receipt doesn't model. */
	raw: unknown
};
type TransactionSnapshot = {
	/** `null` when the source has no record of the tx (mempool + chain). */
	receipt: TransactionReceipt | null
	/** Chain tip height, when the source knows it (saves a round-trip). */
	tip?: number
};
type TransactionStatusSource = {
	get(args: {
		client: Client
		txid: string
	}): Promise<TransactionSnapshot>
	/**
	* True when the source only knows mined transactions and reports
	* `receipt: null` for the whole mempool life of a tx. The wait action
	* then stretches its dropped-grace window to the full timeout, since
	* "unknown" cannot mean "dropped" until the deadline.
	*/
	canonicalOnly?: boolean
};
/**
* Default source: `GET /extended/v1/tx/{txid}` via the client's transport.
* Requires a host that serves Hiro's extended API (a bare stacks-node does
* not). Does not report the chain tip — the wait action fetches it separately
* when `confirmations > 1`.
*/
declare function extendedApiSource(): TransactionStatusSource;
type IndexTxSourceParams = {
	/**
	* URL of your Secondlayer instance. Without it the client's transport
	* URL is assumed to be the instance: a transport on a Hiro host throws
	* up front, and a host that answers `/v1/index` with a non-JSON 404
	* (a bare stacks-node) throws on the first read. Pass it whenever the
	* transport is not the instance.
	*/
	baseUrl?: string
	/** Instance token, sent as `Authorization: Bearer`. */
	apiKey?: string
};
/**
* Source backed by a Secondlayer instance's `/v1/index/transactions/{txid}`.
* The response embeds the chain tip, so N-confirmation math needs no extra
* request. Requests go through the transport layer: same retries, timeout
* and typed errors as every other read. The index only returns canonical
* (mined) transactions; while a tx is in the mempool this source reports
* `receipt: null`, and the wait action's grace window carries it until
* inclusion.
*/
declare function indexTxSource(params?: IndexTxSourceParams): TransactionStatusSource;
type GetTransactionParams = {
	txid: string
	/** Where to read status from. Defaults to {@link extendedApiSource}. */
	source?: TransactionStatusSource
};
/**
* Fetch a transaction's receipt (status, block info, decoded result).
* Returns `null` when the source has no record of the transaction.
*/
declare function getTransaction(client: Client, params: GetTransactionParams): Promise<TransactionReceipt | null>;
type GetAccountHistoryParams = {
	address: string
	/** Capped at 50. Default 20. */
	limit?: number
};
type AccountHistoryResponse = {
	results: unknown[]
	total: number
};
/** Paginated transaction history for a principal (Hiro extended API). */
declare function getAccountHistory(client: Client, params: GetAccountHistoryParams): Promise<AccountHistoryResponse>;
/**
* Current mempool statistics: pending count, fee distribution, age buckets
* (Hiro extended API).
*/
declare function getMempoolStats(client: Client): Promise<any>;
type GetNftHoldingsParams = {
	address: string
	/** Capped at 50. Default 20. */
	limit?: number
};
type NftHoldingsResponse = {
	results: unknown[]
	total: number
};
/** NFT holdings for a principal across all collections (Hiro extended API). */
declare function getNftHoldings(client: Client, params: GetNftHoldingsParams): Promise<NftHoldingsResponse>;
type WaitForTransactionReceiptParams = {
	txid: string
	/** Anchor-block confirmations to wait for. Default 1 (mined). */
	confirmations?: number
	/** Give up after this many ms. Default 180_000 (3 min). */
	timeout?: number
	/** Delay between status polls, ms. Default 3_000. */
	pollingInterval?: number
	/**
	* How long a tx may be unknown to the source before it counts as dropped,
	* ms. Covers broadcast propagation lag. Default 30_000, or the full
	* `timeout` for a canonical-only source (one that cannot see the
	* mempool, so "unknown" means "not mined yet" until the deadline).
	*/
	droppedGracePeriod?: number
	/** Where to read status from. Defaults to {@link extendedApiSource}. */
	source?: TransactionStatusSource
};
/**
* Poll until a transaction is mined with N confirmations, then return its
* receipt.
*
* Rejects with {@link TransactionAbortedError} when the tx mines but aborts
* (`abort_by_response` / `abort_by_post_condition`) — the receipt is attached.
* Rejects with {@link TransactionDroppedError} when the tx leaves the mempool
* unmined or stays unknown past `droppedGracePeriod`, and
* {@link WaitForTransactionTimeoutError} at `timeout`.
*
* Reorg-tolerant: every cycle re-reads the receipt (block height may change)
* and recomputes confirmations from the current tip.
*/
declare function waitForTransactionReceipt(client: Client, params: WaitForTransactionReceiptParams): Promise<TransactionReceipt>;
/** Handle returned by WebSocket subscription methods; call `unsubscribe()` to stop. */
type Subscription = {
	unsubscribe: () => void
};
type BlockNotification = {
	canonical: boolean
	height: number
	hash: string
	index_block_hash: string
	parent_block_hash: string
	burn_block_height: number
	burn_block_hash: string
	parent_burn_block_hash: string
	parent_burn_block_height: number
	parent_index_block_hash: string
	txs: string[]
};
type MempoolNotification = {
	tx_id: string
	tx_type: string
	tx_status: string
	receipt_time: number
	receipt_time_iso: string
	fee_rate: string
	sender_address: string
	sponsor_address?: string
	nonce: number
	contract_call?: {
		contract_id: string
		function_name: string
		function_signature: string
	}
	token_transfer?: {
		recipient_address: string
		amount: string
		memo: string
	}
};
type TxUpdateNotification = {
	tx_id: string
	tx_type: string
	tx_status: string
	block_hash?: string
	block_height?: number
	burn_block_height?: number
	burn_block_time?: number
	tx_result?: {
		hex: string
		repr: string
	}
};
type AddressTxNotification = {
	address: string
	tx_id: string
	tx_type: string
	tx_status: string
	stx_sent: string
	stx_received: string
	stx_transfers: Array<{
		amount: string
		sender: string
		recipient: string
	}>
	ft_transfers: Array<{
		amount: string
		asset_identifier: string
		sender: string
		recipient: string
	}>
	nft_transfers: Array<{
		asset_identifier: string
		sender: string
		recipient: string
		value: {
			hex: string
			repr: string
		}
	}>
};
type AddressBalanceNotification = {
	address: string
	balance: string
	total_sent: string
	total_received: string
	total_fees_sent: string
	total_miner_rewards_received: string
	lock_tx_id: string
	locked: string
	lock_height: number
	burnchain_lock_height: number
	burnchain_unlock_height: number
};
type NftEventNotification = {
	sender: string
	recipient: string
	asset_identifier: string
	asset_event_type: string
	value: {
		hex: string
		repr: string
	}
	tx_id: string
	block_height: number
};
type WatchBlocksParams = {
	onBlock: (block: BlockNotification) => void
};
declare function watchBlocks(client: Client, params: WatchBlocksParams): Promise<Subscription>;
type WatchMempoolParams = {
	onTransaction: (tx: MempoolNotification) => void
};
declare function watchMempool(client: Client, params: WatchMempoolParams): Promise<Subscription>;
type WatchTransactionParams = {
	txId: string
	onUpdate: (update: TxUpdateNotification) => void
};
declare function watchTransaction(client: Client, params: WatchTransactionParams): Promise<Subscription>;
type WatchAddressParams = {
	address: string
	onTransaction: (tx: AddressTxNotification) => void
};
declare function watchAddress(client: Client, params: WatchAddressParams): Promise<Subscription>;
type WatchAddressBalanceParams = {
	address: string
	onBalance: (balance: AddressBalanceNotification) => void
};
declare function watchAddressBalance(client: Client, params: WatchAddressBalanceParams): Promise<Subscription>;
type WatchNftEventParams = {
	onEvent: (event: NftEventNotification) => void
	assetIdentifier?: string
	value?: string
};
declare function watchNftEvent(client: Client, params: WatchNftEventParams): Promise<Subscription>;
type SendTransactionParams = {
	transaction: StacksTransaction
	attachment?: Uint8Array | string
	/**
	* Wait for the transaction to be mined before returning. `true` waits for
	* 1 confirmation; a number waits for that many. The receipt lands on the
	* result. Rejects if the tx aborts, is dropped, or the wait times out.
	*/
	wait?: boolean | number
};
type SendTransactionResult = {
	txid: string
	/** Present when `wait` was requested. */
	receipt?: TransactionReceipt
};
/** Broadcast a signed transaction to the network */
declare function sendTransaction(client: Client, params: SendTransactionParams): Promise<SendTransactionResult>;
type SignTransactionParams = {
	transaction: StacksTransaction
	/** Public keys for multi-sig signing (auto-detected from _multisig metadata if omitted) */
	signers?: string[]
};
/** Sign a transaction using the client's account */
declare function signTransactionAction(client: Client, params: SignTransactionParams): Promise<StacksTransaction>;
type FungibleComparator = "eq" | "gt" | "gte" | "lt" | "lte";
type NonFungibleComparator = "sent" | "not-sent" | "maybe-sent";
type StxPostCondition = {
	type: "stx-postcondition"
	address: string
	condition: FungibleComparator
	amount: string | bigint | number
};
type FtPostCondition = {
	type: "ft-postcondition"
	address: string
	condition: FungibleComparator
	asset: string
	amount: string | bigint | number
};
type NftPostCondition = {
	type: "nft-postcondition"
	address: string
	condition: NonFungibleComparator
	asset: string
	assetId: ClarityValue
};
type StakingPostCondition = {
	type: "staking-postcondition"
	address: string
	condition: FungibleComparator
	amount: string | bigint | number
};
type PoxComparator = "will-not-perform" | "may-perform" | "will-perform";
type PoxPostCondition = {
	type: "pox-postcondition"
	address: string
	condition: PoxComparator
};
type PostCondition = StxPostCondition | FtPostCondition | NftPostCondition | StakingPostCondition | PoxPostCondition;
/** Serialized PC hex is accepted anywhere a `PostCondition` object is. */
type PostConditionInput = PostCondition | string;
type PostConditionMode = "allow" | "deny" | "originator";
type IntegerType = number | string | bigint | Uint8Array;
declare function isProviderAccount(account: Account): account is ProviderAccount;
/**
* Named fee tiers. `'low' | 'mid' | 'high'` map to the node's three fee
* estimations; `'min'` is the node's minimum relay fee — 1 uSTX per byte of
* the serialized transaction, computable offline.
*/
type FeeTier = "min" | "low" | "mid" | "high";
/** Fee input accepted by wallet actions: an explicit amount or a named tier. */
type FeeParam = IntegerType | FeeTier;
declare function isFeeTier(fee: FeeParam | undefined): fee is FeeTier;
/**
* Minimum relay fee: 1 uSTX per byte of the serialized transaction. The fee
* field is fixed-width (8 bytes), so the size — and therefore this floor — is
* stable regardless of the fee value later set on the spending condition.
*/
declare function minimumFee(transaction: StacksTransaction): bigint;
/** Outcome of {@link resolveFee}: the amount and which tier produced it. */
type ResolvedFee = {
	fee: bigint
	/**
	* Tier the amount came from. `'min'` when the estimator had no estimate
	* and the relay floor was used instead. Absent when the caller passed an
	* exact amount.
	*/
	tier?: FeeTier
};
/**
* True when the node answered `POST /v2/fees/transaction` with 400
* `NoEstimateAvailable`: it is healthy but has no fee history for this
* payload (fresh devnet, quiet chain). Every other failure means the
* estimate was never obtained and must surface to the caller.
*/
declare function isNoEstimateAvailable(error: unknown): boolean;
/**
* Resolve a fee param to a concrete amount. Numeric input passes through.
* Tiers `'low' | 'mid' | 'high'` index the node's estimations (nearest
* available when fewer than three are returned); `'min'` resolves to
* {@link minimumFee}, which needs no network round-trip.
*
* The relay floor is the fallback ONLY when the node reports
* `NoEstimateAvailable` or returns no estimations. A transport timeout, 5xx,
* or auth failure rethrows: silently under-paying because the node was
* unreachable would strand the transaction in the mempool.
*/
declare function resolveFee(client: Client, transaction: StacksTransaction, fee: FeeParam | undefined): Promise<ResolvedFee>;
type TransferStxParams = {
	to: string
	amount: IntegerType
	memo?: string
	fee?: FeeParam
	nonce?: IntegerType
	postConditionMode?: PostConditionMode
	postConditions?: PostConditionInput[]
};
/** Build, sign, and broadcast an STX transfer */
declare function transferStx(client: Client, params: TransferStxParams): Promise<string>;
type CallContractParams = {
	contract: string
	functionName: string
	functionArgs?: ClarityValue[]
	fee?: FeeParam
	nonce?: IntegerType
	postConditionMode?: PostConditionMode
	postConditions?: PostConditionInput[]
};
/** Build, sign, and broadcast a contract call */
declare function callContract(client: Client, params: CallContractParams): Promise<string>;
type DeployContractParams = {
	contractName: string
	codeBody: string
	clarityVersion?: ClarityVersion
	fee?: FeeParam
	nonce?: IntegerType
	postConditionMode?: PostConditionMode
	postConditions?: PostConditionInput[]
};
/** Build, sign, and broadcast a contract deploy */
declare function deployContract(client: Client, params: DeployContractParams): Promise<string>;
type SignMessageParams = {
	message: string | ClarityValue
	domain?: {
		name: string
		version: string
		chainId: number
	}
};
/** Sign a message. With `domain`, hashes per SIP-018; without, hashes the serialized CV. */
declare function signMessage2(client: Client, params: SignMessageParams): Promise<string>;
type SponsorTransactionParams = {
	transaction: StacksTransaction
	fee?: FeeParam
	nonce?: IntegerType
};
/** Sponsor a transaction: set sponsor spending condition, sign as sponsor */
declare function sponsorTransaction(client: Client, params: SponsorTransactionParams): Promise<StacksTransaction>;
type AbiUInt128 = "uint128";
type AbiInt128 = "int128";
type AbiBool = "bool";
type AbiPrincipal = "principal";
type AbiTraitReference = "trait_reference";
type AbiNone = "none";
type AbiStringAscii<L extends number = number> = {
	"string-ascii": {
		length: L
	}
};
type AbiStringUtf8<L extends number = number> = {
	"string-utf8": {
		length: L
	}
};
type AbiBuffer<L extends number = number> = {
	buff: {
		length: L
	}
};
type AbiPrimitiveType = AbiUInt128 | AbiInt128 | AbiBool | AbiPrincipal | AbiTraitReference | AbiNone | AbiStringAscii | AbiStringUtf8 | AbiBuffer;
interface AbiListType {
	list: {
		type: AbiType
		length: number
	};
}
interface AbiTupleType {
	tuple: ReadonlyArray<{
		name: string
		type: AbiType
	}>;
}
interface AbiOptionalType {
	optional: AbiType;
}
interface AbiResponseType {
	response: {
		ok: AbiType
		error: AbiType
	};
}
/** Discriminated union of all Clarity value types (primitives, buffers, lists, tuples, optionals, responses). */
type AbiType = AbiPrimitiveType | AbiListType | AbiTupleType | AbiOptionalType | AbiResponseType;
type CamelCaseInner<S extends string> = S extends `${infer P1}-${infer P2}${infer P3}` ? `${P1}${Capitalize<CamelCaseInner<`${P2}${P3}`>>}` : S;
type ToCamelCase<S extends string> = CamelCaseInner<S> extends `${number}${string}` ? `_${CamelCaseInner<S>}` : CamelCaseInner<S>;
type TupleToObject<T extends ReadonlyArray<{
	name: string
	type: AbiType
}>> = { [K in T[number]["name"] as ToCamelCase<K>] : AbiToTS<Extract<T[number], {
	name: K
}>["type"]> };
type AbiToTS<T extends AbiType> = T extends "none" ? never : T extends "uint128" ? bigint : T extends "int128" ? bigint : T extends "bool" ? boolean : T extends "principal" ? string : T extends "trait_reference" ? string : T extends {
	"string-ascii": any
} ? string : T extends {
	"string-utf8": any
} ? string : T extends {
	buff: any
} ? Uint8Array : T extends {
	list: {
		type: infer U extends AbiType
	}
} ? Array<AbiToTS<U>> : T extends {
	optional: infer U extends AbiType
} ? AbiToTS<U> | null : T extends {
	response: {
		ok: infer O extends AbiType
		error: infer E extends AbiType
	}
} ? {
	ok: AbiToTS<O>
} | {
	err: AbiToTS<E>
} : T extends {
	tuple: infer Fields extends ReadonlyArray<{
		name: string
		type: AbiType
	}>
} ? TupleToObject<Fields> : never;
type FunctionAccess = "public" | "read-only" | "private";
interface FunctionArg {
	name: string;
	type: AbiType;
}
/** A single Clarity function definition with name, access level, arguments, and return type. */
interface AbiFunction {
	name: string;
	access: FunctionAccess;
	args: ReadonlyArray<FunctionArg>;
	outputs: AbiType;
}
type VariableAccess = "constant" | "variable";
interface AbiVariable {
	name: string;
	type: AbiType;
	access: VariableAccess;
}
interface AbiMap {
	name: string;
	key: AbiType;
	value: AbiType;
}
interface AbiFungibleToken {
	name: string;
}
interface AbiNonFungibleToken {
	name: string;
	type: AbiType;
}
type TraitFunctionAccess = Exclude<FunctionAccess, "private">;
interface AbiTraitFunction {
	name: string;
	access: TraitFunctionAccess;
	args: ReadonlyArray<FunctionArg>;
	outputs: AbiType;
}
interface AbiTraitDefinition {
	name: string;
	functions: ReadonlyArray<AbiTraitFunction>;
}
/** Full Clarity contract ABI including functions, maps, variables, and token definitions. */
interface AbiContract {
	functions: ReadonlyArray<AbiFunction>;
	maps?: ReadonlyArray<AbiMap>;
	variables?: ReadonlyArray<AbiVariable>;
	fungible_tokens?: ReadonlyArray<AbiFungibleToken>;
	non_fungible_tokens?: ReadonlyArray<AbiNonFungibleToken>;
	implemented_traits?: ReadonlyArray<string>;
	defined_traits?: ReadonlyArray<AbiTraitDefinition>;
}
declare const abiTypes: unique symbol;
/**
* Phantom type bundle a codegen tool can fuse onto an as-const ABI literal.
*
* Function/map keys are camelCase (matching the runtime client's method names)
* and `args` is the named-args object each method accepts. `ret` is the raw
* output type before any response unwrapping.
*/
type ContractTypes = {
	functions: Record<string, {
		args: object
		ret: unknown
		access: "public" | "read-only" | "private"
	}>
	maps?: Record<string, {
		key: unknown
		value: unknown
	}>
};
/**
* Resolve the brand off an ABI type. `never` for un-branded ABIs, which lets
* consumers fall back to structural inference.
*/
type AbiTypesOf<C> = C extends {
	readonly [abiTypes]?: infer T
} ? NonNullable<T> extends ContractTypes ? NonNullable<T> : never : never;
type ExtractFunctionNames<
	C extends AbiContract,
	Access extends FunctionAccess = FunctionAccess
> = Extract<C["functions"][number], {
	access: Access
}>["name"];
type ExtractFunction<
	C extends AbiContract,
	N extends ExtractFunctionNames<C>
> = Extract<C["functions"][number], {
	name: N
}>;
type ExtractFunctionArgs<
	C extends AbiContract,
	N extends ExtractFunctionNames<C>
> = ExtractFunction<C, N> extends {
	args: infer Args extends ReadonlyArray<{
		name: string
		type: any
	}>
} ? { [K in Args[number]["name"] as ToCamelCase<K>] : AbiToTS<Extract<Args[number], {
	name: K
}>["type"]> } : never;
type ExtractFunctionOutput<
	C extends AbiContract,
	N extends ExtractFunctionNames<C>
> = ExtractFunction<C, N> extends {
	outputs: infer O extends AbiType
} ? AbiToTS<O> : never;
type ExtractPublicFunctions<C extends AbiContract> = ExtractFunctionNames<C, "public">;
type ExtractReadOnlyFunctions<C extends AbiContract> = ExtractFunctionNames<C, "read-only">;
type ExtractMapNames<C extends AbiContract> = C["maps"] extends ReadonlyArray<{
	name: infer N extends string
}> ? N : never;
type ExtractMap<
	C extends AbiContract,
	N extends ExtractMapNames<C>
> = C["maps"] extends ReadonlyArray<infer M> ? Extract<M, {
	name: N
}> : never;
type ExtractMapKey<
	C extends AbiContract,
	N extends ExtractMapNames<C>
> = ExtractMap<C, N> extends {
	key: infer K extends AbiType
} ? AbiToTS<K> : never;
type ExtractMapValue<
	C extends AbiContract,
	N extends ExtractMapNames<C>
> = ExtractMap<C, N> extends {
	value: infer V extends AbiType
} ? AbiToTS<V> : never;
/**
* Unwrap `(response ok err)` → just the `ok` branch type. Distributes over the
* `{ ok } | { err }` union: the `err` branch maps to `never` (it throws
* `ContractResponseError` at runtime, so it never reaches the caller).
*/
type UnwrapResponse<T> = T extends {
	ok: infer O
} ? O : T extends {
	err: unknown
} ? never : T;
/**
* True for a structural empty mapped type (`{}`) and for codegen's
* `Record<string, never>`. `keyof Record<string, never>` is `string`, so the
* first check alone is not enough.
*/
type IsEmptyArgs<A> = [keyof A & string] extends [never] ? true : Record<string, never> extends A ? true : false;
/** No-arg ABI functions may omit the dummy `{}`. Functions with args stay required. */
type ContractMethod<
	A,
	R,
	Extra extends unknown[] = []
> = IsEmptyArgs<A> extends true ? (args?: A, ...extra: Extra) => R : (args: A, ...extra: Extra) => R;
type ReadMethodReturn<
	C extends AbiContract,
	N extends ExtractReadOnlyFunctions<C>
> = UnwrapResponse<ExtractFunctionOutput<C, N>>;
/**
* When the ABI carries a codegen brand (`TypedAbi`), method types resolve to
* the generated named aliases — cleaner hovers and error messages. Un-branded
* ABIs fall back to structural inference over the as-const literal.
*/
type TypedReadMethods<T extends ContractTypes> = { [K in keyof T["functions"] as T["functions"][K]["access"] extends "read-only" ? K : never] : ContractMethod<T["functions"][K]["args"], Promise<UnwrapResponse<T["functions"][K]["ret"]>>> };
type TypedCallMethods<T extends ContractTypes> = { [K in keyof T["functions"] as T["functions"][K]["access"] extends "public" ? K : never] : ContractMethod<T["functions"][K]["args"], Promise<string>, [options?: ContractCallOptions]> };
type TypedMapMethods<T extends ContractTypes> = { [K in keyof NonNullable<T["maps"]>] : (key: NonNullable<T["maps"]>[K]["key"]) => Promise<NonNullable<T["maps"]>[K]["value"] | null> };
type ReadMethods<C extends AbiContract> = [AbiTypesOf<C>] extends [never] ? { [N in ExtractReadOnlyFunctions<C> as ToCamelCase<N>] : ContractMethod<ExtractFunctionArgs<C, N>, Promise<ReadMethodReturn<C, N>>> } : TypedReadMethods<AbiTypesOf<C>>;
type CallMethods<C extends AbiContract> = [AbiTypesOf<C>] extends [never] ? { [N in ExtractPublicFunctions<C> as ToCamelCase<N>] : ContractMethod<ExtractFunctionArgs<C, N>, Promise<string>, [options?: ContractCallOptions]> } : TypedCallMethods<AbiTypesOf<C>>;
type MapMethods<C extends AbiContract> = [AbiTypesOf<C>] extends [never] ? { [N in ExtractMapNames<C> as ToCamelCase<N>] : (key: ExtractMapKey<C, N>) => Promise<ExtractMapValue<C, N> | null> } : TypedMapMethods<AbiTypesOf<C>>;
type ContractCallOptions = {
	fee?: IntegerType
	nonce?: IntegerType
	postConditionMode?: PostConditionMode
	postConditions?: PostConditionInput[]
};
/**
* Options for `buildCall.*`, building an unsigned transaction for
* wallet-signs-later flows. `publicKey` defaults to the client account's
* public key. When omitted, `nonce` is the confirmed on-chain nonce read
* straight from the node (the client's nonce manager is never consumed for
* a transaction that may never be sent) and `fee` is the mid estimate,
* falling back to the relay floor only on `NoEstimateAvailable`.
*/
type ContractBuildCallOptions = ContractCallOptions & {
	publicKey?: string
	sponsored?: boolean
};
type TypedBuildCallMethods<T extends ContractTypes> = { [K in keyof T["functions"] as T["functions"][K]["access"] extends "public" ? K : never] : ContractMethod<T["functions"][K]["args"], Promise<StacksTransaction>, [options?: ContractBuildCallOptions]> };
type BuildCallMethods<C extends AbiContract> = [AbiTypesOf<C>] extends [never] ? { [N in ExtractPublicFunctions<C> as ToCamelCase<N>] : ContractMethod<ExtractFunctionArgs<C, N>, Promise<StacksTransaction>, [options?: ContractBuildCallOptions]> } : TypedBuildCallMethods<AbiTypesOf<C>>;
type ContractInstance<C extends AbiContract> = {
	read: ReadMethods<C>
	call: CallMethods<C>
	/** Build unsigned transactions (wallet-signs-later) — never broadcasts. */
	buildCall: BuildCallMethods<C>
	maps: MapMethods<C>
};
type GetContractParams<C extends AbiContract> = {
	client: Client
	address: string
	name: string
	abi: C
};
declare function getContract<const TAbi extends AbiContract>(params: GetContractParams<TAbi>): ContractInstance<TAbi>;
/**
* Encode an ABI function's named args into positional ClarityValues. Exported
* so a caller that needs the raw ClarityValue result (to cache or re-serialize
* it) can reuse the same encoding this module's read methods use, instead of
* maintaining a second one that drifts.
*/
declare function buildFunctionArgs(fn: AbiFunction, args?: Record<string, unknown>): ClarityValue[];
/** True when an ABI output is a `(response ok err)` and needs unwrapping. */
declare function isResponseOutput(type: AbiType): boolean;
declare class ContractResponseError extends Error {
	readonly errorValue: unknown;
	name: string;
	constructor(message: string, errorValue: unknown);
}
export { AccountHistoryResponse, AccountInfo, CallContractParams, ContractBuildCallOptions, ContractCallOptions, ContractInstance, ContractResponseError, ContractSourceResponse, DeployContractParams, EstimateFeeParams, FeeEstimation, FeeParam, FeeTier, GetAccountHistoryParams, GetAccountInfoParams, GetBalanceParams, GetBlockParams, GetContractAbiParams, GetContractParams, GetContractSourceParams, GetDataVarParams, GetMapEntryParams, GetNftHoldingsParams, GetNonceParams, GetRawBlockParams, GetTransactionParams, IndexTxSourceParams, MulticallCall, MulticallFailureResult, MulticallParams, MulticallResult, MulticallSuccessResult, NftHoldingsResponse, RawBlockResponse, ReadContractParams, ResolvedFee, SendTransactionParams, SendTransactionResult, SignMessageParams, SignTransactionParams, SimulateCallFailure, SimulateCallParams, SimulateCallResult, SimulateCallSuccess, SimulateContractCallResult, SimulateDeployResult, SimulateTransactionParams, SimulateTransactionResult, SimulateTransferResult, SponsorTransactionParams, TransactionReceipt, TransactionSnapshot, TransactionStatus, TransactionStatusSource, TransferStxParams, UnwrapResponse, WaitForTransactionReceiptParams, WatchAddressBalanceParams, WatchAddressParams, WatchBlocksParams, WatchMempoolParams, WatchNftEventParams, WatchTransactionParams, buildFunctionArgs, callContract, deployContract, estimateFee, extendedApiSource, getAccountHistory, getAccountInfo, getBalance, getBlock, getBlockHeight, getContract, getContractAbi, getContractSource, getDataVar, getMapEntry, getMempoolStats, getNftHoldings, getNonce, getRawBlock, getTransaction, indexTxSource, isFeeTier, isNoEstimateAvailable, isProviderAccount, isResponseOutput, minimumFee, multicall, readContract, resolveFee, sendTransaction, signMessage2 as signMessage, signTransactionAction, simulateCall, simulateTransaction, sponsorTransaction, transferStx, waitForTransactionReceipt, watchAddress, watchAddressBalance, watchBlocks, watchMempool, watchNftEvent, watchTransaction };