@@ -37,4 +37,5 @@
   * [Getting Allowlisted for a Bond](protocol-bonds/getting-allowlisted-for-a-bond.md)
   * [Bond Pool (BTC + STX) Operator Guide](protocol-bonds/bond-pool-operator-guide.md)
   * [Opening a Bond Position](protocol-bonds/opening-a-bond-position.md)
+  * [Verifying and Reclaiming Your Locked Bitcoin](protocol-bonds/verifying-and-reclaiming-your-locked-bitcoin.md)
   * [Ending or Changing a Bond Position](protocol-bonds/ending-or-changing-a-bond-position.md)
@@ -10,6 +10,7 @@ A protocol bond pairs a Bitcoin commitment with an STX lock for a 12-cycle term.
 
 * [Getting Allowlisted for a Bond](getting-allowlisted-for-a-bond.md): how capacity is allocated, what to send the Stacks Endowment, and how to check your entry.
 * [Opening a Bond Position](opening-a-bond-position.md): the allowlist, the two Bitcoin legs, the registration deadline, and what the contract checks.
+* [Verifying and Reclaiming Your Locked Bitcoin](verifying-and-reclaiming-your-locked-bitcoin.md): checking the lock address before funding, what you need to spend it later, and reclaiming after the timelock.
 * [Ending or Changing a Bond Position](ending-or-changing-a-bond-position.md): exiting early, withdrawing sBTC, changing signer-manager, and rolling into a new position.
 * [Bond pool operator guide](bond-pool-operator-guide.md): running a whitelisted community sBTC pool.
 
 
@@ -118,6 +118,18 @@ What each route does with your assets:
 
 Because your STX is still locked by the ending position, both functions check your locked plus unlocked balance rather than unlocked alone. A bond and an STX-only stake can never both be live, which is why moving between them happens at a boundary rather than mid-term.
 
+### Renewing a native BTC bond
+
+Renewing means registering for the next bond before yours ends, so you move straight from one into the next. The first bond that does not overlap yours starts when yours ends, six bond indexes later.
+
+1. **Get allowlisted for the new bond.** Each bond has its own allowlist, and being on the current one does not carry over. See [Getting Allowlisted for a Bond](getting-allowlisted-for-a-bond.md).
+2. **Lock BTC for the new bond.** Either fund its lock address from other BTC ahead of time, or wait until your current output's unlock height and spend that output straight into the new lock address. The second needs no other BTC. See [Verifying and Reclaiming Your Locked Bitcoin](verifying-and-reclaiming-your-locked-bitcoin.md).
+3. **Register once the new lock confirms**, after your bond's L1 unlock height and before the prepare phase that precedes its end. You can change the STX amount. It must meet the new bond's minimum, and your STX that is still locked counts toward your balance.
+
+On testnet the window is half a testnet reward cycle, 525 blocks, of which 475 are usable.
+
+If you do not register in time, your bond ends normally: your STX unlocks at the end of the term and your BTC stays spendable by you through the timelock branch. You can still join a later bond as a new registration.
+
 ## Prepare-phase timing
 
 `register-for-bond`, `update-bond-registration`, `stake`, `stake-update`, `announce-l1-early-exit`, and `unstake-sbtc` share one guard and one error, `ERR_STAKE_IN_PREPARE_PHASE (u47)`. `unstake` has its own check and code, `ERR_UNSTAKE_IN_PREPARE_PHASE (u28)`.
 
@@ -55,7 +55,7 @@ Read your cap for the bond. A missing entry means you are not allowlisted.
 The address is deterministic: it comes from your Stacks address, the bond's unlock height, your `staker-unlock-bytes`, and the bond's `early-unlock-bytes`. Anyone can rederive it to check the lock.
 
 {% hint style="danger" %}
-**Keep your unlock bytes.** The `staker-unlock-bytes` are not stored on-chain. Without them the lock address cannot be rebuilt and the BTC cannot be reclaimed by either path.
+**Keep your lock script.** The contract does not store your `staker-unlock-bytes` or the lock script built from them, so save the lock script when you register. If you lose it, rebuild it from your `register-for-bond` transaction. See [Verifying and Reclaiming Your Locked Bitcoin](verifying-and-reclaiming-your-locked-bitcoin.md).
 {% endhint %}
 {% endstep %}
 
 
