@secondlayer/stacks 4.2.0 → 4.3.1

package/dist/src/pox5/index.js

@@ -1,19 +1,32 @@
 import {
-  EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET
-} from "../../shared/stacks-rdgg7mj3.js";
+  EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET,
+  buildTxProof
+} from "../../shared/stacks-ztzygy90.js";
 import {
-  BITCOIN_NETWORK_PARAMS
+  POX_ADDRESS_VERSION
+} from "../../shared/stacks-e4xn4m7j.js";
+import {
+  BITCOIN_NETWORK_PARAMS,
+  doubleSha256,
+  parseBitcoinTx,
+  stripWitness
 } from "../../shared/stacks-0cdm20eh.js";
 import {
-  bech32
+  base58,
+  bech32,
+  bech32m
 } from "../../shared/stacks-5nmz5ad9.js";
 import {
   getContract
 } from "../../shared/stacks-jpt52csy.js";
 import {
+  getBalance,
+  getDataVar,
   multicall
-} from "../../shared/stacks-2evvn48s.js";
-import"../../shared/stacks-fb75yew8.js";
+} from "../../shared/stacks-8pfdscq6.js";
+import {
+  getMapEntry
+} from "../../shared/stacks-fb75yew8.js";
 import"../../shared/stacks-27fmgajb.js";
 import"../../shared/stacks-709tra19.js";
 import"../../shared/stacks-4z72akdf.js";
@@ -24,6 +37,7 @@ import"../../shared/stacks-hnqt5rz4.js";
 import"../../shared/stacks-w23294am.js";
 import {
   Cl,
+  deserializeCVBytes,
   serializeCVBytes
 } from "../../shared/stacks-ttdk2g2f.js";
 import"../../shared/stacks-bfan7ex7.js";
@@ -277,154 +291,6 @@ function describePox5Error(code) {
     return;
   return { code: n, name, description: POX5_ERROR_DESCRIPTIONS[n] };
 }
-// src/pox5/cycles.ts
-function burnHeightToRewardCycle(burnHeight, params) {
-  if (burnHeight < params.firstBurnchainBlockHeight) {
-    throw new Error(`burnHeight ${burnHeight} precedes first burnchain block ${params.firstBurnchainBlockHeight}`);
-  }
-  return Math.floor((burnHeight - params.firstBurnchainBlockHeight) / params.rewardCycleLength);
-}
-function rewardCycleToBurnHeight(cycle, params) {
-  return params.firstBurnchainBlockHeight + cycle * params.rewardCycleLength;
-}
-function bondPeriodToRewardCycle(bondIndex, params) {
-  return params.firstBondPeriodCycle + bondIndex * BOND_GAP_CYCLES;
-}
-function bondPeriodToBurnHeight(bondIndex, params) {
-  return rewardCycleToBurnHeight(bondPeriodToRewardCycle(bondIndex, params), params);
-}
-function bondUnlockCycle(bondIndex, params) {
-  return bondPeriodToRewardCycle(bondIndex, params) + BOND_LENGTH_CYCLES;
-}
-function burnHeightToDistributionIndex(burnHeight, params) {
-  return Math.floor((burnHeight - params.firstBurnchainBlockHeight) / Math.floor(params.rewardCycleLength / 2));
-}
-function isInPreparePhase(burnHeight, params) {
-  const offset = (burnHeight - params.firstBurnchainBlockHeight) % params.rewardCycleLength;
-  return offset >= params.rewardCycleLength - params.prepareCycleLength;
-}
-function bondPhaseAtHeight(bondIndex, burnHeight, params) {
-  const cycle = burnHeightToRewardCycle(burnHeight, params);
-  const start = bondPeriodToRewardCycle(bondIndex, params);
-  const unlock = bondUnlockCycle(bondIndex, params);
-  if (cycle < start - BOND_GAP_CYCLES)
-    return "too-early";
-  if (cycle < start)
-    return "open";
-  if (cycle < unlock)
-    return "locked";
-  return "unlocked";
-}
-// src/pox5/script.ts
-import { sha256 } from "@noble/hashes/sha2.js";
-function serializeCScriptNum(n) {
-  const big = typeof n === "bigint" ? n : BigInt(n);
-  if (big < 0n)
-    throw new Error("serializeCScriptNum: negative value");
-  if (big >= C_SCRIPT_NUM_MAX) {
-    throw new Error("serializeCScriptNum: n >= 2^39 (contract rejects with ERR_INVALID_UNLOCK_HEIGHT)");
-  }
-  if (big === 0n)
-    return new Uint8Array(0);
-  const out = [];
-  let v = big;
-  while (v > 0n) {
-    out.push(Number(v & 0xffn));
-    v >>= 8n;
-  }
-  if (out[out.length - 1] & 128)
-    out.push(0);
-  return Uint8Array.from(out);
-}
-function pushScriptBytes(bytes) {
-  const len = bytes.length;
-  if (len > 65535)
-    throw new Error(`pushScriptBytes: payload too large (${len} > 65535)`);
-  let prefix;
-  if (len < 76)
-    prefix = Uint8Array.of(len);
-  else if (len < 256)
-    prefix = Uint8Array.of(76, len);
-  else
-    prefix = Uint8Array.of(77, len & 255, len >> 8);
-  return concatBytes(prefix, bytes);
-}
-function pushCScriptNum(n) {
-  const big = typeof n === "bigint" ? n : BigInt(n);
-  if (big === 0n)
-    return Uint8Array.of(0);
-  if (big >= 1n && big <= 16n)
-    return Uint8Array.of(80 + Number(big));
-  return pushScriptBytes(serializeCScriptNum(big));
-}
-function stakerConsensusBuff(stxAddress) {
-  return serializeCVBytes(Cl.principal(stxAddress));
-}
-function stakerPreimage(stxAddress) {
-  return sha256(stakerConsensusBuff(stxAddress));
-}
-function toBytes(input) {
-  return typeof input === "string" ? hexToBytes(input) : input;
-}
-function buildLockupScript(opts) {
-  const height = BigInt(opts.unlockBurnHeight);
-  if (height >= BITCOIN_LOCKTIME_THRESHOLD) {
-    throw new Error("unlockBurnHeight >= 500,000,000 would be read by Bitcoin as a timestamp (contract rejects it)");
-  }
-  const stakerHash = sha256(stakerPreimage(opts.stxAddress));
-  return concatBytes(Uint8Array.of(99), pushCScriptNum(height), Uint8Array.of(177, 103), hexToBytes("82012088a820"), stakerHash, Uint8Array.of(136), toBytes(opts.earlyUnlockBytes), Uint8Array.of(104, 105), toBytes(opts.stakerUnlockBytes));
-}
-function buildLockupOutputScript(opts) {
-  return concatBytes(Uint8Array.of(0, 32), sha256(buildLockupScript(opts)));
-}
-function buildLockupAddress(opts, network = "mainnet") {
-  const hash = sha256(buildLockupScript(opts));
-  return bech32.encode(BITCOIN_NETWORK_PARAMS[network].hrp, [
-    0,
-    ...bech32.toWords(hash)
-  ]);
-}
-function buildDefaultStakerUnlockBytes(publicKey) {
-  const pubkey = toBytes(publicKey);
-  if (pubkey.length !== 33)
-    throw new Error(`Expected 33-byte compressed pubkey, got ${pubkey.length}`);
-  return concatBytes(pushScriptBytes(pubkey), Uint8Array.of(172));
-}
-// src/pox5/grants.ts
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-function computeSignerGrantHash(opts) {
-  return structuredDataHash({
-    domain: Cl.tuple({
-      name: Cl.stringAscii(POX5_SIGNER_DOMAIN.name),
-      version: Cl.stringAscii(POX5_SIGNER_DOMAIN.version),
-      "chain-id": Cl.uint(opts.chainId)
-    }),
-    message: Cl.tuple({
-      topic: Cl.stringAscii("grant-authorization"),
-      "signer-manager": Cl.principal(opts.signerManager),
-      "auth-id": Cl.uint(opts.authId)
-    })
-  });
-}
-async function signSignerGrant(account, opts) {
-  const vrs = await account.sign(computeSignerGrantHash(opts));
-  if (vrs.length !== 65)
-    throw new Error(`Expected 65-byte recoverable signature, got ${vrs.length}`);
-  return bytesToHex(concatBytes(vrs.slice(1), vrs.slice(0, 1)));
-}
-function verifySignerGrant(opts) {
-  try {
-    const sig = typeof opts.signature === "string" ? hexToBytes(opts.signature) : opts.signature;
-    if (sig.length !== 65)
-      return false;
-    const pubkey = typeof opts.publicKey === "string" ? hexToBytes(opts.publicKey) : opts.publicKey;
-    const hash = computeSignerGrantHash(opts);
-    const recovered = secp256k1.Signature.fromBytes(sig.slice(0, 64)).addRecoveryBit(sig[64]).recoverPublicKey(hash).toBytes(true);
-    return bytesToHex(recovered) === bytesToHex(pubkey);
-  } catch {
-    return false;
-  }
-}
 // src/pox5/abi.ts
 var POX5_ABI = {
   functions: [
@@ -537,6 +403,42 @@ var POX5_ABI = {
       ],
       outputs: { response: { ok: "bool", error: "uint128" } }
     },
+    {
+      name: "get-earned",
+      access: "read-only",
+      args: [
+        { name: "signer", type: "principal" },
+        { name: "reward-cycle", type: "uint128" },
+        { name: "bond-index", type: { optional: "uint128" } }
+      ],
+      outputs: "uint128"
+    },
+    {
+      name: "get-earned-staker-rewards",
+      access: "read-only",
+      args: [
+        { name: "signer", type: "principal" },
+        { name: "reward-cycle", type: "uint128" },
+        { name: "bond-index", type: { optional: "uint128" } },
+        { name: "staker", type: "principal" }
+      ],
+      outputs: "uint128"
+    },
+    {
+      name: "get-last-reward-compute-height",
+      access: "read-only",
+      args: [],
+      outputs: "uint128"
+    },
+    {
+      name: "get-total-shares-staked-for-cycle",
+      access: "read-only",
+      args: [
+        { name: "reward-cycle", type: "uint128" },
+        { name: "bond-index", type: { optional: "uint128" } }
+      ],
+      outputs: "uint128"
+    },
     {
       name: "announce-l1-early-exit",
       access: "public",
@@ -990,6 +892,49 @@ var POX5_ABI = {
           error: "uint128"
         }
       }
+    },
+    {
+      name: "set-bond-admin",
+      access: "public",
+      args: [{ name: "new-admin", type: "principal" }],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "new-admin", type: "principal" },
+              { name: "old-admin", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "set-pause-admin",
+      access: "public",
+      args: [{ name: "new-admin", type: "principal" }],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "new-admin", type: "principal" },
+              { name: "old-admin", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "pause-rewards",
+      access: "public",
+      args: [],
+      outputs: {
+        response: {
+          ok: "bool",
+          error: "uint128"
+        }
+      }
     }
   ]
 };
