@secondlayer/stacks 2.21.1 → 3.0.0

package/dist/src/index.d.ts

@@ -1,3 +1,385 @@
+declare const DECODED_EVENT_TYPES: readonly ["stx_transfer", "stx_mint", "stx_burn", "stx_lock", "ft_transfer", "ft_mint", "ft_burn", "nft_transfer", "nft_mint", "nft_burn", "print"];
+type DecodedEventType = (typeof DECODED_EVENT_TYPES)[number];
+/** Every chain-event filter member across all four surfaces: the 10 decoded
+*  token/STX types, the three contract-shaped types (spelled as subgraphs and
+*  triggers spell them — Index/Streams project `print_event` → `print`), and
+*  the five sBTC lifecycle types (Subscriptions-only). */
+declare const CHAIN_EVENT_FILTER_TYPES: readonly ["stx_transfer", "stx_mint", "stx_burn", "stx_lock", "ft_transfer", "ft_mint", "ft_burn", "nft_transfer", "nft_mint", "nft_burn", "contract_call", "contract_deploy", "print_event", "sbtc_deposit", "sbtc_withdrawal_create", "sbtc_withdrawal_accept", "sbtc_withdrawal_reject", "sbtc_withdrawal_swept_confirmed"];
+type ChainEventFilterType = (typeof CHAIN_EVENT_FILTER_TYPES)[number];
+/** 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;
+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 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>;
+}
+/** Scalar print field types (structural mirror of the subgraphs `ColumnType`). */
+type PrintScalarType = "uint" | "int" | "text" | "principal" | "boolean" | "timestamp" | "jsonb";
+/**
+* One declared print field — structural mirror of `PrintField` in
+* `@secondlayer/subgraphs`. Composite forms exist because real print payloads
+* nest: a vocabulary that could only say `"jsonb"` is what let a flat-field
+* declaration type-check while every event decoded to null.
+*
+* Kept literal through `toSubgraphSource()` so handler narrowing survives.
+*/
+type PrintFieldType = PrintScalarType | {
+	type: PrintFieldType
+	optional: true
+} | {
+	tuple: Record<string, PrintFieldType>
+} | {
+	list: PrintFieldType
+};
+interface StxTransferSpec {
+	type: "stx_transfer";
+	sender?: string;
+	recipient?: string;
+	minAmount?: bigint;
+	maxAmount?: bigint;
+}
+interface StxMintSpec {
+	type: "stx_mint";
+	recipient?: string;
+	minAmount?: bigint;
+}
+interface StxBurnSpec {
+	type: "stx_burn";
+	sender?: string;
+	minAmount?: bigint;
+}
+interface StxLockSpec {
+	type: "stx_lock";
+	lockedAddress?: string;
+	minAmount?: bigint;
+}
+/** Scope to contracts conforming to a trait/standard (e.g. "sip-010") instead
+*  of a fixed contract. Index + Subgraphs + Subscriptions; Streams has no
+*  trait resolution — `toStreamsParams()` throws if set. */
+type TraitScope = {
+	trait?: string
+};
+interface FtTransferSpec extends TraitScope {
+	type: "ft_transfer";
+	assetIdentifier?: string;
+	sender?: string;
+	recipient?: string;
+	minAmount?: bigint;
+}
+interface FtMintSpec extends TraitScope {
+	type: "ft_mint";
+	assetIdentifier?: string;
+	recipient?: string;
+	minAmount?: bigint;
+}
+interface FtBurnSpec extends TraitScope {
+	type: "ft_burn";
+	assetIdentifier?: string;
+	sender?: string;
+	minAmount?: bigint;
+}
+interface NftTransferSpec extends TraitScope {
+	type: "nft_transfer";
+	assetIdentifier?: string;
+	sender?: string;
+	recipient?: string;
+}
+interface NftMintSpec extends TraitScope {
+	type: "nft_mint";
+	assetIdentifier?: string;
+	recipient?: string;
+}
+interface NftBurnSpec extends TraitScope {
+	type: "nft_burn";
+	assetIdentifier?: string;
+	sender?: string;
+}
+interface ContractCallSpec extends TraitScope {
+	type: "contract_call";
+	/** One contract id, or a set of them (max 20). Mirrors the subgraphs
+	*  filter — a router plus its pools is one source, not N. */
+	contractId?: string | readonly string[];
+	functionName?: string;
+	caller?: string;
+	/** Contract ABI (`as const`) — preserved literally so `toSubgraphSource()`
+	*  keeps typing `event.input` in `defineSubgraph`. */
+	abi?: AbiContract;
+}
+interface ContractDeploySpec {
+	type: "contract_deploy";
+	deployer?: string;
+	contractName?: string;
+}
+interface PrintEventSpec extends TraitScope {
+	type: "print_event";
+	/** One contract id, or a set of them (max 20). */
+	contractId?: string | readonly string[];
+	topic?: string;
+	/** Per-topic field schema — preserved literally so `toSubgraphSource()`
+	*  keeps the discriminated-union narrowing of `event.data`. */
+	prints?: Record<string, Record<string, PrintFieldType>>;
+}
+interface SbtcDepositSpec {
+	type: "sbtc_deposit";
+	sender?: string;
+	minAmount?: bigint;
+	maxAmount?: bigint;
+	bitcoinTxid?: string;
+	requestId?: number;
+}
+interface SbtcWithdrawalCreateSpec {
+	type: "sbtc_withdrawal_create";
+	sender?: string;
+	minAmount?: bigint;
+	maxAmount?: bigint;
+	requestId?: number;
+}
+interface SbtcWithdrawalAcceptSpec {
+	type: "sbtc_withdrawal_accept";
+	requestId?: number;
+	sweepTxid?: string;
+}
+interface SbtcWithdrawalRejectSpec {
+	type: "sbtc_withdrawal_reject";
+	requestId?: number;
+}
+interface SbtcWithdrawalSweptConfirmedSpec {
+	type: "sbtc_withdrawal_swept_confirmed";
+	requestId?: number;
+	sweepTxid?: string;
+}
+type ChainEventFilterSpec = StxTransferSpec | StxMintSpec | StxBurnSpec | StxLockSpec | FtTransferSpec | FtMintSpec | FtBurnSpec | NftTransferSpec | NftMintSpec | NftBurnSpec | ContractCallSpec | ContractDeploySpec | PrintEventSpec | SbtcDepositSpec | SbtcWithdrawalCreateSpec | SbtcWithdrawalAcceptSpec | SbtcWithdrawalRejectSpec | SbtcWithdrawalSweptConfirmedSpec;
+type SpecFor<T extends ChainEventFilterType> = Extract<ChainEventFilterSpec, {
+	type: T
+}>;
+/** Wire shape of a chain trigger (Subscriptions), derived per member from
+*  the spec: same fields, with `bigint` amounts stringified (uint128 exceeds
+*  JS safe integers) and the type-only `abi`/`prints` decorations dropped.
+*  Structurally assignable to the SDK's `ChainTrigger` union. */
+type ChainTriggerOf<S> = { [K in keyof Omit<S, "abi" | "prints">] : Exclude<S[K], bigint | readonly string[]> | (bigint extends S[K] ? string : never) };
+/** Params fragment for `index.events.*` (spread into list/walk/consume). */
+type IndexEventsParamsShape = {
+	eventType: DecodedEventType
+	contractId?: string
+	assetIdentifier?: string
+	sender?: string
+	recipient?: string
+	trait?: string
+};
+/** Params fragment for `index.contractCalls.*`. */
+type ContractCallsParamsShape = {
+	contractId?: string
+	functionName?: string
+	sender?: string
+	trait?: string
+};
+/** Params fragment for `streams.events.*`. */
+type StreamsParamsShape = {
+	types: readonly DecodedEventType[]
+	contractId?: string
+	sender?: string
+	recipient?: string
+	assetIdentifier?: string
+};
+type DecodedMember = "stx_transfer" | "stx_mint" | "stx_burn" | "stx_lock" | "ft_transfer" | "ft_mint" | "ft_burn" | "nft_transfer" | "nft_mint" | "nft_burn" | "print_event";
+type ProjectionsFor<
+	T extends ChainEventFilterType,
+	S
+> = {
+	/** Wire trigger for `subscriptions.create({ triggers: [...] })`. BigInt
+	*  amounts become strings here — the one sanctioned boundary. */
+	toChainTrigger(): ChainTriggerOf<S>
+} & (T extends DecodedMember ? {
+	/** Params for `index.events.list/walk/consume` (merge your own
+	*  `limit`/`fromHeight`/`txContext` etc. on top). */
+	toIndexParams<Extra extends Record<string, unknown>>(extra?: Extra): IndexEventsParamsShape & Extra
+	/** Params for `streams.events.list/consume/stream`. Throws if the
+	*  filter uses `trait` (Streams has no trait resolution) or a
+	*  min/max amount (Streams filters have no amount predicates). */
+	toStreamsParams<Extra extends Record<string, unknown>>(extra?: Extra): StreamsParamsShape & Extra
+} : {}) & (T extends "contract_call" ? {
+	/** Params for `index.contractCalls.list/walk/consume`. */
+	toContractCallsParams<Extra extends Record<string, unknown>>(extra?: Extra): ContractCallsParamsShape & Extra
+} : {}) & (T extends Exclude<ChainEventFilterType, `sbtc_${string}`> ? {
+	/** The `sources` entry for `defineSubgraph` — literal `prints`/`abi`
+	*  types are preserved, so handler narrowing survives. */
+	toSubgraphSource(): S
+} : {});
+/**
+* A canonical chain-event filter: the spec fields plus the projections its
+* member supports. Write the filter once; project it to a query
+* (`toIndexParams`), a stream (`toStreamsParams`), a webhook trigger
+* (`toChainTrigger`), or a subgraph source (`toSubgraphSource`).
+*/
+type ChainEventFilter<
+	T extends ChainEventFilterType = ChainEventFilterType,
+	S extends {
+		type: T
+	} = SpecFor<T>
+> = S & ProjectionsFor<T, S>;
+type Fields<T extends ChainEventFilterType> = Omit<SpecFor<T>, "type">;
+/** The `on.*` namespace, annotated explicitly — bunup's dts emitter needs an
+*  annotation on exported values (an inferred object of generic factories
+*  collapses to `{}` in the emitted declarations). */
+interface OnNamespace {
+	stxTransfer(fields?: Fields<"stx_transfer">): ChainEventFilter<"stx_transfer">;
+	stxMint(fields?: Fields<"stx_mint">): ChainEventFilter<"stx_mint">;
+	stxBurn(fields?: Fields<"stx_burn">): ChainEventFilter<"stx_burn">;
+	stxLock(fields?: Fields<"stx_lock">): ChainEventFilter<"stx_lock">;
+	ftTransfer(fields?: Fields<"ft_transfer">): ChainEventFilter<"ft_transfer">;
+	ftMint(fields?: Fields<"ft_mint">): ChainEventFilter<"ft_mint">;
+	ftBurn(fields?: Fields<"ft_burn">): ChainEventFilter<"ft_burn">;
+	nftTransfer(fields?: Fields<"nft_transfer">): ChainEventFilter<"nft_transfer">;
+	nftMint(fields?: Fields<"nft_mint">): ChainEventFilter<"nft_mint">;
+	nftBurn(fields?: Fields<"nft_burn">): ChainEventFilter<"nft_burn">;
+	/** `abi` literals are preserved (`const A`) so `toSubgraphSource()` keeps
+	*  typing `event.input` inside `defineSubgraph`. */
+	contractCall<const A extends AbiContract | undefined = undefined>(fields?: Omit<SpecFor<"contract_call">, "type" | "abi"> & {
+		abi?: A
+	}): ChainEventFilter<"contract_call", {
+		type: "contract_call"
+	} & Omit<SpecFor<"contract_call">, "type" | "abi"> & {
+		abi?: A
+	}>;
+	contractDeploy(fields?: Fields<"contract_deploy">): ChainEventFilter<"contract_deploy">;
+	/** Canonical member is `print_event` (as Subgraphs and Subscriptions spell
+	*  it); `toIndexParams`/`toStreamsParams` project to `print`. `prints`
+	*  literals are preserved (`const P`) for per-topic `event.data` narrowing. */
+	print<const P extends Record<string, Record<string, PrintFieldType>> | undefined = undefined>(fields?: Omit<SpecFor<"print_event">, "type" | "prints"> & {
+		prints?: P
+	}): ChainEventFilter<"print_event", {
+		type: "print_event"
+	} & Omit<SpecFor<"print_event">, "type" | "prints"> & {
+		prints?: P
+	}>;
+	sbtcDeposit(fields?: Fields<"sbtc_deposit">): ChainEventFilter<"sbtc_deposit">;
+	sbtcWithdrawalCreate(fields?: Fields<"sbtc_withdrawal_create">): ChainEventFilter<"sbtc_withdrawal_create">;
+	sbtcWithdrawalAccept(fields?: Fields<"sbtc_withdrawal_accept">): ChainEventFilter<"sbtc_withdrawal_accept">;
+	sbtcWithdrawalReject(fields?: Fields<"sbtc_withdrawal_reject">): ChainEventFilter<"sbtc_withdrawal_reject">;
+	sbtcWithdrawalSweptConfirmed(fields?: Fields<"sbtc_withdrawal_swept_confirmed">): ChainEventFilter<"sbtc_withdrawal_swept_confirmed">;
+}
+/**
+* `on.*` — one filter vocabulary for every surface.
+*
+* ```ts
+* import { on } from "@secondlayer/stacks/filters";
+*
+* const usdc = on.ftTransfer({ assetIdentifier: USDC, minAmount: 1_000_000n });
+*
+* sl.index.events.list(usdc.toIndexParams({ limit: 100 }));   // pull
+* sl.streams.events.consume({ ...usdc.toStreamsParams(), onBatch });
+* sl.subscriptions.create({ name, url, triggers: [usdc.toChainTrigger()] });
+* defineSubgraph({ sources: { usdc: usdc.toSubgraphSource() }, schema, handlers });
+* ```
+*
+* A surface a member can't reach is a missing method (compile error), and a
+* field a surface can't express throws at projection time — never a silent
+* zero-row or over-wide match.
+*/
+declare const on: OnNamespace;
 /** Account derived from a local private key (mnemonic or raw key). */
 type LocalAccount = {
 	type: "local"
@@ -736,6 +1118,12 @@ type ReadContractParams = {
 	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 class BaseError extends Error {
 	name: string;
@@ -1335,155 +1723,6 @@ type WebSocketTransport = Transport & {
 * HTTP requests use the resolved RPC URL; subscriptions use the WS endpoint.
 */
 declare function webSocket(url?: string, config?: WebSocketTransportConfig): TransportFactory;
-declare namespace exports_on {
-	export { transferTo, sip010Transfer, sip009Transfer, sbtcWithdrawal, sbtcDeposit, poxStack, makeSpec, bnsName, SubscriptionFilterSpec, PoxFunction, FilterPrimitive, FilterOperator, FilterClause, Filter, FactoryTarget, BnsAction };
-}
-/**
-* Filter specs for `@secondlayer/sdk` subscriptions.
-*
-* Each `on.*` factory in this directory binds typed filter clauses to a
-* known table shape and returns a `SubscriptionFilterSpec`. Spread it into
-* a full subscription input alongside `name`, `url`, `format`, etc:
-*
-*   const spec = on.transferTo(
-*     { subgraph: "my-watcher", table: "transfers" },
-*     "SP1ABC...",
-*   );
-*   await sdk.subscriptions.create({
-*     ...spec,
-*     name: "watch-incoming",
-*     url: "https://my-app.com/webhook",
-*   });
-*
-* The user supplies which subgraph + table to bind against — these factories
-* don't assume curated read endpoints are subscribable. To watch FT transfers
-* to an address, build a subgraph with a `transfers` table (see
-* `sl subgraphs create --template sip-010-balances`) and bind here.
-*/
-/**
-* What every factory takes as its first arg: which user-owned subgraph table
-* to filter against.
-*/
-type FactoryTarget = {
-	subgraph: string
-	table: string
-};
-/**
-* A primitive value that can appear in a filter clause.
-* Mirrors `SubscriptionFilterPrimitive` in
-* `@secondlayer/shared/schemas/subscriptions` — duplicated here to keep
-* `@secondlayer/stacks` from importing the api/server schema package.
-*/
-type FilterPrimitive = string | number | boolean;
-/** Operator forms a filter clause can take. */
-type FilterOperator = {
-	eq: FilterPrimitive
-} | {
-	neq: FilterPrimitive
-} | {
-	gt: string | number
-} | {
-	gte: string | number
-} | {
-	lt: string | number
-} | {
-	lte: string | number
-} | {
-	in: FilterPrimitive[]
-};
-/** A single column's filter: bare value (eq) or operator object. */
-type FilterClause = FilterPrimitive | FilterOperator;
-/** Map of column → filter clause. Empty `{}` matches every row. */
-type Filter = Record<string, FilterClause>;
-/**
-* Output of every `on.*` factory. Use directly as a partial input to
-* `sdk.subscriptions.create` — the SDK's existing `CreateSubscriptionRequest`
-* already accepts these three fields.
-*/
-type SubscriptionFilterSpec = {
-	subgraphName: string
-	tableName: string
-	filter: Filter
-};
-/** Thin helper to build a spec without restating the field-name mapping. */
-declare function makeSpec(target: FactoryTarget, filter: Filter): SubscriptionFilterSpec;
-type BnsAction = "new-name" | "transfer-name" | "renew-name" | "burn-name" | "new-airdrop";
-/**
-* Match BNS-V2 name lifecycle events.
-*
-* Bind against a subgraph table that mirrors the `bns_name_events` shape
-* (topic, namespace, name, owner, ...). Easiest path: scaffold via
-* `sl subgraphs create --template bns-names`.
-*
-* @param action restrict to one topic; omit to fire on every name event
-*/
-declare function bnsName(target: FactoryTarget, action?: BnsAction, opts?: {
-	namespace?: string
-	owner?: string
-}): SubscriptionFilterSpec;
-type PoxFunction = "stack-stx" | "stack-extend" | "stack-increase" | "delegate-stx" | "revoke-delegate-stx" | "delegate-stack-stx" | "delegate-stack-extend" | "delegate-stack-increase" | "stack-aggregation-commit" | "stack-aggregation-commit-indexed" | "stack-aggregation-increase" | "set-signer-key-authorization";
-/**
-* Match PoX-4 stacking calls. Bind against a subgraph table mirroring
-* `pox4_calls` (function_name, stacker, caller, ...). Scaffold via
-* `sl subgraphs create --template pox-stacking`.
-*
-* @param fn restrict to one PoX-4 function; omit to fire on every call
-*/
-declare function poxStack(target: FactoryTarget, fn?: PoxFunction, opts?: {
-	stacker?: string
-	signerKey?: string
-}): SubscriptionFilterSpec;
-/**
-* Match sBTC deposit completion events. Bind against a subgraph table
-* mirroring `sbtc_events` (topic, amount, sender, bitcoin_txid, ...).
-* Scaffold via `sl subgraphs create --template sbtc-flows`.
-*/
-declare function sbtcDeposit(target: FactoryTarget, opts?: {
-	sender?: string
-	bitcoinTxid?: string
-}): SubscriptionFilterSpec;
-/**
-* Match sBTC withdrawal lifecycle events. Phase defaults to all three
-* (`create` / `accept` / `reject`); pass an explicit `phase` to narrow.
-*/
-declare function sbtcWithdrawal(target: FactoryTarget, opts?: {
-	phase?: "create" | "accept" | "reject"
-	sender?: string
-	requestId?: number
-}): SubscriptionFilterSpec;
-/**
-* Match transfer events into a recipient address.
-*
-* Works against any subgraph table that has a `recipient` column (and
-* optionally `asset_identifier`). Templates that scaffold this shape:
-* `sip-010-balances`, `sbtc-flows`.
-*
-* @param target the user's subgraph + table to bind against
-* @param recipient stx principal that should receive the transfer
-* @param opts.asset optional asset identifier (e.g. `"SP1...usdc::usdc-token"`)
-*   to filter to a specific FT/NFT contract
-*/
-declare function transferTo(target: FactoryTarget, recipient: string, opts?: {
-	asset?: string
-}): SubscriptionFilterSpec;
-/**
-* SIP-010 (fungible token) transfer sugar — alias for `transferTo` that
-* makes the asset filter intent explicit at the call site. Same backing
-* filter; the `asset` param is optional (omit to match every SIP-010
-* transfer in the bound table).
-*/
-declare function sip010Transfer(target: FactoryTarget, asset?: string, opts?: {
-	recipient?: string
-}): SubscriptionFilterSpec;
-/**
-* SIP-009 (non-fungible token) transfer sugar — same pattern as
-* `sip010Transfer`. Bind against an NFT-shaped table (see template
-* `nft-transfers` if/when published).
-*/
-declare function sip009Transfer(target: FactoryTarget, asset?: string, opts?: {
-	recipient?: string
-	tokenId?: string | number
-}): SubscriptionFilterSpec;
 /** Create a ProviderAccount by querying the wallet for addresses */
 declare function providerToAccount(provider: StacksProvider): Promise<ProviderAccount>;
 /** Stacks mainnet chain definition (Hiro API). */
@@ -1506,20 +1745,6 @@ declare function formatStx(microStx: bigint | number | string): string;
 * @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: (address: string) => boolean;
 /**
@@ -1610,4 +1835,4 @@ declare class MalformedResponseError extends BaseError {
 declare class WebSocketError extends BaseError {
 	name: string;
 }
-export { webSocket, walletActions, waitForTransactionReceipt2 as waitForTransactionReceipt, testnet, startNonceReconciler, resolveNonce, redisStore, reconcileNonce, publicActions, providerToAccount, postgresStore, parseStx, exports_on as on, nextFreeNonce, multisigActions, mocknet, mempoolAwareSource, memoryStore, mainnet, jsonRpcSource, isValidAddress, isNonceConflictError, isAddressEqual, indexTxSource, indexSource, http, hiroNonceSource, getTransaction2 as getTransaction, getContractAddress, formatStx, fallback, extendedApiSource, devnet, defineChain, custom, createWalletClient, createPublicClient, createNonceManager, createMultiSigClient, createClient, broadcastWithNonceReset, ZERO_ADDRESS, WebSocketTransportConfig, WebSocketTransport, WebSocketError, WalletClientConfig, WalletClient, WalletActions, WaitForTransactionTimeoutError, WaitForTransactionReceiptParams, TxRejectionReason, TransportFactory, TransportConfig, Transport, TransactionStatusSource, TransactionStatus, TransactionSnapshot, TransactionReceipt, TransactionError, TransactionDroppedError, TransactionAbortedError, TESTNET_ZERO_ADDRESS, SubscriptionFilterSpec, Subscription, StartNonceReconcilerParams, StacksProvider, StacksChain, SqlLike, SimulationError, SigningError, SerializationError, RequestOptions, RequestFn, RedisStoreParams, RedisLike, ReconcileNonceResult, ReconcileNonceParams, ReadOnlyCallError, PublicClientConfig, PublicClient, PublicActions, ProviderAccount, PoxFunction, PostgresStoreParams, NonceStore, NonceManagerSource, NonceManager, MultiSigClientConfig, MultiSigClient, MultiSigActions, MempoolAwareSourceParams, MalformedResponseError, MICROSTX_PER_STX, LocalAccount, IndexTxSourceParams, IndexSourceParams, HttpRequestError, HiroNonceSourceParams, GetTransactionParams, FilterPrimitive, FilterOperator, FilterClause, Filter, FactoryTarget, CustomAccount, CreateNonceManagerParams, ContractCallError, ClientConfig, Client, BroadcastError, BnsAction, BaseError, AddressVersion, Account };
+export { webSocket, walletActions, waitForTransactionReceipt2 as waitForTransactionReceipt, testnet, startNonceReconciler, resolveNonce, redisStore, reconcileNonce, publicActions, providerToAccount, postgresStore, parseStx, on, nextFreeNonce, multisigActions, mocknet, mempoolAwareSource, memoryStore, mainnet, jsonRpcSource, isValidAddress, isNonceConflictError, isAddressEqual, indexTxSource, indexSource, http, hiroNonceSource, getTransaction2 as getTransaction, getContractAddress, formatStx, fallback, extendedApiSource, devnet, defineChain, custom, createWalletClient, createPublicClient, createNonceManager, createMultiSigClient, createClient, broadcastWithNonceReset, ZERO_ADDRESS, WebSocketTransportConfig, WebSocketTransport, WebSocketError, WalletClientConfig, WalletClient, WalletActions, WaitForTransactionTimeoutError, WaitForTransactionReceiptParams, TxRejectionReason, TransportFactory, TransportConfig, Transport, TransactionStatusSource, TransactionStatus, TransactionSnapshot, TransactionReceipt, TransactionError, TransactionDroppedError, TransactionAbortedError, TESTNET_ZERO_ADDRESS, Subscription, StartNonceReconcilerParams, StacksProvider, StacksChain, SqlLike, SimulationError, SigningError, SerializationError, RequestOptions, RequestFn, RedisStoreParams, RedisLike, ReconcileNonceResult, ReconcileNonceParams, ReadOnlyCallError, PublicClientConfig, PublicClient, PublicActions, ProviderAccount, PostgresStoreParams, NonceStore, NonceManagerSource, NonceManager, MultiSigClientConfig, MultiSigClient, MultiSigActions, MempoolAwareSourceParams, MalformedResponseError, MICROSTX_PER_STX, LocalAccount, IndexTxSourceParams, IndexSourceParams, HttpRequestError, HiroNonceSourceParams, GetTransactionParams, CustomAccount, CreateNonceManagerParams, ContractCallError, ClientConfig, Client, ChainTriggerOf, ChainEventFilterType, ChainEventFilterSpec, ChainEventFilter, BroadcastError, BaseError, AddressVersion, Account };