@secondlayer/stacks 0.0.1

package/dist/src/index.d.cts

@@ -0,0 +1,847 @@
+/** 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>
+};
+/** Shared configuration for all transport types. */
+type TransportConfig = {
+	url?: string
+	timeout?: number
+	retryCount?: number
+	retryDelay?: number
+	fetchOptions?: RequestInit
+	apiKey?: string
+};
+/** A resolved transport instance with a bound request function. */
+type Transport = {
+	type: string
+	request: RequestFn
+	config: TransportConfig
+	destroy?: () => void
+};
+/** Factory that creates a {@link Transport} given an optional chain context. */
+type TransportFactory = (params?: {
+	chain?: StacksChain
+}) => Transport;
+/** 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 structured message (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
+};
+/** 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
+	extend: <const TNew extends Record<string, unknown>>(fn: (client: Client<TExtended>) => TNew) => Client<TExtended & TNew> & TNew
+} & TExtended;
+/** Configuration for creating a base {@link Client}. */
+type ClientConfig = {
+	chain?: StacksChain
+	transport: TransportFactory
+	account?: Account
+};
+/** A client pre-extended with read-only {@link PublicActions}. */
+type PublicClient<TExtended extends Record<string, unknown> = Record<string, unknown>> = Client<TExtended>;
+/** A client pre-extended with {@link WalletActions} and a required account. */
+type WalletClient<TExtended extends Record<string, unknown> = Record<string, unknown>> = Client<TExtended> & {
+	account: Account
+};
+/**
+* Create a base client with transport and optional chain/account.
+* Use `.extend()` to compose action decorators (public, wallet, multisig).
+*/
+declare function createClient<TExtended extends Record<string, unknown> = Record<string, unknown>>(config: ClientConfig): Client<TExtended>;
+type GetNonceParams = {
+	address: string
+};
+type GetBalanceParams = {
+	address: string
+};
+type GetAccountInfoParams = {
+	address: string
+};
+type AccountInfo = {
+	balance: bigint
+	nonce: bigint
+	balanceProof: string
+	nonceProof: string
+};
+type GetBlockParams = {
+	height?: number
+	hash?: string
+};
+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;
+type ReadContractParams = {
+	contract: string
+	functionName: string
+	args?: ClarityValue[]
+	sender?: string
+};
+type GetContractAbiParams = {
+	contract: string
+};
+type GetMapEntryParams = {
+	contract: string
+	mapName: string
+	key: ClarityValue
+};
+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
+};
+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
+};
+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];
+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 TransactionPayload = TokenTransferPayload | ContractCallPayload | SmartContractPayload;
+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
+};
+type PostConditionWire = StxPostConditionWire | FtPostConditionWire | NftPostConditionWire;
+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 PostConditionPrincipalWire = {
+	type: "origin"
+} | {
+	type: "standard"
+	address: string
+} | {
+	type: "contract"
+	address: string
+	contractName: string
+};
+type AssetInfoWire = {
+	address: string
+	contractName: string
+	assetName: string
+};
+type EstimateFeeParams = {
+	transaction: StacksTransaction
+};
+type FeeEstimation = {
+	feeRate: number
+	fee: number
+};
+type MulticallCall = {
+	contract: string
+	functionName: string
+	args?: ClarityValue[]
+	sender?: string
+};
+type MulticallParams<TAllowFailure extends boolean = true> = {
+	calls: readonly MulticallCall[]
+	allowFailure?: TAllowFailure
+};
+type MulticallSuccessResult = {
+	status: "success"
+	result: ClarityValue
+};
+type MulticallFailureResult = {
+	status: "failure"
+	error: Error
+};
+type MulticallResult<T extends boolean> = T extends true ? (MulticallSuccessResult | MulticallFailureResult)[] : ClarityValue[];
+declare class BaseError extends Error {
+	name: string;
+	shortMessage: string;
+	details?: string;
+	constructor(shortMessage: string, options?: {
+		cause?: Error
+		details?: string
+	});
+	toJSON(): {};
+}
+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;
+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;
+/** Handle returned by WebSocket subscription methods; call `unsubscribe()` to stop. */
+type Subscription = {
+	unsubscribe: () => void
+};
+type WsEvent = "block" | "mempool" | "tx_update" | "address_tx_update" | "address_balance_update" | "nft_event" | "nft_asset_event" | "nft_collection_event";
+type WsSubscribeParams = {
+	event: WsEvent
+	tx_id?: string
+	address?: string
+	asset_identifier?: string
+	value?: string
+};
+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
+};
+type WatchMempoolParams = {
+	onTransaction: (tx: MempoolNotification) => void
+};
+type WatchTransactionParams = {
+	txId: string
+	onUpdate: (update: TxUpdateNotification) => void
+};
+type WatchAddressParams = {
+	address: string
+	onTransaction: (tx: AddressTxNotification) => void
+};
+type WatchAddressBalanceParams = {
+	address: string
+	onBalance: (balance: AddressBalanceNotification) => void
+};
+type WatchNftEventParams = {
+	onEvent: (event: NftEventNotification) => void
+	assetIdentifier?: string
+	value?: string
+};
+/** Read-only actions: balance queries, contract reads, block data, and event subscriptions. */
+type PublicActions = {
+	getNonce: (params: GetNonceParams) => Promise<bigint>
+	getBalance: (params: GetBalanceParams) => Promise<bigint>
+	getAccountInfo: (params: GetAccountInfoParams) => Promise<AccountInfo>
+	getBlock: (params: GetBlockParams) => Promise<any>
+	getBlockHeight: () => Promise<number>
+	readContract: (params: ReadContractParams) => Promise<ClarityValue>
+	getContractAbi: (params: GetContractAbiParams) => Promise<any>
+	getMapEntry: (params: GetMapEntryParams) => Promise<ClarityValue>
+	estimateFee: (params: EstimateFeeParams) => Promise<FeeEstimation[]>
+	multicall: <T extends boolean = true>(params: MulticallParams<T>) => Promise<MulticallResult<T>>
+	simulateCall: (params: SimulateCallParams) => Promise<SimulateCallResult>
+	simulateTransaction: (params: SimulateTransactionParams) => Promise<SimulateTransactionResult>
+	watchBlocks: (params: WatchBlocksParams) => Promise<Subscription>
+	watchMempool: (params: WatchMempoolParams) => Promise<Subscription>
+	watchTransaction: (params: WatchTransactionParams) => Promise<Subscription>
+	watchAddress: (params: WatchAddressParams) => Promise<Subscription>
+	watchAddressBalance: (params: WatchAddressBalanceParams) => Promise<Subscription>
+	watchNftEvent: (params: WatchNftEventParams) => Promise<Subscription>
+};
+/** Decorator that binds {@link PublicActions} to a client instance. */
+declare function publicActions(client: Client): PublicActions;
+/** Configuration for {@link createPublicClient} (no account needed). */
+type PublicClientConfig = Omit<ClientConfig, "account">;
+/**
+* Create a read-only client pre-extended with {@link PublicActions}.
+* Use for queries, contract reads, and event subscriptions.
+*/
+declare function createPublicClient(config: PublicClientConfig): Client<PublicActions> & PublicActions;
+type SendTransactionParams = {
+	transaction: StacksTransaction
+	attachment?: Uint8Array | string
+};
+type SendTransactionResult = {
+	txid: string
+};
+type SignTransactionParams = {
+	transaction: StacksTransaction
+	/** Public keys for multi-sig signing (auto-detected from _multisig metadata if omitted) */
+	signers?: string[]
+};
+type FungibleComparator = "eq" | "gt" | "gte" | "lt" | "lte";
+type NonFungibleComparator = "sent" | "not-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 PostCondition = StxPostCondition | FtPostCondition | NftPostCondition;
+type IntegerType = number | string | bigint | Uint8Array;
+type TransferStxParams = {
+	to: string
+	amount: IntegerType
+	memo?: string
+	fee?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+type CallContractParams = {
+	contract: string
+	functionName: string
+	functionArgs?: ClarityValue[]
+	fee?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+type DeployContractParams = {
+	contractName: string
+	codeBody: string
+	clarityVersion?: ClarityVersion
+	fee?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+type SignMessageParams = {
+	message: string | ClarityValue
+	domain?: {
+		name: string
+		version: string
+		chainId: number
+	}
+};
+type SponsorTransactionParams = {
+	transaction: StacksTransaction
+	fee?: IntegerType
+	nonce?: IntegerType
+};
+/** Signing actions: send transactions, transfer STX, call/deploy contracts, sign messages. */
+type WalletActions = {
+	sendTransaction: (params: SendTransactionParams) => Promise<SendTransactionResult>
+	signTransaction: (params: SignTransactionParams) => Promise<StacksTransaction>
+	transferStx: (params: TransferStxParams) => Promise<string>
+	callContract: (params: CallContractParams) => Promise<string>
+	deployContract: (params: DeployContractParams) => Promise<string>
+	signMessage: (params: SignMessageParams) => Promise<string>
+	sponsorTransaction: (params: SponsorTransactionParams) => Promise<StacksTransaction>
+};
+/** Decorator that binds {@link WalletActions} to a client instance. */
+declare function walletActions(client: Client): WalletActions;
+/** Configuration for {@link createWalletClient} — requires an account for signing. */
+type WalletClientConfig = ClientConfig & {
+	account: Account
+};
+/**
+* Create a client pre-extended with {@link WalletActions} for signing and broadcasting transactions.
+*/
+declare function createWalletClient(config: WalletClientConfig): Client<WalletActions> & WalletActions & {
+	account: Account
+};
+type MultiSigTransferStxParams = {
+	to: string
+	amount: IntegerType
+	memo?: string
+	fee?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+type MultiSigCallContractParams = {
+	contract: string
+	functionName: string
+	functionArgs?: ClarityValue[]
+	fee?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+type MultiSigDeployContractParams = {
+	contractName: string
+	codeBody: string
+	clarityVersion?: ClarityVersion
+	fee?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+type MultiSigSendTransactionParams = {
+	transaction: StacksTransaction
+	attachment?: Uint8Array | string
+};
+/** Multi-sig transaction actions: build unsigned transactions and broadcast with auto-finalization. */
+type MultiSigActions = {
+	transferStx: (params: MultiSigTransferStxParams) => Promise<StacksTransaction>
+	callContract: (params: MultiSigCallContractParams) => Promise<StacksTransaction>
+	deployContract: (params: MultiSigDeployContractParams) => Promise<StacksTransaction>
+	sendTransaction: (params: MultiSigSendTransactionParams) => Promise<SendTransactionResult>
+};
+/** Decorator that binds {@link MultiSigActions} to a multi-sig client. */
+declare function multisigActions(client: Client): MultiSigActions;
+/** Configuration for {@link createMultiSigClient} — requires signer public keys and threshold. */
+type MultiSigClientConfig = Omit<ClientConfig, "account"> & {
+	signers: string[]
+	requiredSignatures: number
+	hashMode?: MultiSigHashMode
+};
+/** A client pre-extended with {@link MultiSigActions} for m-of-n signing workflows. */
+type MultiSigClient = Client<MultiSigActions> & MultiSigActions;
+/**
+* Create a client for multi-sig transaction workflows.
+* Builds unsigned transactions that can be signed by each party then broadcast.
+*/
+declare function createMultiSigClient(config: MultiSigClientConfig): MultiSigClient;
+/**
+* Create an HTTP transport for Stacks node RPC calls.
+* Falls back to the chain's default RPC URL, then `localhost:3999`.
+*/
+declare function http(url?: string, config?: TransportConfig): TransportFactory;
+/** Create a transport backed by a user-provided request function. */
+declare function custom(params: {
+	request: RequestFn
+}): TransportFactory;
+/** Create a transport that tries each transport in order until one succeeds. */
+declare function fallback(transports: TransportFactory[]): TransportFactory;
+/** Configuration for the WebSocket transport, extending base {@link TransportConfig}. */
+type WebSocketTransportConfig = TransportConfig & {
+	/** WebSocket URL (resolved from chain if omitted) */
+	url?: string
+	/** Enable auto-reconnect (default: true) */
+	reconnect?: boolean
+	/** Max reconnect attempts (default: 10) */
+	reconnectMaxAttempts?: number
+	/** Base delay in ms for exponential backoff (default: 1000) */
+	reconnectBaseDelay?: number
+};
+/** Transport with WebSocket subscription capabilities and auto-reconnect. */
+type WebSocketTransport = Transport & {
+	type: "webSocket"
+	subscribe: (params: WsSubscribeParams, callback: (data: any) => void) => Promise<Subscription>
+	destroy: () => void
+};
+/**
+* Create a WebSocket transport for real-time Stacks event subscriptions.
+* HTTP requests use the resolved RPC URL; subscriptions use the WS endpoint.
+*/
+declare function webSocket(url?: string, config?: WebSocketTransportConfig): TransportFactory;
+/** Create a ProviderAccount by querying the wallet for addresses */
+declare function providerToAccount(provider: StacksProvider): Promise<ProviderAccount>;
+/** Stacks mainnet chain definition (Hiro API). */
+declare const mainnet: StacksChain;
+/** Stacks testnet chain definition (Hiro API). */
+declare const testnet: StacksChain;
+/** Local development chain definition (localhost:3999). */
+declare const devnet: StacksChain;
+/** Alias for devnet used in mock/test environments. */
+declare const mocknet: StacksChain;
+/** Identity helper for defining a custom {@link StacksChain} with full type inference. */
+declare function defineChain(chain: StacksChain): StacksChain;
+/**
+* Format microSTX to STX string (6 decimals).
+* @example formatStx(1000000n) → "1.0"
+*/
+declare function formatStx(microStx: bigint | number | string): string;
+/**
+* Parse STX string to microSTX bigint (6 decimals).
+* @example parseStx("1.5") → 1500000n
+*/
+declare function parseStx(stx: string | number): bigint;
+/** C32-encoded address version bytes for single-sig and multi-sig on each network. */
+declare const AddressVersion: {
+	readonly MainnetSingleSig: 22
+	readonly MainnetMultiSig: 20
+	readonly TestnetSingleSig: 26
+	readonly TestnetMultiSig: 21
+};
+type AddressVersion = (typeof AddressVersion)[keyof typeof AddressVersion];
+/** Mainnet burn address (all-zero hash160). */
+declare const ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
+/** Testnet burn address (all-zero hash160). */
+declare const TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
+/** Number of microSTX per 1 STX (10^6). */
+declare const MICROSTX_PER_STX = 1000000n;
+/** Alias for validateStacksAddress — matches future.md naming. */
+declare const isValidAddress: unknown;
+/**
+* Compare two Stacks addresses for equality (case-insensitive, version-aware).
+* Throws if either address is invalid.
+*/
+declare function isAddressEqual(a: string, b: string): boolean;
+/**
+* Build a contract address from deployer + contract name.
+* Validates both parts; returns `deployer.contractName`.
+*/
+declare function getContractAddress(deployer: string, contractName: string): string;
+export { webSocket, walletActions, testnet, publicActions, providerToAccount, parseStx, multisigActions, mocknet, mainnet, isValidAddress, isAddressEqual, http, getContractAddress, formatStx, fallback, devnet, defineChain, custom, createWalletClient, createPublicClient, createMultiSigClient, createClient, ZERO_ADDRESS, WebSocketTransportConfig, WebSocketTransport, WalletClientConfig, WalletClient, WalletActions, TransportFactory, TransportConfig, Transport, TESTNET_ZERO_ADDRESS, Subscription, StacksProvider, StacksChain, RequestOptions, RequestFn, PublicClientConfig, PublicClient, PublicActions, ProviderAccount, MultiSigClientConfig, MultiSigClient, MultiSigActions, MICROSTX_PER_STX, LocalAccount, CustomAccount, ClientConfig, Client, AddressVersion, Account };