@@ -1005,11 +950,11 @@ function getPox5Contract(client) {
   const [address, name] = pox5ContractId(client).split(".");
   return getContract({ client, address, name, abi: POX5_ABI });
 }
-function toBytes2(input) {
+function toBytes(input) {
   return typeof input === "string" ? hexToBytes(input) : input;
 }
 function optionalBytes(input) {
-  return input === undefined ? null : toBytes2(input);
+  return input === undefined ? null : toBytes(input);
 }
 var MAX_LOCKUP_OUTPUTS = 10;
 var MAX_LEAF_HASHES = 14;
@@ -1032,16 +977,16 @@ function btcLockupArg(lockup) {
     ok: {
       outputs: lockup.l1Outputs.map((o) => ({
         height: intToBigInt(o.height),
-        tx: toBytes2(o.tx),
+        tx: toBytes(o.tx),
         outputIndex: intToBigInt(o.outputIndex),
-        header: toBytes2(o.header),
-        leafHashes: o.leafHashes.map(toBytes2),
+        header: toBytes(o.header),
+        leafHashes: o.leafHashes.map(toBytes),
         txCount: intToBigInt(o.txCount),
         txIndex: intToBigInt(o.txIndex),
         amount: intToBigInt(o.amount),
         unlockBurnHeight: intToBigInt(o.unlockBurnHeight)
       })),
-      stakerUnlockBytes: toBytes2(lockup.stakerUnlockBytes)
+      stakerUnlockBytes: toBytes(lockup.stakerUnlockBytes)
     }
   };
 }
