@secondlayer/stacks 0.0.1

package/dist/src/actions/index.d.ts

@@ -0,0 +1,886 @@
+/** 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
+};
+/** 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;
+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
+};
+declare function getBlock(client: Client, params?: GetBlockParams): Promise<any>;
+declare function getBlockHeight(client: Client): Promise<number>;
+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
+};
+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 GetMapEntryParams = {
+	contract: string
+	mapName: string
+	key: ClarityValue
+};
+declare function getMapEntry<T extends ClarityValue = ClarityValue>(client: Client, params: GetMapEntryParams): Promise<T>;
+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
+};
+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
+};
+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 {
+	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;
+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>;
+/** 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
+};
+type SendTransactionResult = {
+	txid: string
+};
+/** 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";
+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[]
+};
+/** 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?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+/** 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?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+/** 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 structured message per SIP-018 */
+declare function signMessage2(client: Client, params: SignMessageParams): Promise<string>;
+type SponsorTransactionParams = {
+	transaction: StacksTransaction
+	fee?: IntegerType
+	nonce?: IntegerType
+};
+/** Sponsor a transaction: set sponsor spending condition, sign as sponsor */
+declare function sponsorTransaction(client: Client, params: SponsorTransactionParams): Promise<StacksTransaction>;
+declare function isProviderAccount(account: Account): account is ProviderAccount;
+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>;
+declare function toCamelCase(str: string): string;
+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>;
+}
+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 */
+type UnwrapResponse<T> = T extends {
+	ok: infer O
+} | {
+	err: any
+} ? O : T;
+type ReadMethodReturn<
+	C extends AbiContract,
+	N extends ExtractReadOnlyFunctions<C>
+> = UnwrapResponse<ExtractFunctionOutput<C, N>>;
+type ReadMethods<C extends AbiContract> = { [N in ExtractReadOnlyFunctions<C> as ToCamelCaseName<N>] : (args: ExtractFunctionArgs<C, N>) => Promise<ReadMethodReturn<C, N>> };
+type CallMethods<C extends AbiContract> = { [N in ExtractPublicFunctions<C> as ToCamelCaseName<N>] : (args: ExtractFunctionArgs<C, N>, options?: ContractCallOptions) => Promise<string> };
+type MapMethods<C extends AbiContract> = { [N in ExtractMapNames<C> as ToCamelCaseName<N>] : (key: ExtractMapKey<C, N>) => Promise<ExtractMapValue<C, N> | null> };
+type ToCamelCaseName<S extends string> = S extends string ? ReturnType<typeof toCamelCase> extends string ? S : S : S;
+type ContractCallOptions = {
+	fee?: IntegerType
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+type ContractInstance<C extends AbiContract> = {
+	read: ReadMethods<C>
+	call: CallMethods<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>;
+declare class ContractResponseError extends Error {
+	readonly errorValue: unknown;
+	name: string;
+	constructor(message: string, errorValue: unknown);
+}
+export { watchTransaction, watchNftEvent, watchMempool, watchBlocks, watchAddressBalance, watchAddress, transferStx, sponsorTransaction, simulateTransaction, simulateCall, signTransactionAction, signMessage2 as signMessage, sendTransaction, readContract, multicall, isProviderAccount, getNonce, getMapEntry, getContractAbi, getContract, getBlockHeight, getBlock, getBalance, getAccountInfo, estimateFee, deployContract, callContract, WatchTransactionParams, WatchNftEventParams, WatchMempoolParams, WatchBlocksParams, WatchAddressParams, WatchAddressBalanceParams, TransferStxParams, SponsorTransactionParams, SimulateTransferResult, SimulateTransactionResult, SimulateTransactionParams, SimulateDeployResult, SimulateContractCallResult, SimulateCallSuccess, SimulateCallResult, SimulateCallParams, SimulateCallFailure, SignTransactionParams, SignMessageParams, SendTransactionResult, SendTransactionParams, ReadContractParams, MulticallSuccessResult, MulticallResult, MulticallParams, MulticallFailureResult, MulticallCall, GetNonceParams, GetMapEntryParams, GetContractParams, GetContractAbiParams, GetBlockParams, GetBalanceParams, GetAccountInfoParams, FeeEstimation, EstimateFeeParams, DeployContractParams, ContractResponseError, ContractInstance, ContractCallOptions, CallContractParams, AccountInfo };