@secondlayer/stacks 2.14.0 → 2.15.0

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

@@ -0,0 +1,646 @@
+/** 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
+};
+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;
+/** 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>
+	/** 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>
+};
+/** 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
+};
+/** 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;
+/**
+* Chain-reported PoX-5 activation facts, read from the node's `/v2/pox`
+* `contract_versions[]`. Present the moment nodes run stacks-core >= 4.0.0 —
+* no hardcoded heights, works on any network.
+*/
+type Pox5Activation = {
+	/** Fully-qualified `pox-5` contract id (boot address differs per network). */
+	contractId: string
+	/** Bitcoin block height at which Epoch 4.0 (and pox-5) activates. */
+	activationBurnchainBlockHeight: number
+	/** First reward cycle in which pox-5 governs PoX. */
+	firstRewardCycleId: number
+};
+/**
+* Read pox-5's activation entry from the node. Returns `undefined` when the
+* node doesn't know about pox-5 yet (pre-4.0.0 node software).
+*/
+declare function getPox5Activation(client: Client): Promise<Pox5Activation | undefined>;
+/**
+* Whether pox-5 is live on the node's chain: the node software knows the
+* contract AND the burnchain has reached its activation height. One request.
+*/
+declare function isPox5Active(client: Client): Promise<boolean>;
+/** Throw a descriptive error unless pox-5 is active on the client's chain. */
+declare function assertPox5Active(client: Client): Promise<void>;
+/**
+* PoX-5 (SIP-045 Bitcoin Staking) constants, pinned against the final
+* contract shipped in stacks-core 4.0.0 (`stackslib/.../boot/pox-5.clar`).
+*/
+/** Boot contract name; deployer is the chain's boot address. */
+declare const POX5_CONTRACT_NAME = "pox-5";
+/**
+* Epoch 4.0 hard-fork activation height on mainnet — Bitcoin block 960,230
+* (expected ~2026-07-29 03:00 UTC, per the stacks-core 4.0.0 release).
+* Prefer the runtime gate in `activation.ts` (`getPox5Activation`), which
+* reads the node's `/v2/pox` and needs no hardcoded height.
+*/
+declare const POX5_ACTIVATION_BURN_HEIGHT_MAINNET = 960230;
+/** Length of a paired-BTC bond, in reward cycles (`BOND_LENGTH_CYCLES`). */
+declare const BOND_LENGTH_CYCLES = 12;
+/** Gap between consecutive bond starts, in reward cycles (`BOND_GAP_CYCLES`). */
+declare const BOND_GAP_CYCLES = 2;
+/** Hard cap for STX-only stake duration, in cycles (`MAX_NUM_CYCLES`). */
+declare const MAX_NUM_CYCLES = 96;
+/** SIP-018 domain for signer-key grants (`POX_5_SIGNER_DOMAIN`). */
+declare const POX5_SIGNER_DOMAIN: {
+	readonly name: "pox-5-signer"
+	readonly version: "1.0.0"
+};
+/**
+* `serialize-c-script-num` rejects values at or above 2^39 — the ceiling of a
+* 5-byte minimally-encoded ScriptNum (`ERR_INVALID_UNLOCK_HEIGHT`).
+*/
+declare const C_SCRIPT_NUM_MAX = 549755813888n;
+/**
+* Bitcoin treats CLTV values >= 500,000,000 as Unix timestamps (BIP-65); the
+* contract rejects unlock heights at or above this so a lockup can never
+* commit a height Bitcoin would reinterpret.
+*/
+declare const BITCOIN_LOCKTIME_THRESHOLD = 500000000n;
+/**
+* Pure cycle/height math, mirroring the pox-5 helper read-onlys byte-for-byte
+* (`burn-height-to-reward-cycle`, `reward-cycle-to-burn-height`,
+* `bond-period-to-reward-cycle`, `burn-height-to-distribution-index`).
+*
+* All functions anchor on chain-reported parameters — pass values from
+* `/v2/pox` (`first_burnchain_block_height`, `reward_cycle_length`,
+* `prepare_cycle_length`) and `getPox5Activation` (`firstRewardCycleId` =
+* the contract's `first-bond-period-cycle`). Nothing is hardcoded, so the
+* math is correct on mainnet, testnet, and devnet alike.
+*/
+type PoxCycleParams = {
+	/** `/v2/pox` `first_burnchain_block_height`. */
+	firstBurnchainBlockHeight: number
+	/** `/v2/pox` `reward_cycle_length` (mainnet 2100). */
+	rewardCycleLength: number
+};
+type BondCycleParams = PoxCycleParams & {
+	/** pox-5's first bond-period cycle (`getPox5Activation().firstRewardCycleId`). */
+	firstBondPeriodCycle: number
+};
+/** Reward cycle containing `burnHeight`. Mirrors `burn-height-to-reward-cycle`. */
+declare function burnHeightToRewardCycle(burnHeight: number, params: PoxCycleParams): number;
+/** Burn height at the start of `cycle`. Mirrors `reward-cycle-to-burn-height`. */
+declare function rewardCycleToBurnHeight(cycle: number, params: PoxCycleParams): number;
+/** Reward cycle at which bond period `bondIndex` starts. Mirrors `bond-period-to-reward-cycle`. */
+declare function bondPeriodToRewardCycle(bondIndex: number, params: BondCycleParams): number;
+/** Burn height at which bond period `bondIndex` starts. Mirrors `bond-period-to-burn-height`. */
+declare function bondPeriodToBurnHeight(bondIndex: number, params: BondCycleParams): number;
+/** First reward cycle in which bond `bondIndex`'s STX unlock (start + 12 cycles). */
+declare function bondUnlockCycle(bondIndex: number, params: BondCycleParams): number;
+/**
+* Distribution-cycle index at `burnHeight` — distribution cycles are half a
+* reward cycle long. Mirrors `burn-height-to-distribution-index`.
+*/
+declare function burnHeightToDistributionIndex(burnHeight: number, params: PoxCycleParams): number;
+/**
+* Whether `burnHeight` falls in a cycle's prepare phase (the final
+* `prepareCycleLength` blocks). pox-5 rejects `unstake-sbtc` and
+* `announce-l1-early-exit` during a prepare phase.
+*/
+declare function isInPreparePhase(burnHeight: number, params: PoxCycleParams & {
+	prepareCycleLength: number
+}): boolean;
+type BondPhase = "too-early" | "open" | "locked" | "unlocked";
+/**
+* Coarse lifecycle phase of bond `bondIndex` at `burnHeight`: `too-early`
+* (before the bond's start is registerable), `open`/`locked` while active,
+* `unlocked` after 12 cycles.
+*/
+declare function bondPhaseAtHeight(bondIndex: number, burnHeight: number, params: BondCycleParams): BondPhase;
+type BitcoinNetwork = "mainnet" | "testnet" | "regtest";
+/**
+* Byte-for-byte TypeScript mirrors of pox-5's Bitcoin-script helpers
+* (`serialize-c-script-num`, `push-c-script-num`, `push-script-bytes`,
+* `construct-lockup-script`, `construct-lockup-output-script`), pinned
+* against the final contract in stacks-core 4.0.0. The contract validates a
+* staker's L1 lockup output against exactly these bytes, so any divergence
+* means a rejected registration — the read-onlys on-chain double as a
+* cross-check oracle for these functions.
+*/
+/**
+* Minimal little-endian ScriptNum encoding of a non-negative integer
+* (`0` → empty; a `0x00` sign byte is appended when the top byte's high bit
+* is set). Mirrors `serialize-c-script-num`, including its 2^39 ceiling.
+*/
+declare function serializeCScriptNum(n: number | bigint): Uint8Array;
+/**
+* Push arbitrary bytes onto a Bitcoin script: direct length byte under 76,
+* `OP_PUSHDATA1` under 256, `OP_PUSHDATA2` otherwise. Mirrors
+* `push-script-bytes`.
+*/
+declare function pushScriptBytes(bytes: Uint8Array): Uint8Array;
+/**
+* Push a numeric script value: `OP_0` for zero, the single-byte ops
+* `OP_1`..`OP_16` for 1–16, else a minimal ScriptNum push. Mirrors
+* `push-c-script-num`.
+*/
+declare function pushCScriptNum(n: number | bigint): Uint8Array;
+/** `to-consensus-buff?` of a principal — the staker identity the script commits to. */
+declare function stakerConsensusBuff(stxAddress: string): Uint8Array;
+/**
+* The 32-byte witness item the early-exit branch must reveal:
+* `sha256(to-consensus-buff? staker)`. The script stores `sha256` of THIS,
+* so revealing it proves which staker the exit is for.
+*/
+declare function stakerPreimage(stxAddress: string): Uint8Array;
+type BuildLockupScriptOptions = {
+	/** Staker principal (standard or contract address). */
+	stxAddress: string
+	/** Burn height at which the CLTV branch becomes spendable. */
+	unlockBurnHeight: number | bigint
+	/** Staker-signature subscript, run last in BOTH branches. */
+	stakerUnlockBytes: Uint8Array | string
+	/** Per-bond early-unlock subscript (from `protocol-bonds.early-unlock-bytes`). */
+	earlyUnlockBytes: Uint8Array | string
+};
+/**
+* The L1 lockup witness script. Mirrors `construct-lockup-script`:
+*
+* ```
+* OP_IF
+*   <unlockBurnHeight> OP_CHECKLOCKTIMEVERIFY
+* OP_ELSE
+*   OP_SIZE <32> OP_EQUALVERIFY OP_SHA256
+*   <sha256(sha256(consensus-buff(staker)))> OP_EQUALVERIFY
+*   <earlyUnlockBytes>
+* OP_ENDIF
+* OP_VERIFY
+* <stakerUnlockBytes>
+* ```
+*/
+declare function buildLockupScript(opts: BuildLockupScriptOptions): Uint8Array;
+/**
+* P2WSH `scriptPubKey` for a lockup script: `0x0020 || sha256(script)`.
+* Mirrors `construct-lockup-output-script`.
+*/
+declare function buildLockupOutputScript(opts: BuildLockupScriptOptions): Uint8Array;
+/** The bech32 P2WSH address a staker sends their L1 BTC lockup to. */
+declare function buildLockupAddress(opts: BuildLockupScriptOptions, network?: BitcoinNetwork): string;
+/**
+* The default staker subscript: `<pubkey> OP_CHECKSIG` — spendable by one
+* key. Any script tail is valid as far as the contract is concerned; this is
+* the common case.
+*/
+declare function buildDefaultStakerUnlockBytes(publicKey: Uint8Array | string): Uint8Array;
+/**
+* PoX-5 signer-key grants: SIP-018 structured-data signatures authorizing a
+* signer-manager contract to use a signer key. Mirrors
+* `pox-5.get-signer-grant-message-hash` — domain `pox-5-signer/1.0.0`,
+* message `{ topic: "grant-authorization", signer-manager, auth-id }`.
+*/
+type SignerGrantOptions = {
+	/** The signer-manager contract principal being authorized. */
+	signerManager: string
+	/** Replay-protection id, chosen by the signer. */
+	authId: bigint | number
+	/** Stacks chain id (`mainnet.id` / `testnet.id`). */
+	chainId: number
+};
+/**
+* The 32-byte hash a signer signs to grant their key — byte-identical to the
+* contract's `get-signer-grant-message-hash` read-only (which doubles as an
+* on-chain cross-check).
+*/
+declare function computeSignerGrantHash(opts: SignerGrantOptions): Uint8Array;
+/**
+* Sign a signer-key grant. Returns the 65-byte recoverable signature in RSV
+* order (recovery byte last), hex — the layout `grant-signer-key`'s
+* `signer-sig (buff 65)` expects.
+*/
+declare function signSignerGrant(account: LocalAccount, opts: SignerGrantOptions): Promise<string>;
+/**
+* Verify a signer-key grant signature locally: recover the pubkey from the
+* RSV signature over the grant hash and compare. Returns `false` for
+* malformed input rather than throwing.
+*/
+declare function verifySignerGrant(opts: SignerGrantOptions & {
+	publicKey: Uint8Array | string
+	signature: Uint8Array | string
+}): boolean;
+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 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;
+type IntegerType = number | string | bigint | Uint8Array;
+/**
+* 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;
+type CallContractParams = {
+	contract: string
+	functionName: string
+	functionArgs?: ClarityValue[]
+	fee?: FeeParam
+	nonce?: IntegerType
+	postConditionMode?: "allow" | "deny"
+	postConditions?: PostCondition[]
+};
+/**
+* PoX-5 contract calls and reads, pinned against the final contract in
+* stacks-core 4.0.0. Wallet actions route through `callContract`, so they
+* inherit fee tiers, nonce management, and typed broadcast errors; pair the
+* returned txid with `waitForTransactionReceipt` to await inclusion.
+*
+* Note: pox-5 uses `contract-caller`/`tx-sender` directly (there is no
+* `allow-contract-caller` indirection like pox-4). Amount/lock safety is
+* expressed with the new Epoch 4.0 `Staking`/`Pox` post-conditions — pass
+* them via `postConditions` on any of these actions.
+*/
+/** Resolve the boot `pox-5` contract id for the client's chain. */
+declare function pox5ContractId(client: Client): string;
+type TxOptions = Pick<CallContractParams, "fee" | "nonce" | "postConditions" | "postConditionMode">;
+/**
+* One proven L1 timelock output — a Bitcoin SPV inclusion proof of the lockup
+* tx plus which output is the lockup. `@secondlayer/stacks/bitcoin`'s
+* `buildTxProof` produces the proof fields.
+*/
+type L1LockupOutput = {
+	/** Burn height of the Bitcoin block containing the lockup tx. */
+	height: IntegerType
+	/** Raw Bitcoin tx (witness-stripped), hex or bytes. */
+	tx: Uint8Array | string
+	outputIndex: IntegerType
+	/** 80-byte Bitcoin block header. */
+	header: Uint8Array | string
+	/** Merkle siblings, leaf→root (max 14). */
+	leafHashes: Array<Uint8Array | string>
+	txCount: IntegerType
+	txIndex: IntegerType
+	/** Output value in sats. */
+	amount: IntegerType
+	unlockBurnHeight: IntegerType
+};
+/** BTC side of a bond registration: proven L1 lockups, or an sBTC amount. */
+type BtcLockup = {
+	l1Outputs: L1LockupOutput[]
+	stakerUnlockBytes: Uint8Array | string
+} | {
+	sbtcSats: IntegerType
+};
+type SetupBondParams = TxOptions & {
+	bondIndex: IntegerType
+	/** Target yield rate, basis points. */
+	targetRate: IntegerType
+	/** µSTX per 100 sats (BTCUSD / STXUSD representation). */
+	stxValueRatio: IntegerType
+	/** Minimum locked STX relative to BTC, basis points. */
+	minUstxRatio: IntegerType
+	/** Early-unlock subscript for this bond's L1 lockup scripts (max 683B). */
+	earlyUnlockBytes: Uint8Array | string
+	allowlist: Array<{
+		staker: string
+		maxSats: IntegerType
+	}>
+};
+type RegisterForBondParams = TxOptions & {
+	bondIndex: IntegerType
+	/** Signer-manager contract principal. */
+	signerManager: string
+	amountUstx: IntegerType
+	btcLockup: BtcLockup
+	signerCalldata?: Uint8Array | string
+};
+type UpdateBondRegistrationParams = TxOptions & {
+	signerManager: string
+	oldSignerManager: string
+	signerCalldata?: Uint8Array | string
+};
+type StakeParams = TxOptions & {
+	signerManager: string
+	amountUstx: IntegerType
+	numCycles: IntegerType
+	startBurnHeight: IntegerType
+	signerCalldata?: Uint8Array | string
+};
+type StakeUpdateParams = TxOptions & {
+	signerManager: string
+	oldSignerManager: string
+	cyclesToExtend: IntegerType
+	amountIncrease: IntegerType
+	signerCalldata?: Uint8Array | string
+};
+type UnstakeParams = TxOptions & {
+	oldSignerManager: string
+};
+type UnstakeSbtcParams = TxOptions & {
+	signerManager: string
+	amountSats: IntegerType
+};
+type AnnounceL1EarlyExitParams = TxOptions & {
+	staker: string
+	oldSignerManager: string
+};
+type CalculateRewardsParams = TxOptions & {
+	bondPeriods: IntegerType[]
+};
+type ClaimRewardsParams = TxOptions & {
+	bondPeriods: IntegerType[]
+	rewardCycle: IntegerType
+};
+type ClaimStakerRewardsForSignerParams = TxOptions & {
+	staker: string
+	rewardCycle: IntegerType
+	bondIndex?: IntegerType
+};
+type GrantSignerKeyParams = TxOptions & {
+	/** 33-byte compressed signer key. */
+	signerKey: Uint8Array | string
+	signerManager: string
+	authId: IntegerType
+	/** 65-byte RSV signature from `signSignerGrant`. */
+	signerSig: Uint8Array | string
+};
+type RevokeSignerGrantParams = TxOptions & {
+	signerManager: string
+	signerKey: Uint8Array | string
+};
+/**
+* A staker's whole PoX-5 position in ONE batched request: staker info, bond
+* membership, custodied sBTC, and the current cycle — the state a dashboard
+* or agent polls, without four round-trips.
+*/
+type StakerState = {
+	stakerInfo: ClarityValue
+	bondMembership: ClarityValue
+	custodiedSbtc: ClarityValue
+	currentCycle: ClarityValue
+};
+/** Actions provided by the pox5 extension. */
+type Pox5Actions = {
+	pox5: {
+		isActive: () => Promise<boolean>
+		getActivation: () => Promise<Pox5Activation | undefined>
+		contractId: () => string
+		getStakerState: (staker: string) => Promise<StakerState>
+		getStakerInfo: (staker: string) => Promise<ClarityValue>
+		getBondMembership: (staker: string) => Promise<ClarityValue>
+		getProtocolBond: (bondIndex: IntegerType) => Promise<ClarityValue>
+		getBondAllowance: (bondIndex: IntegerType, staker: string) => Promise<ClarityValue>
+		getTotalSbtcStakedForBond: (bondIndex: IntegerType) => Promise<ClarityValue>
+		getStakerCustodiedSbtc: (staker: string) => Promise<ClarityValue>
+		hasAnnouncedL1EarlyExit: (bondIndex: IntegerType, staker: string) => Promise<ClarityValue>
+		getBondL1UnlockHeight: (bondIndex: IntegerType) => Promise<ClarityValue>
+		getSignerInfo: (signer: string) => Promise<ClarityValue>
+		verifySignerKeyGrant: (signerManager: string, signerKey: Uint8Array | string) => Promise<ClarityValue>
+		getCurrentRewardCycle: () => Promise<ClarityValue>
+		getFirstRewardCycle: () => Promise<ClarityValue>
+		setupBond: (params: SetupBondParams) => Promise<string>
+		registerForBond: (params: RegisterForBondParams) => Promise<string>
+		updateBondRegistration: (params: UpdateBondRegistrationParams) => Promise<string>
+		stake: (params: StakeParams) => Promise<string>
+		stakeUpdate: (params: StakeUpdateParams) => Promise<string>
+		unstake: (params: UnstakeParams) => Promise<string>
+		unstakeSbtc: (params: UnstakeSbtcParams) => Promise<string>
+		announceL1EarlyExit: (params: AnnounceL1EarlyExitParams) => Promise<string>
+		calculateRewards: (params: CalculateRewardsParams) => Promise<string>
+		claimRewards: (params: ClaimRewardsParams) => Promise<string>
+		claimStakerRewardsForSigner: (params: ClaimStakerRewardsForSignerParams) => Promise<string>
+		grantSignerKey: (params: GrantSignerKeyParams) => Promise<string>
+		revokeSignerGrant: (params: RevokeSignerGrantParams) => Promise<string>
+	}
+};
+/**
+* PoX-5 extension for the Stacks client.
+*
+* @example
+* const client = createWalletClient({ chain: mainnet, transport: http(), account })
+*   .extend(pox5());
+*
+* if (await client.pox5.isActive()) {
+*   const txid = await client.pox5.stake({
+*     signerManager: "SP…​.signer-mgr",
+*     amountUstx: 100_000_000_000n,
+*     numCycles: 12,
+*     startBurnHeight: 960_231,
+*     fee: "low",
+*   });
+*   await client.waitForTransactionReceipt({ txid });
+* }
+*/
+declare function pox5(): (client: Client) => Pox5Actions;
+export { verifySignerGrant, stakerPreimage, stakerConsensusBuff, signSignerGrant, serializeCScriptNum, rewardCycleToBurnHeight, pushScriptBytes, pushCScriptNum, pox5ContractId, pox5, isPox5Active, isInPreparePhase, getPox5Activation, computeSignerGrantHash, burnHeightToRewardCycle, burnHeightToDistributionIndex, buildLockupScript, buildLockupOutputScript, buildLockupAddress, buildDefaultStakerUnlockBytes, bondUnlockCycle, bondPhaseAtHeight, bondPeriodToRewardCycle, bondPeriodToBurnHeight, assertPox5Active, UpdateBondRegistrationParams, UnstakeSbtcParams, UnstakeParams, StakerState, StakeUpdateParams, StakeParams, SignerGrantOptions, SetupBondParams, RevokeSignerGrantParams, RegisterForBondParams, PoxCycleParams, Pox5Activation, Pox5Actions, POX5_SIGNER_DOMAIN, POX5_CONTRACT_NAME, POX5_ACTIVATION_BURN_HEIGHT_MAINNET, MAX_NUM_CYCLES, L1LockupOutput, GrantSignerKeyParams, ClaimStakerRewardsForSignerParams, ClaimRewardsParams, CalculateRewardsParams, C_SCRIPT_NUM_MAX, BuildLockupScriptOptions, BtcLockup, BondPhase, BondCycleParams, BOND_LENGTH_CYCLES, BOND_GAP_CYCLES, BITCOIN_LOCKTIME_THRESHOLD, AnnounceL1EarlyExitParams };