@@ -1060,7 +1005,7 @@ function setupBond(client, params) {
     targetRate: intToBigInt(targetRate),
     stxValueRatio: intToBigInt(stxValueRatio),
     minUstxRatio: intToBigInt(minUstxRatio),
-    earlyUnlockBytes: toBytes2(earlyUnlockBytes),
+    earlyUnlockBytes: toBytes(earlyUnlockBytes),
     allowlist: allowlist.map((a) => ({
       staker: a.staker,
       maxSats: intToBigInt(a.maxSats)
@@ -1160,15 +1105,26 @@ function claimStakerRewardsForSigner(client, params) {
 function grantSignerKey(client, params) {
   const { signerKey, signerManager, authId, signerSig, ...tx } = params;
   return getPox5Contract(client).call.grantSignerKey({
-    signerKey: toBytes2(signerKey),
+    signerKey: toBytes(signerKey),
     signerManager,
     authId: intToBigInt(authId),
-    signerSig: toBytes2(signerSig)
+    signerSig: toBytes(signerSig)
   }, tx);
 }
 function revokeSignerGrant(client, params) {
   const { signerManager, signerKey, ...tx } = params;
-  return getPox5Contract(client).call.revokeSignerGrant({ signerManager, signerKey: toBytes2(signerKey) }, tx);
+  return getPox5Contract(client).call.revokeSignerGrant({ signerManager, signerKey: toBytes(signerKey) }, tx);
+}
+function setBondAdmin(client, params) {
+  const { newAdmin, ...tx } = params;
+  return getPox5Contract(client).call.setBondAdmin({ newAdmin }, tx);
+}
+function setPauseAdmin(client, params) {
+  const { newAdmin, ...tx } = params;
+  return getPox5Contract(client).call.setPauseAdmin({ newAdmin }, tx);
+}
+function pauseRewards(client, params) {
+  return getPox5Contract(client).call.pauseRewards({}, params ?? {});
 }
 async function getStakerInfo(client, staker) {
   return await getPox5Contract(client).read.getStakerInfo({
@@ -1218,7 +1174,7 @@ async function getSignerInfo(client, signer) {
 function verifySignerKeyGrantOnChain(client, signerManager, signerKey) {
   return getPox5Contract(client).read.verifySignerKeyGrant({
     signerManager,
-    signerKey: toBytes2(signerKey)
+    signerKey: toBytes(signerKey)
   });
 }
 function getCurrentRewardCycle(client) {
@@ -1227,49 +1183,806 @@ function getCurrentRewardCycle(client) {
 function getFirstPox5RewardCycle(client) {
   return getPox5Contract(client).read.getFirstPox5RewardCycle({});
 }
-// src/pox5/extension.ts
-async function getStakerState(client, staker) {
-  const contract = pox5ContractId(client);
-  const results = await multicall(client, {
-    allowFailure: false,
-    calls: [
-      {
-        contract,
-        functionName: "get-staker-info",
-        args: [Cl.principal(staker)]
-      },
-      {
-        contract,
-        functionName: "get-bond-membership",
-        args: [Cl.principal(staker)]
-      },
-      {
-        contract,
-        functionName: "get-staker-custodied-sbtc",
-        args: [Cl.principal(staker)]
-      },
-      { contract, functionName: "current-pox-reward-cycle", args: [] }
-    ]
+function getEarned(client, params) {
+  return getPox5Contract(client).read.getEarned({
+    signer: params.signer,
+    rewardCycle: intToBigInt(params.rewardCycle),
+    bondIndex: params.bondIndex === undefined ? null : intToBigInt(params.bondIndex)
   });
-  const [stakerInfo, bondMembership, custodiedSbtc, currentCycle] = results;
-  return {
-    stakerInfo,
-    bondMembership,
-    custodiedSbtc,
-    currentCycle
-  };
 }
-function pox5() {
-  return (client) => ({
-    pox5: {
-      isActive: () => isPox5Active(client),
-      getActivation: () => getPox5Activation(client),
-      getPoxInfo: () => getPoxInfo(client),
-      contractId: () => pox5ContractId(client),
-      getStakerState: (staker) => getStakerState(client, staker),
-      getStakerInfo: (staker) => getStakerInfo(client, staker),
-      getBondMembership: (staker) => getBondMembership(client, staker),
-      getProtocolBond: (bondIndex) => getProtocolBond(client, bondIndex),
+function getEarnedStakerRewards(client, params) {
+  return getPox5Contract(client).read.getEarnedStakerRewards({
+    signer: params.signer,
+    rewardCycle: intToBigInt(params.rewardCycle),
+    bondIndex: params.bondIndex === undefined ? null : intToBigInt(params.bondIndex),
+    staker: params.staker
+  });
+}
+function getLastRewardComputeHeight(client) {
+  return getPox5Contract(client).read.getLastRewardComputeHeight({});
+}
+function getTotalSharesStakedForCycle(client, rewardCycle, bondIndex) {
+  return getPox5Contract(client).read.getTotalSharesStakedForCycle({
+    rewardCycle: intToBigInt(rewardCycle),
+    bondIndex: bondIndex === undefined ? null : intToBigInt(bondIndex)
+  });
+}
+
+// src/pox5/cycles.ts
+function burnHeightToRewardCycle(burnHeight, params) {
+  if (burnHeight < params.firstBurnchainBlockHeight) {
+    throw new Error(`burnHeight ${burnHeight} precedes first burnchain block ${params.firstBurnchainBlockHeight}`);
+  }
+  return Math.floor((burnHeight - params.firstBurnchainBlockHeight) / params.rewardCycleLength);
+}
+function rewardCycleToBurnHeight(cycle, params) {
+  return params.firstBurnchainBlockHeight + cycle * params.rewardCycleLength;
+}
+function bondPeriodToRewardCycle(bondIndex, params) {
+  return params.firstBondPeriodCycle + bondIndex * BOND_GAP_CYCLES;
+}
+function bondPeriodToBurnHeight(bondIndex, params) {
+  return rewardCycleToBurnHeight(bondPeriodToRewardCycle(bondIndex, params), params);
+}
+function bondUnlockCycle(bondIndex, params) {
+  return bondPeriodToRewardCycle(bondIndex, params) + BOND_LENGTH_CYCLES;
+}
+function computeBondUnlockHeight(bondIndex, params) {
+  const endCycle = bondPeriodToRewardCycle(bondIndex + BOND_LENGTH_CYCLES / BOND_GAP_CYCLES, params);
+  return rewardCycleToBurnHeight(endCycle, params) - Math.floor(params.rewardCycleLength / 2);
+}
+function burnHeightToDistributionIndex(burnHeight, params) {
+  return Math.floor((burnHeight - params.firstBurnchainBlockHeight) / Math.floor(params.rewardCycleLength / 2));
+}
+function distributionCycleToBurnHeight(distIndex, params) {
+  return params.firstBurnchainBlockHeight + distIndex * Math.floor(params.rewardCycleLength / 2);
+}
+function currentDistributionCycle(burnHeight, params) {
+  return burnHeightToDistributionIndex(burnHeight, params);
+}
+function isInPreparePhase(burnHeight, params) {
+  const offset = (burnHeight - params.firstBurnchainBlockHeight) % params.rewardCycleLength;
+  return offset >= params.rewardCycleLength - params.prepareCycleLength;
+}
+function bondPhaseAtHeight(bondIndex, burnHeight, params) {
+  const cycle = burnHeightToRewardCycle(burnHeight, params);
+  const start = bondPeriodToRewardCycle(bondIndex, params);
+  const unlock = bondUnlockCycle(bondIndex, params);
+  if (cycle < start - BOND_GAP_CYCLES)
+    return "too-early";
+  if (cycle < start)
+    return "open";
+  if (cycle < unlock)
+    return "locked";
+  return "unlocked";
+}
+function bondStatusAtHeight(bondIndex, burnHeight, params) {
+  const cycle = burnHeightToRewardCycle(burnHeight, params);
+  const start = bondPeriodToRewardCycle(bondIndex, params);
+  const unlock = bondUnlockCycle(bondIndex, params);
+  if (cycle < start - BOND_GAP_CYCLES)
+    return "too-early";
+  if (cycle < start) {
+    if (cycle === start - 1 && isInPreparePhase(burnHeight, params)) {
+      return "locked";
+    }
+    return "open";
+  }
+  if (cycle < unlock)
+    return "locked";
+  return "unlocked";
+}
+
+// src/pox5/eligibility.ts
+function finish(reasons) {
+  const unique = [];
+  const seen = new Set;
+  for (const code of reasons) {
+    if (!seen.has(code)) {
+      seen.add(code);
+      unique.push(code);
+    }
+  }
+  if (unique.length === 0)
+    return { ok: true };
+  return { ok: false, reasons: unique };
+}
+function toBytes2(input) {
+  return typeof input === "string" ? hexToBytes(input) : input;
+}
+function outpointKey(tx, outputIndex) {
+  const hex = typeof tx === "string" ? tx.toLowerCase() : bytesToHex(tx);
+  return `${hex}:${intToBigInt(outputIndex)}`;
+}
+async function readCycleClock(client) {
+  const info = await getPoxInfo(client);
+  const burnHeight = info.currentBurnchainBlockHeight;
+  const first = info.firstBurnchainBlockHeight;
+  const raw = await client.request("/v2/pox", { method: "GET" });
+  const pox5 = info.contractVersions.find((v) => v.contractId.endsWith(`.${POX5_CONTRACT_NAME}`));
+  if (typeof burnHeight !== "number" || typeof first !== "number" || typeof raw.reward_cycle_length !== "number" || typeof raw.prepare_cycle_length !== "number" || pox5 == null) {
+    return;
+  }
+  return {
+    burnHeight,
+    params: {
+      firstBurnchainBlockHeight: first,
+      rewardCycleLength: raw.reward_cycle_length,
+      prepareCycleLength: raw.prepare_cycle_length
+    },
+    firstBondPeriodCycle: pox5.firstRewardCycleId
+  };
+}
+function inPrepare(clock) {
+  if (!clock)
+    return true;
+  return isInPreparePhase(clock.burnHeight, clock.params);
+}
+async function signerReasons(client, signerManager) {
+  const info = await getSignerInfo(client, signerManager);
+  if (info == null)
+    return [Pox5ErrorCode.SignerNotFound];
+  try {
+    const granted = await verifySignerKeyGrantOnChain(client, signerManager, info);
+    if (!granted)
+      return [Pox5ErrorCode.SignerKeyGrantNotFound];
+  } catch {
+    return [Pox5ErrorCode.SignerKeyGrantNotFound];
+  }
+  return [];
+}
+function bondOverlaps(membership, newFirstCycle, clock) {
+  if (!membership)
+    return false;
+  const start = bondPeriodToRewardCycle(Number(membership.bondIndex), {
+    ...clock.params,
+    firstBondPeriodCycle: clock.firstBondPeriodCycle
+  });
+  return start + BOND_LENGTH_CYCLES > newFirstCycle;
+}
+async function stxFloor(client, staker, amountUstx) {
+  const balance = await getBalance(client, { address: staker });
+  if (balance < amountUstx)
+    return Pox5ErrorCode.InsufficientStx;
+  return;
+}
+function principalValue(cv) {
+  if (cv.type === "address" || cv.type === "contract")
+    return cv.value;
+  return;
+}
+function minUstxForSats(sats, stxValueRatio, minUstxRatio) {
+  return stxValueRatio * sats / 100n * minUstxRatio / 10000n;
+}
+async function eligibleStake(client, params) {
+  const reasons = [];
+  const amountUstx = intToBigInt(params.amountUstx);
+  const numCycles = intToBigInt(params.numCycles);
+  const startBurnHeight = intToBigInt(params.startBurnHeight);
+  const [clock, stakerInfo, membership, signerErrs, floor] = await Promise.all([
+    readCycleClock(client),
+    getStakerInfo(client, params.staker),
+    getBondMembership(client, params.staker),
+    signerReasons(client, params.signerManager),
+    stxFloor(client, params.staker, amountUstx)
+  ]);
+  if (inPrepare(clock))
+    reasons.push(Pox5ErrorCode.StakeInPreparePhase);
+  reasons.push(...signerErrs);
+  if (floor !== undefined)
+    reasons.push(floor);
+  if (numCycles < 1n || numCycles > BigInt(MAX_NUM_CYCLES)) {
+    reasons.push(Pox5ErrorCode.InvalidNumCycles);
+  }
+  if (clock) {
+    const currentCycle = burnHeightToRewardCycle(clock.burnHeight, clock.params);
+    const firstRewardCycle = currentCycle + 1;
+    const specified = burnHeightToRewardCycle(Number(startBurnHeight), clock.params) + 1;
+    if (firstRewardCycle !== specified) {
+      reasons.push(Pox5ErrorCode.InvalidStartBurnHeight);
+    }
+    if (stakerInfo)
+      reasons.push(Pox5ErrorCode.AlreadyStaked);
+    if (bondOverlaps(membership, firstRewardCycle, clock)) {
+      reasons.push(Pox5ErrorCode.AlreadyStaked);
+    }
+    if (membership) {
+      const unlock = await getBondL1UnlockHeight(client, membership.bondIndex);
+      if (BigInt(clock.burnHeight) < unlock) {
+        reasons.push(Pox5ErrorCode.RolloverTooEarly);
+      }
+    }
+  } else if (stakerInfo) {
+    reasons.push(Pox5ErrorCode.AlreadyStaked);
+  }
+  return finish(reasons);
+}
+async function eligibleRegisterForBond(client, params) {
+  const reasons = [];
+  const amountUstx = intToBigInt(params.amountUstx);
+  const lockup = params.btcLockup;
+  let sats = 0n;
+  if ("sbtcSats" in lockup) {
+    sats = intToBigInt(lockup.sbtcSats);
+  } else {
+    if (lockup.l1Outputs.length === 0) {
+      reasons.push(Pox5ErrorCode.InvalidLockupAmount);
+    }
+    const seen = new Set;
+    for (const output of lockup.l1Outputs) {
+      sats += intToBigInt(output.amount);
+      const key = outpointKey(output.tx, output.outputIndex);
+      if (seen.has(key))
+        reasons.push(Pox5ErrorCode.DuplicateLockupOutpoint);
+      seen.add(key);
+    }
+  }
+  const [clock, stakerInfo, membership, bond, allowance, signerErrs, floor] = await Promise.all([
+    readCycleClock(client),
+    getStakerInfo(client, params.staker),
+    getBondMembership(client, params.staker),
+    getProtocolBond(client, params.bondIndex),
+    getBondAllowance(client, params.bondIndex, params.staker),
+    signerReasons(client, params.signerManager),
+    stxFloor(client, params.staker, amountUstx)
+  ]);
+  if (inPrepare(clock))
+    reasons.push(Pox5ErrorCode.StakeInPreparePhase);
+  reasons.push(...signerErrs);
+  if (floor !== undefined)
+    reasons.push(floor);
+  if (!bond)
+    reasons.push(Pox5ErrorCode.BondNotFound);
+  if (allowance == null)
+    reasons.push(Pox5ErrorCode.NotAllowlisted);
+  else if (sats > allowance)
+    reasons.push(Pox5ErrorCode.TooMuchSats);
+  if (bond) {
+    const min = minUstxForSats(sats, bond.stxValueRatio, bond.minUstxRatio);
+    if (amountUstx < min)
+      reasons.push(Pox5ErrorCode.InsufficientStx);
+  }
+  if (clock) {
+    const bondStart = bondPeriodToBurnHeight(Number(intToBigInt(params.bondIndex)), {
+      ...clock.params,
+      firstBondPeriodCycle: clock.firstBondPeriodCycle
+    });
+    if (clock.burnHeight >= bondStart) {
+      reasons.push(Pox5ErrorCode.BondAlreadyStarted);
+    }
+    const firstRewardCycle = bondPeriodToRewardCycle(Number(intToBigInt(params.bondIndex)), { ...clock.params, firstBondPeriodCycle: clock.firstBondPeriodCycle });
+    if (stakerInfo) {
+      const unlockCycle = Number(stakerInfo.firstRewardCycle) + Number(stakerInfo.numCycles);
+      if (unlockCycle > firstRewardCycle) {
+        reasons.push(Pox5ErrorCode.AlreadyStaked);
+      }
+    }
+    if (bondOverlaps(membership, firstRewardCycle, clock)) {
+      reasons.push(Pox5ErrorCode.AlreadyRegistered);
+    }
+    if (membership) {
+      const unlock = await getBondL1UnlockHeight(client, membership.bondIndex);
+      if (BigInt(clock.burnHeight) < unlock) {
+        reasons.push(Pox5ErrorCode.RolloverTooEarly);
+      }
+    }
+  }
+  if ("l1Outputs" in lockup && lockup.l1Outputs.length > 0) {
+    const minUnlock = await getBondL1UnlockHeight(client, params.bondIndex);
+    for (const output of lockup.l1Outputs) {
+      const height = intToBigInt(output.unlockBurnHeight);
+      if (height < minUnlock || height >= BITCOIN_LOCKTIME_THRESHOLD) {
+        reasons.push(Pox5ErrorCode.InvalidUnlockHeight);
+      }
+    }
+  }
+  return finish(reasons);
+}
+async function eligibleUnstake(client, params) {
+  const reasons = [];
+  const [clock, stakerInfo] = await Promise.all([
+    readCycleClock(client),
+    getStakerInfo(client, params.staker)
+  ]);
+  if (inPrepare(clock))
+    reasons.push(Pox5ErrorCode.UnstakeInPreparePhase);
+  if (!stakerInfo)
+    reasons.push(Pox5ErrorCode.NotStaking);
+  else if (stakerInfo.signer !== params.oldSignerManager) {
+    reasons.push(Pox5ErrorCode.InvalidOldSignerManager);
+  }
+  return finish(reasons);
+}
+async function eligibleUnstakeSbtc(client, params) {
+  const reasons = [];
+  const amount = intToBigInt(params.amountSats);
+  const [clock, membership] = await Promise.all([
+    readCycleClock(client),
+    getBondMembership(client, params.staker)
+  ]);
+  if (inPrepare(clock))
+    reasons.push(Pox5ErrorCode.StakeInPreparePhase);
+  if (!membership)
+    reasons.push(Pox5ErrorCode.NotBondParticipant);
+  else {
+    if (membership.signer !== params.signerManager) {
+      reasons.push(Pox5ErrorCode.InvalidOldSignerManager);
+    }
+    if (membership.isL1Lock)
+      reasons.push(Pox5ErrorCode.CannotUnstakeSbtc);
+    if (amount > membership.amountSats) {
+      reasons.push(Pox5ErrorCode.InvalidUnstakeSbtcAmount);
+    }
+  }
+  return finish(reasons);
+}
+async function eligibleClaimRewards(client, params) {
+  const reasons = [];
+  const contract = pox5ContractId(client);
+  const paused = await getDataVar(client, {
+    contract,
+    varName: "rewards-paused"
+  });
+  if (paused.type === "true")
+    reasons.push(Pox5ErrorCode.RewardsPaused);
+  const periods = params.bondPeriods ?? [];
+  const earnedParts = await Promise.all([
+    getEarned(client, {
+      signer: params.signer,
+      rewardCycle: params.rewardCycle,
+      bondIndex: params.bondIndex
+    }),
+    ...periods.map((bondIndex) => getEarned(client, {
+      signer: params.signer,
+      rewardCycle: params.rewardCycle,
+      bondIndex
+    }))
+  ]);
+  let total = 0n;
+  for (const part of earnedParts)
+    total += part;
+  if (total === 0n)
+    reasons.push(Pox5ErrorCode.NoClaimableRewards);
+  return finish(reasons);
+}
+async function eligibleGrantSignerKey(client, params) {
+  const reasons = [];
+  const used = await getMapEntry(client, {
+    contract: pox5ContractId(client),
+    mapName: "used-signer-key-grants",
+    key: Cl.tuple({
+      "signer-key": Cl.buffer(toBytes2(params.signerKey)),
+      "signer-manager": Cl.principal(params.signerManager),
+      "auth-id": Cl.uint(intToBigInt(params.authId))
+    })
+  });
+  if (used.type === "some")
+    reasons.push(Pox5ErrorCode.SignerKeyGrantUsed);
+  return finish(reasons);
+}
+async function eligibleSetBondAdmin(client, params) {
+  const admin = await getDataVar(client, {
+    contract: pox5ContractId(client),
+    varName: "bond-admin"
+  });
+  if (principalValue(admin) !== params.caller) {
+    return finish([Pox5ErrorCode.Unauthorized]);
+  }
+  return { ok: true };
+}
+async function eligiblePauseRewards(client, params) {
+  const admin = await getDataVar(client, {
+    contract: pox5ContractId(client),
+    varName: "pause-admin"
+  });
+  if (principalValue(admin) !== params.caller) {
+    return finish([Pox5ErrorCode.Unauthorized]);
+  }
+  return { ok: true };
+}
+// src/pox5/script.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+function serializeCScriptNum(n) {
+  const big = typeof n === "bigint" ? n : BigInt(n);
+  if (big < 0n)
+    throw new Error("serializeCScriptNum: negative value");
+  if (big >= C_SCRIPT_NUM_MAX) {
+    throw new Error("serializeCScriptNum: n >= 2^39 (contract rejects with ERR_INVALID_UNLOCK_HEIGHT)");
+  }
+  if (big === 0n)
+    return new Uint8Array(0);
+  const out = [];
+  let v = big;
+  while (v > 0n) {
+    out.push(Number(v & 0xffn));
+    v >>= 8n;
+  }
+  if (out[out.length - 1] & 128)
+    out.push(0);
+  return Uint8Array.from(out);
+}
+function pushScriptBytes(bytes) {
+  const len = bytes.length;
+  if (len > 65535)
+    throw new Error(`pushScriptBytes: payload too large (${len} > 65535)`);
+  let prefix;
+  if (len < 76)
+    prefix = Uint8Array.of(len);
+  else if (len < 256)
+    prefix = Uint8Array.of(76, len);
+  else
+    prefix = Uint8Array.of(77, len & 255, len >> 8);
+  return concatBytes(prefix, bytes);
+}
+function pushCScriptNum(n) {
+  const big = typeof n === "bigint" ? n : BigInt(n);
+  if (big === 0n)
+    return Uint8Array.of(0);
+  if (big >= 1n && big <= 16n)
+    return Uint8Array.of(80 + Number(big));
+  return pushScriptBytes(serializeCScriptNum(big));
+}
+function stakerConsensusBuff(stxAddress) {
+  return serializeCVBytes(Cl.principal(stxAddress));
+}
+function stakerPreimage(stxAddress) {
+  return sha256(stakerConsensusBuff(stxAddress));
+}
+function toBytes3(input) {
+  return typeof input === "string" ? hexToBytes(input) : input;
+}
+function buildLockupScript(opts) {
+  const height = BigInt(opts.unlockBurnHeight);
+  if (height <= 0n) {
+    throw new Error("unlockBurnHeight must be > 0 (contract rejects with ERR_INVALID_UNLOCK_HEIGHT)");
+  }
+  if (height >= BITCOIN_LOCKTIME_THRESHOLD) {
+    throw new Error("unlockBurnHeight >= 500,000,000 would be read by Bitcoin as a timestamp (contract rejects it)");
+  }
+  const stakerHash = sha256(stakerPreimage(opts.stxAddress));
+  return concatBytes(Uint8Array.of(99), pushCScriptNum(height), Uint8Array.of(177, 103), hexToBytes("82012088a820"), stakerHash, Uint8Array.of(136), toBytes3(opts.earlyUnlockBytes), Uint8Array.of(104, 105), toBytes3(opts.stakerUnlockBytes));
+}
+function buildLockupOutputScript(opts) {
+  return concatBytes(Uint8Array.of(0, 32), sha256(buildLockupScript(opts)));
+}
+function buildLockupAddress(opts, network = "mainnet") {
+  const hash = sha256(buildLockupScript(opts));
+  return bech32.encode(BITCOIN_NETWORK_PARAMS[network].hrp, [
+    0,
+    ...bech32.toWords(hash)
+  ]);
+}
+function buildDefaultStakerUnlockBytes(publicKey) {
+  const pubkey = toBytes3(publicKey);
+  if (pubkey.length !== 33)
+    throw new Error(`Expected 33-byte compressed pubkey, got ${pubkey.length}`);
+  const prefix = pubkey[0];
+  if (prefix !== 2 && prefix !== 3) {
+    throw new Error(`Expected compressed pubkey prefix 0x02 or 0x03, got ${prefix}`);
+  }
+  return concatBytes(pushScriptBytes(pubkey), Uint8Array.of(172));
+}
+function buildRegisterMetadata(opts) {
+  const unlockHeight = computeBondUnlockHeight(opts.bondIndex, opts.cycle);
+  const unlockBytes = buildDefaultStakerUnlockBytes(opts.bitcoinPublicKey);
+  const lockOpts = {
+    stxAddress: opts.stxAddress,
+    unlockBurnHeight: unlockHeight,
+    stakerUnlockBytes: unlockBytes,
+    earlyUnlockBytes: opts.earlyUnlockBytes
+  };
+  return {
+    lockAddress: buildLockupAddress(lockOpts, opts.network ?? "mainnet"),
+    lockScript: buildLockupScript(lockOpts),
+    outputScript: buildLockupOutputScript(lockOpts),
+    unlockBytes,
+    unlockHeight
+  };
+}
+// src/pox5/grants.ts
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+function computeSignerGrantHash(opts) {
+  return structuredDataHash({
+    domain: Cl.tuple({
+      name: Cl.stringAscii(POX5_SIGNER_DOMAIN.name),
+      version: Cl.stringAscii(POX5_SIGNER_DOMAIN.version),
+      "chain-id": Cl.uint(opts.chainId)
+    }),
+    message: Cl.tuple({
+      topic: Cl.stringAscii("grant-authorization"),
+      "signer-manager": Cl.principal(opts.signerManager),
+      "auth-id": Cl.uint(opts.authId)
+    })
+  });
+}
+async function signSignerGrant(account, opts) {
+  const vrs = await account.sign(computeSignerGrantHash(opts));
+  if (vrs.length !== 65)
+    throw new Error(`Expected 65-byte recoverable signature, got ${vrs.length}`);
+  return bytesToHex(concatBytes(vrs.slice(1), vrs.slice(0, 1)));
+}
+function verifySignerGrant(opts) {
+  try {
+    const sig = typeof opts.signature === "string" ? hexToBytes(opts.signature) : opts.signature;
+    if (sig.length !== 65)
+      return false;
+    const pubkey = typeof opts.publicKey === "string" ? hexToBytes(opts.publicKey) : opts.publicKey;
+    const hash = computeSignerGrantHash(opts);
+    const recovered = secp256k1.Signature.fromBytes(sig.slice(0, 64)).addRecoveryBit(sig[64]).recoverPublicKey(hash).toBytes(true);
+    return bytesToHex(recovered) === bytesToHex(pubkey);
+  } catch {
+    return false;
+  }
+}
+// src/pox5/lockProof.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+var MAX_LEAF_HASHES2 = 14;
+function lockupScriptPubKey(lockScript) {
+  return concatBytes(Uint8Array.of(0, 32), sha2562(lockScript));
+}
+function scriptsEqual(a, b) {
+  return bytesToHex(a) === bytesToHex(b);
+}
+function spvProofToL1LockupOutput(opts) {
+  const { proof, lockScript, unlockBurnHeight } = opts;
+  const tx = stripWitness(proof.rawTx);
+  const parsed = parseBitcoinTx(proof.rawTx);
+  const expected = lockupScriptPubKey(lockScript);
+  let outputIndex = opts.vout ?? proof.vout;
+  if (outputIndex === undefined) {
+    const matches = [];
+    for (let i = 0;i < parsed.outputs.length; i++) {
+      const spk = parsed.outputs[i]?.scriptPubKey;
+      if (spk && scriptsEqual(spk, expected))
+        matches.push(i);
+    }
+    if (matches.length !== 1) {
+      throw new Error(`spvProofToL1LockupOutput: expected exactly one matching lockup output, found ${matches.length}`);
+    }
+    outputIndex = matches[0];
+  }
+  const output = parsed.outputs[outputIndex];
+  if (!output) {
+    throw new Error(`spvProofToL1LockupOutput: output ${outputIndex} is out of range (${parsed.outputs.length} outputs)`);
+  }
+  if (!scriptsEqual(output.scriptPubKey, expected)) {
+    throw new Error("lockup output script does not match");
+  }
+  const leafHashes = proof.merkle.siblings;
+  if (leafHashes.length > MAX_LEAF_HASHES2) {
+    throw new Error(`spvProofToL1LockupOutput: ${leafHashes.length} merkle siblings; pox-5 accepts at most ${MAX_LEAF_HASHES2}`);
+  }
+  return {
+    height: proof.height,
+    tx,
+    outputIndex,
+    header: proof.header,
+    leafHashes,
+    txCount: proof.merkle.txCount,
+    txIndex: proof.merkle.txIndex,
+    amount: output.value,
+    unlockBurnHeight
+  };
+}
+async function buildPox5LockProof(opts) {
+  const proof = await buildTxProof(opts.source, {
+    txid: opts.txid,
+    vout: opts.vout
+  });
+  return spvProofToL1LockupOutput({
+    proof,
+    lockScript: opts.lockScript,
+    unlockBurnHeight: opts.unlockBurnHeight,
+    vout: opts.vout
+  });
+}
+// src/pox5/reclaim.ts
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
+import * as btc from "@scure/btc-signer";
+import { signECDSA } from "@scure/btc-signer/utils.js";
+var SIGHASH_ALL = 1;
+var DUST_LIMIT_SATS = 546n;
+var ELSE_SELECTOR = new Uint8Array(0);
+var IF_SELECTOR = new Uint8Array([1]);
+var TX_OPTS = {
+  allowUnknownOutputs: true,
+  disableScriptCheck: true,
+  allowUnknownInputs: true
+};
+var REGTEST_NETWORK = { ...btc.TEST_NETWORK, bech32: "bcrt" };
+function btcNetworkFrom(network) {
+  if (network === "mainnet")
+    return btc.NETWORK;
+  if (network === "testnet")
+    return btc.TEST_NETWORK;
+  return REGTEST_NETWORK;
+}
+function toBytes4(value) {
+  return typeof value === "string" ? hexToBytes(value) : value;
+}
+function toPrivBytes(value) {
+  return toBytes4(value).slice(0, 32);
+}
+function bytesEqual(a, b) {
+  return bytesToHex(a) === bytesToHex(b);
+}
+function scriptToWshOutput(lockScript) {
+  return concatBytes(Uint8Array.of(0, 32), sha2563(lockScript));
+}
+var SCAFFOLD_PREFIX_LEN = 10;
+function decodeLockScript(script) {
+  const ops = btc.Script.decode(script);
+  const endifIdx = ops.reduce((found, op, i) => op === "ENDIF" && ops[i + 1] === "VERIFY" ? i : found, -1);
+  const hashOp = ops[8];
+  const shapeOk = endifIdx >= SCAFFOLD_PREFIX_LEN && ops[0] === "IF" && ops[2] === "CHECKLOCKTIMEVERIFY" && ops[3] === "ELSE" && ops[4] === "SIZE" && ops[6] === "EQUALVERIFY" && ops[7] === "SHA256" && hashOp instanceof Uint8Array && hashOp.length === 32 && ops[9] === "EQUALVERIFY";
+  if (!shapeOk) {
+    throw new Error("reclaim: lockScript is not a pox-5 lockup script (expected the OP_IF/OP_ELSE … OP_ENDIF OP_VERIFY scaffold)");
+  }
+  const keysIn = (slice) => slice.filter((op) => op instanceof Uint8Array && op.length === 33);
+  const heightOp = ops[1];
+  const unlockHeight = typeof heightOp === "number" ? heightOp : heightOp instanceof Uint8Array ? Number(btc.ScriptNum().decode(heightOp)) : undefined;
+  return {
+    cosignerPubs: keysIn(ops.slice(SCAFFOLD_PREFIX_LEN, endifIdx)),
+    stakerPubs: keysIn(ops.slice(endifIdx + 2)),
+    unlockHeight
+  };
+}
+function buildReclaim(opts) {
+  const network = btcNetworkFrom(opts.network);
+  const lockScript = toBytes4(opts.lockScript);
+  const { unlockHeight: scriptHeight } = decodeLockScript(lockScript);
+  const amount = intToBigInt(opts.utxo.value);
+  const { address } = opts.output;
+  const feeSats = intToBigInt(opts.output.feeSats);
+  if (feeSats < 0n) {
+    throw new Error(`buildReclaim: feeSats (${feeSats}) must be non-negative`);
+  }
+  const outputScript = scriptToWshOutput(lockScript);
+  if (opts.utxo.scriptPubKey && !bytesEqual(opts.utxo.scriptPubKey, outputScript)) {
+    throw new Error("buildReclaim: utxo.scriptPubKey does not match the lockScript — the signature would commit to the wrong output and every reclaim attempt would fail at relay");
+  }
+  const sweepSats = amount - feeSats;
+  if (sweepSats <= 0n) {
+    throw new Error(`buildReclaim: fee (${feeSats}) >= utxo value (${amount})`);
+  }
+  if (sweepSats < DUST_LIMIT_SATS) {
+    throw new Error(`buildReclaim: sweep of ${sweepSats} sats is below the ${DUST_LIMIT_SATS}-sat dust limit — nodes would not relay the tx`);
+  }
+  const earlyExit = opts.path === "early-exit";
+  if (!earlyExit && scriptHeight == null) {
+    throw new Error("buildReclaim: the locktime path needs a lockScript that encodes a CLTV unlock height");
+  }
+  const lockTime = earlyExit ? 0 : scriptHeight;
+  const tx = new btc.Transaction({ ...TX_OPTS, lockTime });
+  tx.addInput({
+    txid: opts.utxo.txid,
+    index: opts.utxo.vout,
+    sequence: earlyExit ? 4294967295 : 4294967294,
+    witnessUtxo: { script: outputScript, amount },
+    witnessScript: lockScript
+  });
+  tx.addOutputAddress(address, sweepSats, network);
+  return tx;
+}
+function computeReclaimSighash(tx, opts) {
+  const input = tx.getInput(0);
+  const witnessScript = opts?.witnessScript != null ? toBytes4(opts.witnessScript) : input.witnessScript;
+  const amount = opts?.amountSats != null ? intToBigInt(opts.amountSats) : input.witnessUtxo?.amount;
+  if (!witnessScript || amount == null) {
+    throw new Error("computeReclaimSighash: need witnessScript + amount (pass `opts` for a raw-hex tx)");
+  }
+  return tx.preimageWitnessV0(0, witnessScript, SIGHASH_ALL, amount);
+}
+function signReclaim(sighash, privateKey, opts) {
+  const priv = toPrivBytes(privateKey);
+  return concatBytes(signECDSA(sighash, priv, opts?.lowR ?? false), Uint8Array.of(SIGHASH_ALL));
+}
+function finalizeReclaim(opts) {
+  const { tx } = opts;
+  const witnessScript = tx.getInput(0).witnessScript;
+  if (!witnessScript)
+    throw new Error("finalizeReclaim: input 0 has no witnessScript");
+  tx.updateInput(0, { finalScriptWitness: reclaimWitness(opts, witnessScript) }, true);
+  if (!tx.isFinal)
+    throw new Error("finalizeReclaim: witness injection failed (tx not final)");
+  return { txHex: tx.hex, txid: tx.id };
+}
+function reclaimWitness(opts, witnessScript) {
+  const sigs = opts.tx.getInput(0).partialSig ?? [];
+  const { stakerPubs, cosignerPubs } = decodeLockScript(witnessScript);
+  if (stakerPubs.length !== 1) {
+    throw new Error(`finalizeReclaim: expected exactly one staker public key in the lockup script, found ${stakerPubs.length} — multi-key subscripts are not supported`);
+  }
+  const stakerPub = stakerPubs[0];
+  if (!stakerPub) {
+    throw new Error("finalizeReclaim: expected exactly one staker public key in the lockup script, found 0 — multi-key subscripts are not supported");
+  }
+  const sigFor = (pub) => sigs.find(([p]) => p !== undefined && bytesEqual(p, pub))?.[1];
+  const stakerSig = sigFor(stakerPub);
+  if (!stakerSig)
+    throw new Error("finalizeReclaim: missing staker signature (partialSig)");
+  if (opts.path === "locktime")
+    return [stakerSig, IF_SELECTOR, witnessScript];
+  if (cosignerPubs.length !== 1) {
+    throw new Error(`finalizeReclaim: expected exactly one cosigner public key in the lockup script, found ${cosignerPubs.length} — multi-key subscripts are not supported`);
+  }
+  const cosignerPub = cosignerPubs[0];
+  if (!cosignerPub) {
+    throw new Error("finalizeReclaim: expected exactly one cosigner public key in the lockup script, found 0 — multi-key subscripts are not supported");
+  }
+  const cosignerSig = sigFor(cosignerPub);
+  if (!cosignerSig)
+    throw new Error("finalizeReclaim: missing cosigner signature (partialSig)");
+  return [
+    stakerSig,
+    cosignerSig,
+    stakerPreimage(opts.stxAddress),
+    ELSE_SELECTOR,
+    witnessScript
+  ];
+}
+function reclaim(opts) {
+  const tx = buildReclaim(opts);
+  tx.signIdx(toPrivBytes(opts.stakerPrivateKey), 0);
+  if (opts.path === "early-exit") {
+    if (opts.cosignerPrivateKey == null) {
+      throw new Error('reclaim: cosignerPrivateKey is required for path "early-exit"');
+    }
+    if (opts.stxAddress == null) {
+      throw new Error('reclaim: stxAddress is required for path "early-exit" (preimage)');
+    }
+    tx.signIdx(toPrivBytes(opts.cosignerPrivateKey), 0);
+    return finalizeReclaim({
+      path: "early-exit",
+      tx,
+      stxAddress: opts.stxAddress
+    });
+  }
+  return finalizeReclaim({ path: "locktime", tx });
+}
+// src/pox5/extension.ts
+async function getStakerState(client, staker) {
+  const contract = pox5ContractId(client);
+  const results = await multicall(client, {
+    allowFailure: false,
+    calls: [
+      {
+        contract,
+        functionName: "get-staker-info",
+        args: [Cl.principal(staker)]
+      },
+      {
+        contract,
+        functionName: "get-bond-membership",
+        args: [Cl.principal(staker)]
+      },
+      {
+        contract,
+        functionName: "get-staker-custodied-sbtc",
+        args: [Cl.principal(staker)]
+      },
+      { contract, functionName: "current-pox-reward-cycle", args: [] }
+    ]
+  });
+  const [stakerInfo, bondMembership, custodiedSbtc, currentCycle] = results;
+  return {
+    stakerInfo,
+    bondMembership,
+    custodiedSbtc,
+    currentCycle
+  };
+}
+function pox5() {
+  return (client) => ({
+    pox5: {
+      isActive: () => isPox5Active(client),
+      getActivation: () => getPox5Activation(client),
+      getPoxInfo: () => getPoxInfo(client),
+      contractId: () => pox5ContractId(client),
+      getStakerState: (staker) => getStakerState(client, staker),
+      getStakerInfo: (staker) => getStakerInfo(client, staker),
+      getBondMembership: (staker) => getBondMembership(client, staker),
+      getProtocolBond: (bondIndex) => getProtocolBond(client, bondIndex),
       getBondAllowance: (bondIndex, staker) => getBondAllowance(client, bondIndex, staker),
       getTotalSbtcStakedForBond: (bondIndex) => getTotalSbtcStakedForBond(client, bondIndex),
       getStakerCustodiedSbtc: (staker) => getStakerCustodiedSbtc(client, staker),
@@ -1279,6 +1992,18 @@ function pox5() {
       verifySignerKeyGrant: (signerManager, signerKey) => verifySignerKeyGrantOnChain(client, signerManager, signerKey),
       getCurrentRewardCycle: () => getCurrentRewardCycle(client),
       getFirstRewardCycle: () => getFirstPox5RewardCycle(client),
+      getEarned: (params) => getEarned(client, params),
+      getEarnedStakerRewards: (params) => getEarnedStakerRewards(client, params),
+      getLastRewardComputeHeight: () => getLastRewardComputeHeight(client),
+      getTotalSharesStakedForCycle: (rewardCycle, bondIndex) => getTotalSharesStakedForCycle(client, rewardCycle, bondIndex),
+      eligibleStake: (params) => eligibleStake(client, params),
+      eligibleRegisterForBond: (params) => eligibleRegisterForBond(client, params),
+      eligibleUnstake: (params) => eligibleUnstake(client, params),
+      eligibleUnstakeSbtc: (params) => eligibleUnstakeSbtc(client, params),
+      eligibleClaimRewards: (params) => eligibleClaimRewards(client, params),
+      eligibleGrantSignerKey: (params) => eligibleGrantSignerKey(client, params),
+      eligibleSetBondAdmin: (params) => eligibleSetBondAdmin(client, params),
+      eligiblePauseRewards: (params) => eligiblePauseRewards(client, params),
       setupBond: (params) => setupBond(client, params),
       registerForBond: (params) => registerForBond(client, params),
       updateBondRegistration: (params) => updateBondRegistration(client, params),
@@ -1291,35 +2016,237 @@ function pox5() {
       claimRewards: (params) => claimRewards(client, params),
       claimStakerRewardsForSigner: (params) => claimStakerRewardsForSigner(client, params),
       grantSignerKey: (params) => grantSignerKey(client, params),
-      revokeSignerGrant: (params) => revokeSignerGrant(client, params)
+      revokeSignerGrant: (params) => revokeSignerGrant(client, params),
+      setBondAdmin: (params) => setBondAdmin(client, params),
+      setPauseAdmin: (params) => setPauseAdmin(client, params),
+      pauseRewards: (params) => pauseRewards(client, params),
+      buildLockProof: (opts) => buildPox5LockProof(opts)
     }
   });
 }
+// src/pox5/btcAddress.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Decode(str) {
+  let num = 0n;
+  for (const char of str) {
+    const idx = BASE58_ALPHABET.indexOf(char);
+    if (idx === -1)
+      throw new Error(`Invalid base58 character: ${char}`);
+    num = num * 58n + BigInt(idx);
+  }
+  const hex = num.toString(16).padStart(2, "0");
+  const padded = hex.length % 2 ? `0${hex}` : hex;
+  const rawBytes = hexToBytes(padded);
+  let leadingZeros = 0;
+  for (const char of str) {
+    if (char === "1")
+      leadingZeros++;
+    else
+      break;
+  }
+  const result = new Uint8Array(leadingZeros + rawBytes.length);
+  result.set(rawBytes, leadingZeros);
+  return result;
+}
+function base58CheckEncode(version, payload) {
+  const data = concatBytes(Uint8Array.of(version), payload);
+  const checksum = doubleSha256(data).slice(0, 4);
+  return base58.encode(concatBytes(data, checksum));
+}
+function expectedHashLen(version) {
+  if (!Number.isInteger(version) || version < 0 || version > 6) {
+    throw new Error(`Unknown PoX address version: 0x${version.toString(16)}`);
+  }
+  return version <= 4 ? 20 : 32;
+}
+function canonicalizeBtcAddress(repr) {
+  const expected = expectedHashLen(repr.version);
+  const { hashbytes } = repr;
+  if (hashbytes.length === expected)
+    return { version: repr.version, hashbytes };
+  if (expected === 20 && hashbytes.length === 32 && hashbytes.slice(20).every((b) => b === 0)) {
+    return { version: repr.version, hashbytes: hashbytes.slice(0, 20) };
+  }
+  throw new Error(`Invalid hashbytes length for PoX version 0x${repr.version.toString(16)}: ${hashbytes.length}`);
+}
+function parseBtcAddress(address) {
+  if (address.startsWith("bc1") || address.startsWith("tb1") || address.startsWith("bcrt1")) {
+    return parseSegwitAddress(address);
+  }
+  return parseLegacyAddress(address);
+}
+function parseSegwitAddress(address) {
+  let decoded;
+  try {
+    decoded = bech32.decode(address);
+  } catch {
+    decoded = bech32m.decode(address);
+  }
+  const witnessVersion = decoded.words[0];
+  if (witnessVersion === undefined) {
+    throw new Error("Invalid segwit address: missing witness version");
+  }
+  const data = bech32.fromWords(decoded.words.slice(1));
+  const hashbytes = new Uint8Array(data);
+  let version;
+  if (witnessVersion === 0) {
+    if (hashbytes.length === 20) {
+      version = POX_ADDRESS_VERSION.p2wpkh;
+    } else if (hashbytes.length === 32) {
+      version = POX_ADDRESS_VERSION.p2wsh;
+    } else {
+      throw new Error(`Invalid witness v0 program length: ${hashbytes.length}`);
+    }
+  } else if (witnessVersion === 1) {
+    if (hashbytes.length !== 32) {
+      throw new Error(`Invalid witness v1 program length: ${hashbytes.length}`);
+    }
+    version = POX_ADDRESS_VERSION.p2tr;
+  } else {
+    throw new Error(`Unsupported witness version: ${witnessVersion}`);
+  }
+  return { version, hashbytes };
+}
+function parseLegacyAddress(address) {
+  const decoded = base58Decode(address);
+  if (decoded.length !== 25) {
+    throw new Error(`Invalid legacy address length: ${decoded.length}`);
+  }
+  const versionByte = decoded[0];
+  if (versionByte === undefined) {
+    throw new Error("Invalid legacy address: missing version byte");
+  }
+  const hashbytes = decoded.slice(1, 21);
+  let version;
+  if (versionByte === 0 || versionByte === 111) {
+    version = POX_ADDRESS_VERSION.p2pkh;
+  } else if (versionByte === 5 || versionByte === 196) {
+    version = POX_ADDRESS_VERSION.p2sh;
+  } else {
+    throw new Error(`Unknown legacy address version byte: 0x${versionByte.toString(16)}`);
+  }
+  return { version, hashbytes };
+}
+function stringifyBtcAddress(repr, network) {
+  const { version, hashbytes } = canonicalizeBtcAddress(repr);
+  const params = BITCOIN_NETWORK_PARAMS[network];
+  switch (version) {
+    case POX_ADDRESS_VERSION.p2pkh:
+      return base58CheckEncode(params.p2pkh, hashbytes);
+    case POX_ADDRESS_VERSION.p2sh:
+    case POX_ADDRESS_VERSION.p2sh_p2wpkh:
+    case POX_ADDRESS_VERSION.p2sh_p2wsh:
+      return base58CheckEncode(params.p2sh, hashbytes);
+    case POX_ADDRESS_VERSION.p2wpkh:
+    case POX_ADDRESS_VERSION.p2wsh:
+      return bech32.encode(params.hrp, [0, ...bech32.toWords(hashbytes)]);
+    case POX_ADDRESS_VERSION.p2tr:
+      return bech32m.encode(params.hrp, [1, ...bech32m.toWords(hashbytes)]);
+    default:
+      throw new Error(`Unknown PoX address version: 0x${version.toString(16)}`);
+  }
+}
+var BtcAddress = {
+  parse: parseBtcAddress,
+  stringify: stringifyBtcAddress
+};
+// src/pox5/signerCalldata.ts
+function buildSignerCalldata(opts) {
+  const repr = canonicalizeBtcAddress(typeof opts.poxAddress === "string" ? parseBtcAddress(opts.poxAddress) : opts.poxAddress);
+  return serializeCVBytes(Cl.tuple({
+    "pox-addr": Cl.tuple({
+      version: Cl.buffer(Uint8Array.of(repr.version)),
+      hashbytes: Cl.buffer(repr.hashbytes)
+    }),
+    "max-fee": Cl.uint(opts.maxFeeSats)
+  }));
+}
+function parseSignerCalldata(calldata) {
+  const cv = deserializeCVBytes(calldata);
+  if (cv.type !== "tuple") {
+    throw new Error("signer calldata is not a Clarity tuple");
+  }
+  const poxAddr = cv.value["pox-addr"];
+  const maxFee = cv.value["max-fee"];
+  if (!poxAddr || poxAddr.type !== "tuple") {
+    throw new Error("signer calldata missing pox-addr tuple");
+  }
+  if (!maxFee || maxFee.type !== "uint") {
+    throw new Error("signer calldata missing max-fee uint");
+  }
+  const versionCv = poxAddr.value.version;
+  const hashCv = poxAddr.value.hashbytes;
+  if (!versionCv || versionCv.type !== "buffer") {
+    throw new Error("signer calldata pox-addr missing version buffer");
+  }
+  if (!hashCv || hashCv.type !== "buffer") {
+    throw new Error("signer calldata pox-addr missing hashbytes buffer");
+  }
+  const versionBytes = hexToBytes(versionCv.value);
+  if (versionBytes.length !== 1) {
+    throw new Error(`signer calldata version must be buff 1, got ${versionBytes.length}`);
+  }
+  const version = versionBytes[0];
+  if (version === undefined) {
+    throw new Error("signer calldata version buffer is empty");
+  }
+  return {
+    poxAddress: canonicalizeBtcAddress({
+      version,
+      hashbytes: hexToBytes(hashCv.value)
+    }),
+    maxFeeSats: maxFee.value
+  };
+}
 export {
   verifySignerGrant,
+  stringifyBtcAddress,
   stakerPreimage,
   stakerConsensusBuff,
+  spvProofToL1LockupOutput,
   signSignerGrant,
+  signReclaim,
   serializeCScriptNum,
   rewardCycleToBurnHeight,
+  reclaim,
   pushScriptBytes,
   pushCScriptNum,
   pox5ContractId,
   pox5,
+  parseSignerCalldata,
   parsePox5Error,
+  parseBtcAddress,
   isPox5Active,
   isInPreparePhase,
   getPoxInfo,
   getPox5Activation,
+  finalizeReclaim,
+  eligibleUnstakeSbtc,
+  eligibleUnstake,
+  eligibleStake,
+  eligibleSetBondAdmin,
+  eligibleRegisterForBond,
+  eligiblePauseRewards,
+  eligibleGrantSignerKey,
+  eligibleClaimRewards,
+  distributionCycleToBurnHeight,
   describePox5Error,
+  currentDistributionCycle,
   computeSignerGrantHash,
+  computeReclaimSighash,
+  computeBondUnlockHeight,
   burnHeightToRewardCycle,
   burnHeightToDistributionIndex,
+  buildSignerCalldata,
+  buildRegisterMetadata,
+  buildReclaim,
+  buildPox5LockProof,
   buildLockupScript,
   buildLockupOutputScript,
   buildLockupAddress,
   buildDefaultStakerUnlockBytes,
   bondUnlockCycle,
+  bondStatusAtHeight,
   bondPhaseAtHeight,
   bondPeriodToRewardCycle,
   bondPeriodToBurnHeight,
@@ -1334,10 +2261,11 @@ export {
   POX5_ABI,
   MAX_NUM_CYCLES,
   C_SCRIPT_NUM_MAX,
+  BtcAddress,
   BOND_LENGTH_CYCLES,
   BOND_GAP_CYCLES,
   BITCOIN_LOCKTIME_THRESHOLD
 };
 
-//# debugId=A1DC6FC93AED92D864756E2164756E21
+//# debugId=8137CB55456126D164756E2164756E21
 //# sourceMappingURL=index.js.map