@@ -0,0 +1,102 @@
+---
+description: >-
+  How to check a bond's Bitcoin lock address before you fund it, what you need
+  to spend it later, and how to reclaim your BTC once the timelock passes.
+---
+
+# Verifying and Reclaiming Your Locked Bitcoin
+
+On a native BTC bond your Bitcoin stays in an output you control, guarded by a timelock. This page covers the two moments that matter for your funds: checking the lock address before you send anything to it, and spending the output back to yourself once the timelock passes. For leaving before the timelock, see [Ending or Changing a Bond Position](ending-or-changing-a-bond-position.md).
+
+## Before you fund: check the lock address
+
+The lock address is deterministic. It is built from four inputs:
+
+* your Stacks address,
+* the output's unlock height, at or above the bond's minimum,
+* your `staker-unlock-bytes`, by default `<your Bitcoin public key> OP_CHECKSIG`,
+* the bond's `early-unlock-bytes`, published on-chain when the bond is set up.
+
+Check the address against the contract before funding. The contract's `construct-lockup-output-script` builds the same output from the same inputs. If it disagrees with the address your wallet or tool shows, do not fund. The code is under [Cross-check the script before funding](verifying-and-reclaiming-your-locked-bitcoin.md#cross-check-the-script-before-funding).
+
+{% hint style="danger" %}
+**Check before you send.** BTC sent to an address that does not match the contract's script cannot be registered for the bond, and whether you can spend it depends entirely on what that address actually encodes.
+{% endhint %}
+
+## What you need to spend it later
+
+Spending the output needs the lock script, the output itself, and your Bitcoin key. Save the lock script when you register, and keep the lock transaction ID: it identifies the output to spend. If you lose the lock script, you can rebuild it from its four inputs:
+
+| Input                 | Where to find it again                                                                                                       |
+| --------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| Stacks address        | Your Stacks wallet                                                                                                           |
+| Unlock height         | The arguments of your `register-for-bond` transaction                                                                        |
+| `staker-unlock-bytes` | The same transaction. With the default unlock bytes, rebuild them from the public key of the Bitcoin key you registered with |
+| `early-unlock-bytes`  | The bond's on-chain record                                                                                                   |
+
+The contract keeps none of these in its own state, which is why the registration transaction matters.
+
+## Reclaim after the timelock
+
+Once Bitcoin passes the output's unlock height, you spend it alone through the timelock branch. There is no co-signer, no Stacks transaction and no deadline: the output stays spendable by you from then on.
+
+Your STX leg unlocks separately, at the end of the bond term on Stacks. See the [bond timeline](https://docs.stacks.co/learn/bitcoin-staking#the-bond-timeline).
+
+## Building a reclaim
+
+For wallet, custodian, and app developers. The examples use [`@stacks/bitcoin-staking`](https://www.npmjs.com/package/@stacks/bitcoin-staking) 7.6.0.
+
+### Cross-check the script before funding
+
+```ts
+import { buildLockOutputScript, fetchConstructLockupOutputScript } from '@stacks/bitcoin-staking';
+import { bytesToHex } from '@stacks/common';
+
+const inputs = { stxAddress: staker, unlockHeight, unlockBytes, earlyUnlockBytes: bond.earlyUnlockBytes };
+
+const local = buildLockOutputScript(inputs);
+const onchain = await fetchConstructLockupOutputScript({ ...inputs, network: 'mainnet' });
+if (bytesToHex(local) !== bytesToHex(onchain)) {
+  throw new Error('Lock script mismatch: do not fund');
+}
+```
+
+### Rebuild the lock script if you did not keep it
+
+```ts
+import { buildLockScript, buildUnlockScript, fetchBond } from '@stacks/bitcoin-staking';
+
+const bond = await fetchBond({ bondIndex, network: 'mainnet' });
+const lockScript = buildLockScript({
+  stxAddress: staker,
+  unlockHeight, // from your register-for-bond transaction
+  unlockBytes: buildUnlockScript(stakerBtcPublicKey),
+  earlyUnlockBytes: bond.earlyUnlockBytes,
+});
+```
+
+### Build, sign and finalize the spend
+
+```ts
+import { buildReclaim, finalizeReclaim } from '@stacks/bitcoin-staking';
+
+const tx = buildReclaim({
+  path: 'locktime',
+  utxo,       // the lockup UTXO: { txid, vout, value }
+  lockScript,
+  output: { address: destinationAddress, feeSats },
+  network: 'mainnet',
+});
+
+// Sign input 0 with your key, or send tx.toPSBT() to a hardware or browser wallet
+tx.signIdx(stakerPrivateKey, 0);
+
+const { txHex, txid } = finalizeReclaim({ path: 'locktime', tx });
+// Broadcast txHex to Bitcoin
+```
+
+`buildReclaim` sets the transaction's `nLockTime` to the unlock height decoded from the lock script, so the spend can be mined from the block after that height. The signature commits to the outputs and fee, so set them before signing.
+
+### Relock straight into the next bond
+
+To renew without other BTC, set `output.address` to the next bond's lock address instead of your own. The same spend moves your BTC from the old lock into the new one. Once it confirms, register for the next bond with a proof of the new output. See [Renewing a native BTC bond](ending-or-changing-a-bond-position.md#renewing-a-native-btc-bond).