@bitgo-beta/babylonlabs-io-btc-staking-ts 0.4.0-beta.514 → 0.4.0-beta.516

package/dist/index.js

@@ -104,9 +104,6 @@ import { address as address2, payments } from "bitcoinjs-lib";
 var key = "0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
 var internalPubkey = Buffer.from(key, "hex").subarray(1, 33);
 
-// src/constants/unbonding.ts
-var MIN_UNBONDING_OUTPUT_VALUE = 1e3;
-
 // src/utils/staking/index.ts
 var buildStakingTransactionOutputs = (scripts, network, amount) => {
   const stakingOutputInfo = deriveStakingOutputInfo(scripts, network);
@@ -204,124 +201,6 @@ var findMatchingTxOutputIndex = (tx, outputAddress, network) => {
   }
   return index;
 };
-var validateStakingTxInputData = (stakingAmountSat, timelock, params, inputUTXOs, feeRate) => {
-  if (stakingAmountSat < params.minStakingAmountSat || stakingAmountSat > params.maxStakingAmountSat) {
-    throw new StakingError(
-      "INVALID_INPUT" /* INVALID_INPUT */,
-      "Invalid staking amount"
-    );
-  }
-  if (timelock < params.minStakingTimeBlocks || timelock > params.maxStakingTimeBlocks) {
-    throw new StakingError("INVALID_INPUT" /* INVALID_INPUT */, "Invalid timelock");
-  }
-  if (inputUTXOs.length == 0) {
-    throw new StakingError(
-      "INVALID_INPUT" /* INVALID_INPUT */,
-      "No input UTXOs provided"
-    );
-  }
-  if (feeRate <= 0) {
-    throw new StakingError("INVALID_INPUT" /* INVALID_INPUT */, "Invalid fee rate");
-  }
-};
-var validateParams = (params) => {
-  if (params.covenantNoCoordPks.length == 0) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      "Could not find any covenant public keys"
-    );
-  }
-  if (params.covenantNoCoordPks.length < params.covenantQuorum) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      "Covenant public keys must be greater than or equal to the quorum"
-    );
-  }
-  params.covenantNoCoordPks.forEach((pk) => {
-    if (!isValidNoCoordPublicKey(pk)) {
-      throw new StakingError(
-        "INVALID_PARAMS" /* INVALID_PARAMS */,
-        "Covenant public key should contains no coordinate"
-      );
-    }
-  });
-  if (params.unbondingTime <= 0) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      "Unbonding time must be greater than 0"
-    );
-  }
-  if (params.unbondingFeeSat <= 0) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      "Unbonding fee must be greater than 0"
-    );
-  }
-  if (params.maxStakingAmountSat < params.minStakingAmountSat) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      "Max staking amount must be greater or equal to min staking amount"
-    );
-  }
-  if (params.minStakingAmountSat < params.unbondingFeeSat + MIN_UNBONDING_OUTPUT_VALUE) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      `Min staking amount must be greater than unbonding fee plus ${MIN_UNBONDING_OUTPUT_VALUE}`
-    );
-  }
-  if (params.maxStakingTimeBlocks < params.minStakingTimeBlocks) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      "Max staking time must be greater or equal to min staking time"
-    );
-  }
-  if (params.minStakingTimeBlocks <= 0) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      "Min staking time must be greater than 0"
-    );
-  }
-  if (params.covenantQuorum <= 0) {
-    throw new StakingError(
-      "INVALID_PARAMS" /* INVALID_PARAMS */,
-      "Covenant quorum must be greater than 0"
-    );
-  }
-  if (params.slashing) {
-    if (params.slashing.slashingRate <= 0) {
-      throw new StakingError(
-        "INVALID_PARAMS" /* INVALID_PARAMS */,
-        "Slashing rate must be greater than 0"
-      );
-    }
-    if (params.slashing.slashingRate > 1) {
-      throw new StakingError(
-        "INVALID_PARAMS" /* INVALID_PARAMS */,
-        "Slashing rate must be less or equal to 1"
-      );
-    }
-    if (params.slashing.slashingPkScriptHex.length == 0) {
-      throw new StakingError(
-        "INVALID_PARAMS" /* INVALID_PARAMS */,
-        "Slashing public key script is missing"
-      );
-    }
-    if (params.slashing.minSlashingTxFeeSat <= 0) {
-      throw new StakingError(
-        "INVALID_PARAMS" /* INVALID_PARAMS */,
-        "Minimum slashing transaction fee must be greater than 0"
-      );
-    }
-  }
-};
-var validateStakingTimelock = (stakingTimelock, params) => {
-  if (stakingTimelock < params.minStakingTimeBlocks || stakingTimelock > params.maxStakingTimeBlocks) {
-    throw new StakingError(
-      "INVALID_INPUT" /* INVALID_INPUT */,
-      "Staking transaction timelock is out of range"
-    );
-  }
-};
 var toBuffers = (inputs) => {
   try {
     return inputs.map((i) => Buffer.from(i, "hex"));
@@ -333,6 +212,30 @@ var toBuffers = (inputs) => {
     );
   }
 };
+var clearTxSignatures = (tx) => {
+  tx.ins.forEach((input) => {
+    input.script = Buffer.alloc(0);
+    input.witness = [];
+  });
+  return tx;
+};
+var deriveMerkleProof = (merkle) => {
+  const proofHex = merkle.reduce((acc, m) => {
+    return acc + Buffer.from(m, "hex").reverse().toString("hex");
+  }, "");
+  return proofHex;
+};
+var extractFirstSchnorrSignatureFromTransaction = (singedTransaction) => {
+  for (const input of singedTransaction.ins) {
+    if (input.witness && input.witness.length > 0) {
+      const schnorrSignature = input.witness[0];
+      if (schnorrSignature.length === 64) {
+        return schnorrSignature;
+      }
+    }
+  }
+  return void 0;
+};
 
 // src/staking/psbt.ts
 import { Psbt, payments as payments3 } from "bitcoinjs-lib";
@@ -475,6 +378,82 @@ var stakingPsbt = (stakingTx, network, inputUTXOs, publicKeyNoCoord) => {
   });
   return psbt;
 };
+var stakingExpansionPsbt = (network, stakingTx, previousStakingTxInfo, inputUTXOs, previousScripts, publicKeyNoCoord) => {
+  const psbt = new Psbt({ network });
+  if (stakingTx.version !== void 0)
+    psbt.setVersion(stakingTx.version);
+  if (stakingTx.locktime !== void 0)
+    psbt.setLocktime(stakingTx.locktime);
+  if (publicKeyNoCoord && publicKeyNoCoord.length !== NO_COORD_PK_BYTE_LENGTH) {
+    throw new Error("Invalid public key");
+  }
+  const previousStakingOutput = previousStakingTxInfo.stakingTx.outs[previousStakingTxInfo.outputIndex];
+  if (!previousStakingOutput) {
+    throw new Error("Previous staking output not found");
+  }
+  ;
+  if (getScriptType(previousStakingOutput.script) !== "taproot" /* P2TR */) {
+    throw new Error("Previous staking output script type is not P2TR");
+  }
+  if (stakingTx.ins.length !== 2) {
+    throw new Error(
+      "Staking expansion transaction must have exactly 2 inputs"
+    );
+  }
+  const txInputs = stakingTx.ins;
+  if (Buffer.from(txInputs[0].hash).reverse().toString("hex") !== previousStakingTxInfo.stakingTx.getId()) {
+    throw new Error("Previous staking input hash does not match");
+  } else if (txInputs[0].index !== previousStakingTxInfo.outputIndex) {
+    throw new Error("Previous staking input index does not match");
+  }
+  const inputScriptTree = [
+    { output: previousScripts.slashingScript },
+    [{ output: previousScripts.unbondingScript }, { output: previousScripts.timelockScript }]
+  ];
+  const inputRedeem = {
+    output: previousScripts.unbondingScript,
+    redeemVersion: REDEEM_VERSION
+  };
+  const p2tr = payments3.p2tr({
+    internalPubkey,
+    scriptTree: inputScriptTree,
+    redeem: inputRedeem,
+    network
+  });
+  if (!p2tr.witness || p2tr.witness.length === 0) {
+    throw new Error(
+      "Failed to create P2TR witness for expansion transaction input"
+    );
+  }
+  const inputTapLeafScript = {
+    leafVersion: inputRedeem.redeemVersion,
+    script: inputRedeem.output,
+    controlBlock: p2tr.witness[p2tr.witness.length - 1]
+  };
+  psbt.addInput({
+    hash: txInputs[0].hash,
+    index: txInputs[0].index,
+    sequence: txInputs[0].sequence,
+    witnessUtxo: {
+      script: previousStakingOutput.script,
+      value: previousStakingOutput.value
+    },
+    tapInternalKey: internalPubkey,
+    tapLeafScript: [inputTapLeafScript]
+  });
+  const inputUTXO = findInputUTXO(inputUTXOs, txInputs[1]);
+  const psbtInputData = getPsbtInputFields(inputUTXO, publicKeyNoCoord);
+  psbt.addInput({
+    hash: txInputs[1].hash,
+    index: txInputs[1].index,
+    sequence: txInputs[1].sequence,
+    ...psbtInputData
+  });
+  stakingTx.outs.forEach((o) => {
+    psbt.addOutput({ script: o.script, value: o.value });
+  });
+  return psbt;
+};
 var unbondingPsbt = (scripts, unbondingTx, stakingTx, network) => {
   if (unbondingTx.outs.length !== 1) {
     throw new Error("Unbonding transaction must have exactly one output");
@@ -761,7 +740,14 @@ var StakingScriptData = class {
 };
 
 // src/staking/transactions.ts
-import { Psbt as Psbt2, Transaction as Transaction3, payments as payments5, script as script2, address as address3, opcodes as opcodes3 } from "bitcoinjs-lib";
+import {
+  Psbt as Psbt2,
+  Transaction as Transaction3,
+  payments as payments5,
+  script as script2,
+  address as address3,
+  opcodes as opcodes3
+} from "bitcoinjs-lib";
 
 // src/constants/dustSat.ts
 var BTC_DUST_SAT = 546;
@@ -773,6 +759,7 @@ import { script as bitcoinScript2 } from "bitcoinjs-lib";
 var DEFAULT_INPUT_SIZE = 180;
 var P2WPKH_INPUT_SIZE = 68;
 var P2TR_INPUT_SIZE = 58;
+var P2TR_STAKING_EXPANSION_INPUT_SIZE = 268;
 var TX_BUFFER_SIZE_OVERHEAD = 11;
 var LOW_RATE_ESTIMATION_ACCURACY_BUFFER = 30;
 var MAX_NON_LEGACY_OUTPUT_SIZE = 43;
@@ -853,6 +840,41 @@ var getStakingTxInputUTXOsAndFees = (availableUTXOs, stakingAmount, feeRate, out
     fee: estimatedFee
   };
 };
+var getStakingExpansionTxFundingUTXOAndFees = (availableUTXOs, feeRate, outputs) => {
+  if (availableUTXOs.length === 0) {
+    throw new Error("Insufficient funds");
+  }
+  const validUTXOs = availableUTXOs.filter((utxo) => {
+    const script4 = Buffer.from(utxo.scriptPubKey, "hex");
+    const decompiledScript = bitcoinScript2.decompile(script4);
+    return decompiledScript && decompiledScript.length > 0;
+  });
+  if (validUTXOs.length === 0) {
+    throw new Error("Insufficient funds: no valid UTXOs available for staking");
+  }
+  const sortedUTXOs = validUTXOs.sort((a, b) => a.value - b.value);
+  for (const utxo of sortedUTXOs) {
+    const estimatedSize = getEstimatedSize(
+      [utxo],
+      outputs
+    ) + P2TR_STAKING_EXPANSION_INPUT_SIZE;
+    let estimatedFee = estimatedSize * feeRate + rateBasedTxBufferFee(feeRate);
+    if (utxo.value >= estimatedFee) {
+      if (utxo.value - estimatedFee > BTC_DUST_SAT) {
+        estimatedFee += getEstimatedChangeOutputSize() * feeRate;
+      }
+      if (utxo.value >= estimatedFee) {
+        return {
+          selectedUTXO: utxo,
+          fee: estimatedFee
+        };
+      }
+    }
+  }
+  throw new Error(
+    "Insufficient funds: unable to find a UTXO to cover the fees for the staking expansion transaction."
+  );
+};
 var getWithdrawTxFee = (feeRate) => {
   const inputSize = P2TR_INPUT_SIZE;
   const outputSize = getEstimatedChangeOutputSize();
@@ -931,6 +953,64 @@ function stakingTransaction(scripts, amount, changeAddress, inputUTXOs, network,
     fee
   };
 }
+function stakingExpansionTransaction(network, scripts, amount, changeAddress, feeRate, inputUTXOs, previousStakingTxInfo) {
+  if (amount <= 0 || feeRate <= 0) {
+    throw new Error("Amount and fee rate must be bigger than 0");
+  } else if (!isValidBitcoinAddress(changeAddress, network)) {
+    throw new Error("Invalid BTC change address");
+  }
+  const previousStakingOutputInfo = deriveStakingOutputInfo(
+    previousStakingTxInfo.scripts,
+    network
+  );
+  const previousStakingOutputIndex = findMatchingTxOutputIndex(
+    previousStakingTxInfo.stakingTx,
+    previousStakingOutputInfo.outputAddress,
+    network
+  );
+  const previousStakingAmount = previousStakingTxInfo.stakingTx.outs[previousStakingOutputIndex].value;
+  if (amount !== previousStakingAmount) {
+    throw new Error(
+      "Expansion staking transaction amount must be equal to the previous staking amount. Increase of the staking amount is not supported yet."
+    );
+  }
+  const stakingOutputs = buildStakingTransactionOutputs(
+    scripts,
+    network,
+    amount
+  );
+  const { selectedUTXO, fee } = getStakingExpansionTxFundingUTXOAndFees(
+    inputUTXOs,
+    feeRate,
+    stakingOutputs
+  );
+  const tx = new Transaction3();
+  tx.version = TRANSACTION_VERSION;
+  tx.addInput(
+    previousStakingTxInfo.stakingTx.getHash(),
+    previousStakingOutputIndex,
+    NON_RBF_SEQUENCE
+  );
+  tx.addInput(
+    transactionIdToHash(selectedUTXO.txid),
+    selectedUTXO.vout,
+    NON_RBF_SEQUENCE
+  );
+  stakingOutputs.forEach((o) => {
+    tx.addOutput(o.scriptPubKey, o.value);
+  });
+  if (selectedUTXO.value - fee > BTC_DUST_SAT) {
+    tx.addOutput(
+      address3.toOutputScript(changeAddress, network),
+      selectedUTXO.value - fee
+    );
+  }
+  return {
+    transaction: tx,
+    fee,
+    fundingUTXO: selectedUTXO
+  };
+}
 function withdrawEarlyUnbondedTransaction(scripts, unbondingTx, withdrawalAddress, network, feeRate) {
   const scriptTree = [
     {
@@ -1205,13 +1285,14 @@ var createCovenantWitness = (originalWitness, paramsCovenants, covenantSigs, cov
       `Not enough covenant signatures. Required: ${covenantQuorum}, got: ${covenantSigs.length}`
     );
   }
-  for (const sig of covenantSigs) {
+  const filteredCovenantSigs = covenantSigs.filter((sig) => {
     const btcPkHexBuf = Buffer.from(sig.btcPkHex, "hex");
-    if (!paramsCovenants.some((covenant) => covenant.equals(btcPkHexBuf))) {
-      throw new Error(
-        `Covenant signature public key ${sig.btcPkHex} not found in params covenants`
-      );
-    }
+    return paramsCovenants.some((covenant) => covenant.equals(btcPkHexBuf));
+  });
+  if (filteredCovenantSigs.length < covenantQuorum) {
+    throw new Error(
+      `Not enough valid covenant signatures. Required: ${covenantQuorum}, got: ${filteredCovenantSigs.length}`
+    );
   }
   const covenantSigsBuffers = covenantSigs.slice(0, covenantQuorum).map((sig) => ({
     btcPkHex: Buffer.from(sig.btcPkHex, "hex"),
@@ -1227,12 +1308,202 @@ var createCovenantWitness = (originalWitness, paramsCovenants, covenantSigs, cov
   return [...composedCovenantSigs, ...originalWitness];
 };
 
-// src/staking/index.ts
-var Staking = class {
-  constructor(network, stakerInfo, params, finalityProviderPksNoCoordHex, stakingTimelock) {
-    if (!isValidBitcoinAddress(stakerInfo.address, network)) {
-      throw new StakingError(
-        "INVALID_INPUT" /* INVALID_INPUT */,
+// src/constants/unbonding.ts
+var MIN_UNBONDING_OUTPUT_VALUE = 1e3;
+
+// src/utils/babylon.ts
+import { fromBech32 } from "@cosmjs/encoding";
+var isValidBabylonAddress = (address4) => {
+  try {
+    const { prefix } = fromBech32(address4);
+    return prefix === "bbn";
+  } catch (error) {
+    return false;
+  }
+};
+
+// src/utils/staking/validation.ts
+var validateStakingExpansionInputs = ({
+  babylonBtcTipHeight,
+  inputUTXOs,
+  stakingInput,
+  previousStakingInput,
+  babylonAddress
+}) => {
+  if (babylonBtcTipHeight === 0) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      "Babylon BTC tip height cannot be 0"
+    );
+  }
+  if (!inputUTXOs || inputUTXOs.length === 0) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      "No input UTXOs provided"
+    );
+  }
+  if (babylonAddress && !isValidBabylonAddress(babylonAddress)) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      "Invalid Babylon address"
+    );
+  }
+  if (stakingInput.stakingAmountSat !== previousStakingInput.stakingAmountSat) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      "Staking expansion amount must equal the previous staking amount"
+    );
+  }
+  const currentFPs = stakingInput.finalityProviderPksNoCoordHex;
+  const previousFPs = previousStakingInput.finalityProviderPksNoCoordHex;
+  const missingPreviousFPs = previousFPs.filter((prevFp) => !currentFPs.includes(prevFp));
+  if (missingPreviousFPs.length > 0) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      `Invalid staking expansion: all finality providers from the previous
+      staking must be included. Missing: ${missingPreviousFPs.join(", ")}`
+    );
+  }
+};
+var validateStakingTxInputData = (stakingAmountSat, timelock, params, inputUTXOs, feeRate) => {
+  if (stakingAmountSat < params.minStakingAmountSat || stakingAmountSat > params.maxStakingAmountSat) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      "Invalid staking amount"
+    );
+  }
+  if (timelock < params.minStakingTimeBlocks || timelock > params.maxStakingTimeBlocks) {
+    throw new StakingError("INVALID_INPUT" /* INVALID_INPUT */, "Invalid timelock");
+  }
+  if (inputUTXOs.length == 0) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      "No input UTXOs provided"
+    );
+  }
+  if (feeRate <= 0) {
+    throw new StakingError("INVALID_INPUT" /* INVALID_INPUT */, "Invalid fee rate");
+  }
+};
+var validateParams = (params) => {
+  if (params.covenantNoCoordPks.length == 0) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Could not find any covenant public keys"
+    );
+  }
+  if (params.covenantNoCoordPks.length < params.covenantQuorum) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Covenant public keys must be greater than or equal to the quorum"
+    );
+  }
+  params.covenantNoCoordPks.forEach((pk) => {
+    if (!isValidNoCoordPublicKey(pk)) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Covenant public key should contains no coordinate"
+      );
+    }
+  });
+  if (params.unbondingTime <= 0) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Unbonding time must be greater than 0"
+    );
+  }
+  if (params.unbondingFeeSat <= 0) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Unbonding fee must be greater than 0"
+    );
+  }
+  if (params.maxStakingAmountSat < params.minStakingAmountSat) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Max staking amount must be greater or equal to min staking amount"
+    );
+  }
+  if (params.minStakingAmountSat < params.unbondingFeeSat + MIN_UNBONDING_OUTPUT_VALUE) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      `Min staking amount must be greater than unbonding fee plus ${MIN_UNBONDING_OUTPUT_VALUE}`
+    );
+  }
+  if (params.maxStakingTimeBlocks < params.minStakingTimeBlocks) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Max staking time must be greater or equal to min staking time"
+    );
+  }
+  if (params.minStakingTimeBlocks <= 0) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Min staking time must be greater than 0"
+    );
+  }
+  if (params.covenantQuorum <= 0) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Covenant quorum must be greater than 0"
+    );
+  }
+  if (params.slashing) {
+    if (params.slashing.slashingRate <= 0) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Slashing rate must be greater than 0"
+      );
+    }
+    if (params.slashing.slashingRate > 1) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Slashing rate must be less or equal to 1"
+      );
+    }
+    if (params.slashing.slashingPkScriptHex.length == 0) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Slashing public key script is missing"
+      );
+    }
+    if (params.slashing.minSlashingTxFeeSat <= 0) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Minimum slashing transaction fee must be greater than 0"
+      );
+    }
+  }
+};
+var validateStakingTimelock = (stakingTimelock, params) => {
+  if (stakingTimelock < params.minStakingTimeBlocks || stakingTimelock > params.maxStakingTimeBlocks) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      "Staking transaction timelock is out of range"
+    );
+  }
+};
+var validateStakingExpansionCovenantQuorum = (paramsForPreviousStakingTx, paramsForCurrentStakingTx) => {
+  const previousCovenantMembers = paramsForPreviousStakingTx.covenantNoCoordPks;
+  const currentCovenantMembers = paramsForCurrentStakingTx.covenantNoCoordPks;
+  const requiredQuorum = paramsForPreviousStakingTx.covenantQuorum;
+  const activePreviousMembers = previousCovenantMembers.filter(
+    (prevMember) => currentCovenantMembers.includes(prevMember)
+  ).length;
+  if (activePreviousMembers < requiredQuorum) {
+    throw new StakingError(
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      `Staking expansion failed: insufficient covenant quorum. Required: ${requiredQuorum}, Available: ${activePreviousMembers}. Too many covenant members have rotated out.`
+    );
+  }
+};
+
+// src/staking/index.ts
+var Staking = class _Staking {
+  constructor(network, stakerInfo, params, finalityProviderPksNoCoordHex, stakingTimelock) {
+    if (!isValidBitcoinAddress(stakerInfo.address, network)) {
+      throw new StakingError(
+        "INVALID_INPUT" /* INVALID_INPUT */,
         "Invalid staker bitcoin address"
       );
     }
@@ -1335,6 +1606,81 @@ var Staking = class {
       );
     }
   }
+  /**
+   * Creates a staking expansion transaction that extends an existing BTC stake
+   * to new finality providers or renews the timelock.
+   * 
+   * This method implements RFC 037 BTC Stake Expansion,
+   * allowing existing active BTC staking transactions
+   * to extend their delegation to new finality providers without going through
+   * the full unbonding process.
+   * 
+   * The expansion transaction:
+   * 1. Spends the previous staking transaction output as the first input
+   * 2. Uses funding UTXO as additional input to cover transaction fees or
+   *    to increase the staking amount
+   * 3. Creates a new staking output with expanded finality provider coverage or
+   *    renews the timelock
+   * 4. Has an output returning the remaining funds as change (if any) to the
+   * staker BTC address
+   * 
+   * @param {number} stakingAmountSat - The total staking amount in satoshis
+   * (The amount had to be equal to the previous staking amount for now, this
+   * lib does not yet support increasing the staking amount at this stage)
+   * @param {UTXO[]} inputUTXOs - Available UTXOs to use for funding the
+   * expansion transaction fees. Only one will be selected for the expansion
+   * @param {number} feeRate - Fee rate in satoshis per byte for the 
+   * expansion transaction
+   * @param {StakingParams} paramsForPreviousStakingTx - Staking parameters 
+   * used in the previous staking transaction
+   * @param {Object} previousStakingTxInfo - Necessary information to spend the
+   * previous staking transaction.
+   * @returns {TransactionResult & { fundingUTXO: UTXO }} - An object containing
+   * the unsigned expansion transaction and calculated fee, and the funding UTXO
+   * @throws {StakingError} - If the transaction cannot be built or validation
+   * fails
+   */
+  createStakingExpansionTransaction(stakingAmountSat, inputUTXOs, feeRate, paramsForPreviousStakingTx, previousStakingTxInfo) {
+    validateStakingTxInputData(
+      stakingAmountSat,
+      this.stakingTimelock,
+      this.params,
+      inputUTXOs,
+      feeRate
+    );
+    validateStakingExpansionCovenantQuorum(
+      paramsForPreviousStakingTx,
+      this.params
+    );
+    const previousStaking = new _Staking(
+      this.network,
+      this.stakerInfo,
+      paramsForPreviousStakingTx,
+      previousStakingTxInfo.stakingInput.finalityProviderPksNoCoordHex,
+      previousStakingTxInfo.stakingInput.stakingTimelock
+    );
+    const {
+      transaction: stakingExpansionTx,
+      fee: stakingExpansionTxFee,
+      fundingUTXO
+    } = stakingExpansionTransaction(
+      this.network,
+      this.buildScripts(),
+      stakingAmountSat,
+      this.stakerInfo.address,
+      feeRate,
+      inputUTXOs,
+      {
+        stakingTx: previousStakingTxInfo.stakingTx,
+        scripts: previousStaking.buildScripts()
+      }
+    );
+    return {
+      transaction: stakingExpansionTx,
+      fee: stakingExpansionTxFee,
+      fundingUTXO
+    };
+  }
   /**
    * Create a staking psbt based on the existing staking transaction.
    *
@@ -1359,6 +1705,48 @@ var Staking = class {
       isTaproot(this.stakerInfo.address, this.network) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : void 0
     );
   }
+  /**
+   * Convert a staking expansion transaction to a PSBT.
+   *
+   * @param {Transaction} stakingExpansionTx - The staking expansion
+   * transaction to convert
+   * @param {UTXO[]} inputUTXOs - Available UTXOs for the
+   * funding input (second input)
+   * @param {StakingParams} paramsForPreviousStakingTx - Staking parameters
+   * used for the previous staking transaction
+   * @param {Object} previousStakingTxInfo - Information about the previous
+   * staking transaction
+   * @returns {Psbt} The PSBT for the staking expansion transaction
+   * @throws {Error} If the previous staking output cannot be found or
+   * validation fails
+   */
+  toStakingExpansionPsbt(stakingExpansionTx, inputUTXOs, paramsForPreviousStakingTx, previousStakingTxInfo) {
+    const previousStaking = new _Staking(
+      this.network,
+      this.stakerInfo,
+      paramsForPreviousStakingTx,
+      previousStakingTxInfo.stakingInput.finalityProviderPksNoCoordHex,
+      previousStakingTxInfo.stakingInput.stakingTimelock
+    );
+    const previousScripts = previousStaking.buildScripts();
+    const { outputAddress } = deriveStakingOutputInfo(previousScripts, this.network);
+    const previousStakingOutputIndex = findMatchingTxOutputIndex(
+      previousStakingTxInfo.stakingTx,
+      outputAddress,
+      this.network
+    );
+    return stakingExpansionPsbt(
+      this.network,
+      stakingExpansionTx,
+      {
+        stakingTx: previousStakingTxInfo.stakingTx,
+        outputIndex: previousStakingOutputIndex
+      },
+      inputUTXOs,
+      previousScripts,
+      isTaproot(this.stakerInfo.address, this.network) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : void 0
+    );
+  }
   /**
    * Create an unbonding transaction for staking.
    *
@@ -1593,20 +1981,17 @@ var Staking = class {
 };
 
 // src/staking/manager.ts
-import {
-  btccheckpoint,
-  btcstaking,
-  btcstakingtx
-} from "@babylonlabs-io/babylon-proto-ts";
+import { btccheckpoint, btcstaking, btcstakingtx } from "@babylonlabs-io/babylon-proto-ts";
 import {
   BIP322Sig,
   BTCSigType
 } from "@babylonlabs-io/babylon-proto-ts/dist/generated/babylon/btcstaking/v1/pop";
-import { Psbt as Psbt3 } from "bitcoinjs-lib";
+import { Psbt as Psbt3, Transaction as Transaction4 } from "bitcoinjs-lib";
 
 // src/constants/registry.ts
 var BABYLON_REGISTRY_TYPE_URLS = {
-  MsgCreateBTCDelegation: "/babylon.btcstaking.v1.MsgCreateBTCDelegation"
+  MsgCreateBTCDelegation: "/babylon.btcstaking.v1.MsgCreateBTCDelegation",
+  MsgBtcStakeExpand: "/babylon.btcstaking.v1.MsgBtcStakeExpand"
 };
 
 // src/utils/index.ts
@@ -1622,16 +2007,24 @@ var reverseBuffer = (buffer) => {
   return clonedBuffer;
 };
 
-// src/utils/babylon.ts
-import { fromBech32 } from "@cosmjs/encoding";
-var isValidBabylonAddress = (address4) => {
-  try {
-    const { prefix } = fromBech32(address4);
-    return prefix === "bbn";
-  } catch (error) {
-    return false;
+// src/utils/pop.ts
+import { sha256 } from "bitcoinjs-lib/src/crypto";
+
+// src/constants/staking.ts
+var STAKING_MODULE_ADDRESS = "bbn13837feaxn8t0zvwcjwhw7lhpgdcx4s36eqteah";
+
+// src/utils/pop.ts
+function createStakerPopContext(chainId, popContextVersion = 0) {
+  const contextString = `btcstaking/${popContextVersion}/staker_pop/${chainId}/${STAKING_MODULE_ADDRESS}`;
+  return sha256(Buffer.from(contextString, "utf8")).toString("hex");
+}
+function buildPopMessage(bech32Address, currentHeight, chainId, upgradeConfig) {
+  if (chainId !== void 0 && upgradeConfig?.upgradeHeight !== void 0 && upgradeConfig.version !== void 0 && currentHeight !== void 0 && currentHeight >= upgradeConfig.upgradeHeight) {
+    const contextHash = createStakerPopContext(chainId, upgradeConfig.version);
+    return contextHash + bech32Address;
   }
-};
+  return bech32Address;
+}
 
 // src/utils/staking/param.ts
 var getBabylonParamByBtcHeight = (height, babylonParamsVersions) => {
@@ -1654,7 +2047,7 @@ var getBabylonParamByVersion = (version, babylonParams) => {
 
 // src/staking/manager.ts
 var BabylonBtcStakingManager = class {
-  constructor(network, stakingParams, btcProvider, babylonProvider, ee) {
+  constructor(network, stakingParams, btcProvider, babylonProvider, ee, upgradeConfig) {
     this.network = network;
     this.stakingParams = stakingParams;
     this.btcProvider = btcProvider;
@@ -1665,6 +2058,7 @@ var BabylonBtcStakingManager = class {
       throw new Error("No staking parameters provided");
     }
     this.stakingParams = stakingParams;
+    this.upgradeConfig = upgradeConfig;
   }
   /**
    * Creates a signed Pre-Staking Registration transaction that is ready to be
@@ -1692,10 +2086,7 @@ var BabylonBtcStakingManager = class {
     if (!isValidBabylonAddress(babylonAddress)) {
       throw new Error("Invalid Babylon address");
     }
-    const params = getBabylonParamByBtcHeight(
-      babylonBtcTipHeight,
-      this.stakingParams
-    );
+    const params = getBabylonParamByBtcHeight(babylonBtcTipHeight, this.stakingParams);
     const staking = new Staking(
       this.network,
       stakerBtcInfo,
@@ -1703,11 +2094,7 @@ var BabylonBtcStakingManager = class {
       stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { transaction } = staking.createStakingTransaction(
-      stakingInput.stakingAmountSat,
-      inputUTXOs,
-      feeRate
-    );
+    const { transaction } = staking.createStakingTransaction(stakingInput.stakingAmountSat, inputUTXOs, feeRate);
     const msg = await this.createBtcDelegationMsg(
       "delegation:create",
       staking,
@@ -1725,6 +2112,110 @@ var BabylonBtcStakingManager = class {
       stakingTx: transaction
     };
   }
+  /**
+   * Create a signed staking expansion transaction that is ready to be sent to
+   * the Babylon chain.
+   */
+  async stakingExpansionRegistrationBabylonTransaction(stakerBtcInfo, stakingInput, babylonBtcTipHeight, inputUTXOs, feeRate, babylonAddress, previousStakingTxInfo) {
+    validateStakingExpansionInputs({
+      babylonBtcTipHeight,
+      inputUTXOs,
+      stakingInput,
+      previousStakingInput: previousStakingTxInfo.stakingInput,
+      babylonAddress
+    });
+    const params = getBabylonParamByBtcHeight(babylonBtcTipHeight, this.stakingParams);
+    const paramsForPreviousStakingTx = getBabylonParamByVersion(previousStakingTxInfo.paramVersion, this.stakingParams);
+    const stakingInstance = new Staking(
+      this.network,
+      stakerBtcInfo,
+      params,
+      stakingInput.finalityProviderPksNoCoordHex,
+      stakingInput.stakingTimelock
+    );
+    const { transaction: stakingExpansionTx, fundingUTXO } = stakingInstance.createStakingExpansionTransaction(
+      stakingInput.stakingAmountSat,
+      inputUTXOs,
+      feeRate,
+      paramsForPreviousStakingTx,
+      previousStakingTxInfo
+    );
+    let fundingTx;
+    try {
+      fundingTx = await this.btcProvider.getTransactionHex(fundingUTXO.txid);
+    } catch (error) {
+      throw StakingError.fromUnknown(
+        error,
+        "INVALID_INPUT" /* INVALID_INPUT */,
+        "Failed to retrieve funding transaction hex"
+      );
+    }
+    const msg = await this.createBtcDelegationMsg(
+      "delegation:expand",
+      stakingInstance,
+      stakingInput,
+      stakingExpansionTx,
+      babylonAddress,
+      stakerBtcInfo,
+      params,
+      {
+        delegationExpansionInfo: {
+          previousStakingTx: previousStakingTxInfo.stakingTx,
+          fundingTx: Transaction4.fromHex(fundingTx)
+        }
+      }
+    );
+    this.ee?.emit("delegation:expand", {
+      type: "create-btc-delegation-msg"
+    });
+    return {
+      signedBabylonTx: await this.babylonProvider.signTransaction(msg),
+      stakingTx: stakingExpansionTx
+    };
+  }
+  /**
+   * Estimates the transaction fee for a BTC staking expansion transaction.
+   *
+   * @param {StakerInfo} stakerBtcInfo - The staker's Bitcoin information
+   * including address and public key
+   * @param {number} babylonBtcTipHeight - The current Babylon BTC tip height
+   * used to determine staking parameters
+   * @param {StakingInputs} stakingInput - The new staking input parameters for
+   * the expansion
+   * @param {UTXO[]} inputUTXOs - Available UTXOs that can be used for funding
+   * the expansion transaction
+   * @param {number} feeRate - Fee rate in satoshis per byte for the expansion
+   * transaction
+   * @param {Object} previousStakingTxInfo - Information about the previous
+   * staking transaction being expanded
+   * @returns {number} - The estimated transaction fee in satoshis
+   * @throws {Error} - If validation fails or the fee cannot be calculated
+   */
+  estimateBtcStakingExpansionFee(stakerBtcInfo, babylonBtcTipHeight, stakingInput, inputUTXOs, feeRate, previousStakingTxInfo) {
+    validateStakingExpansionInputs({
+      babylonBtcTipHeight,
+      inputUTXOs,
+      stakingInput,
+      previousStakingInput: previousStakingTxInfo.stakingInput
+    });
+    const params = getBabylonParamByBtcHeight(babylonBtcTipHeight, this.stakingParams);
+    const paramsForPreviousStakingTx = getBabylonParamByVersion(previousStakingTxInfo.paramVersion, this.stakingParams);
+    const stakingInstance = new Staking(
+      this.network,
+      stakerBtcInfo,
+      params,
+      stakingInput.finalityProviderPksNoCoordHex,
+      stakingInput.stakingTimelock
+    );
+    const { fee } = stakingInstance.createStakingExpansionTransaction(
+      stakingInput.stakingAmountSat,
+      inputUTXOs,
+      feeRate,
+      paramsForPreviousStakingTx,
+      previousStakingTxInfo
+    );
+    return fee;
+  }
   /**
    * Creates a signed post-staking registration transaction that is ready to be
    * sent to the Babylon chain. This is used when a staking transaction is
@@ -1742,10 +2233,7 @@ var BabylonBtcStakingManager = class {
    * @returns The signed babylon transaction in base64 format.
    */
   async postStakeRegistrationBabylonTransaction(stakerBtcInfo, stakingTx, stakingTxHeight, stakingInput, inclusionProof, babylonAddress) {
-    const params = getBabylonParamByBtcHeight(
-      stakingTxHeight,
-      this.stakingParams
-    );
+    const params = getBabylonParamByBtcHeight(stakingTxHeight, this.stakingParams);
     if (!isValidBabylonAddress(babylonAddress)) {
       throw new Error("Invalid Babylon address");
     }
@@ -1758,11 +2246,7 @@ var BabylonBtcStakingManager = class {
     );
     const scripts = stakingInstance.buildScripts();
     const stakingOutputInfo = deriveStakingOutputInfo(scripts, this.network);
-    findMatchingTxOutputIndex(
-      stakingTx,
-      stakingOutputInfo.outputAddress,
-      this.network
-    );
+    findMatchingTxOutputIndex(stakingTx, stakingOutputInfo.outputAddress, this.network);
     const delegationMsg = await this.createBtcDelegationMsg(
       "delegation:register",
       stakingInstance,
@@ -1771,7 +2255,9 @@ var BabylonBtcStakingManager = class {
       babylonAddress,
       stakerBtcInfo,
       params,
-      this.getInclusionProof(inclusionProof)
+      {
+        inclusionProof: this.getInclusionProof(inclusionProof)
+      }
     );
     this.ee?.emit("delegation:register", {
       type: "create-btc-delegation-msg"
@@ -1798,10 +2284,7 @@ var BabylonBtcStakingManager = class {
     if (babylonBtcTipHeight === 0) {
       throw new Error("Babylon BTC tip height cannot be 0");
     }
-    const params = getBabylonParamByBtcHeight(
-      babylonBtcTipHeight,
-      this.stakingParams
-    );
+    const params = getBabylonParamByBtcHeight(babylonBtcTipHeight, this.stakingParams);
     const staking = new Staking(
       this.network,
       stakerBtcInfo,
@@ -1809,11 +2292,7 @@ var BabylonBtcStakingManager = class {
       stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { fee: stakingFee } = staking.createStakingTransaction(
-      stakingInput.stakingAmountSat,
-      inputUTXOs,
-      feeRate
-    );
+    const { fee: stakingFee } = staking.createStakingTransaction(stakingInput.stakingAmountSat, inputUTXOs, feeRate);
     return stakingFee;
   }
   /**
@@ -1830,10 +2309,7 @@ var BabylonBtcStakingManager = class {
    * @returns The signed staking transaction.
    */
   async createSignedBtcStakingTransaction(stakerBtcInfo, stakingInput, unsignedStakingTx, inputUTXOs, stakingParamsVersion) {
-    const params = getBabylonParamByVersion(
-      stakingParamsVersion,
-      this.stakingParams
-    );
+    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
     if (inputUTXOs.length === 0) {
       throw new Error("No input UTXOs provided");
     }
@@ -1867,16 +2343,103 @@ var BabylonBtcStakingManager = class {
       stakingDuration: stakingInput.stakingTimelock,
       type: "staking"
     });
-    const signedStakingPsbtHex = await this.btcProvider.signPsbt(
-      stakingPsbt2.toHex(),
+    const signedStakingPsbtHex = await this.btcProvider.signPsbt(stakingPsbt2.toHex(), {
+      contracts,
+      action: {
+        name: "sign-btc-staking-transaction" /* SIGN_BTC_STAKING_TRANSACTION */
+      }
+    });
+    return Psbt3.fromHex(signedStakingPsbtHex).extractTransaction();
+  }
+  /**
+   * Creates a signed staking expansion transaction that is ready to be sent to
+   * the BTC network.
+   *
+   * @param {StakerInfo} stakerBtcInfo - The staker's BTC information including
+   * address and public key
+   * @param {StakingInputs} stakingInput - The staking inputs for the expansion
+   * @param {Transaction} unsignedStakingExpansionTx - The unsigned staking
+   * expansion transaction
+   * @param {UTXO[]} inputUTXOs - Available UTXOs for the funding input
+   * @param {number} stakingParamsVersion - The version of staking parameters
+   * that was used when registering the staking expansion delegation.
+   * @param {Object} previousStakingTxInfo - Information about the previous
+   * staking transaction
+   * @param {Array} covenantStakingExpansionSignatures - Covenant committee
+   * signatures for the expansion
+   * @returns {Promise<Transaction>} The fully signed staking expansion
+   * transaction
+   * @throws {Error} If signing fails, validation fails, or required data is
+   * missing
+   */
+  async createSignedBtcStakingExpansionTransaction(stakerBtcInfo, stakingInput, unsignedStakingExpansionTx, inputUTXOs, stakingParamsVersion, previousStakingTxInfo, covenantStakingExpansionSignatures) {
+    validateStakingExpansionInputs({
+      inputUTXOs,
+      stakingInput,
+      previousStakingInput: previousStakingTxInfo.stakingInput
+    });
+    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
+    if (inputUTXOs.length === 0) {
+      throw new Error("No input UTXOs provided");
+    }
+    const staking = new Staking(
+      this.network,
+      stakerBtcInfo,
+      params,
+      stakingInput.finalityProviderPksNoCoordHex,
+      stakingInput.stakingTimelock
+    );
+    const previousParams = getBabylonParamByVersion(previousStakingTxInfo.paramVersion, this.stakingParams);
+    const stakingExpansionPsbt2 = staking.toStakingExpansionPsbt(
+      unsignedStakingExpansionTx,
+      inputUTXOs,
+      previousParams,
+      previousStakingTxInfo
+    );
+    const contracts = [
       {
-        contracts,
-        action: {
-          name: "sign-btc-staking-transaction" /* SIGN_BTC_STAKING_TRANSACTION */
+        id: "babylon:staking" /* STAKING */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+          covenantPks: params.covenantNoCoordPks,
+          covenantThreshold: params.covenantQuorum,
+          minUnbondingTime: params.unbondingTime,
+          stakingDuration: stakingInput.stakingTimelock
         }
       }
+    ];
+    this.ee?.emit("delegation:stake", {
+      stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+      finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+      covenantPks: params.covenantNoCoordPks,
+      covenantThreshold: params.covenantQuorum,
+      unbondingTimeBlocks: params.unbondingTime,
+      stakingDuration: stakingInput.stakingTimelock,
+      type: "staking"
+    });
+    const signedStakingPsbtHex = await this.btcProvider.signPsbt(stakingExpansionPsbt2.toHex(), {
+      contracts,
+      action: {
+        name: "sign-btc-staking-transaction" /* SIGN_BTC_STAKING_TRANSACTION */
+      }
+    });
+    const signedStakingExpansionTx = Psbt3.fromHex(signedStakingPsbtHex).extractTransaction();
+    if (signedStakingExpansionTx.getId() !== unsignedStakingExpansionTx.getId()) {
+      throw new Error("Staking expansion transaction hash does not match the computed hash");
+    }
+    const covenantBuffers = previousParams.covenantNoCoordPks.map((covenant) => Buffer.from(covenant, "hex"));
+    const witness = createCovenantWitness(
+      // The first input of the staking expansion transaction is the previous
+      // staking output. We will attach the covenant signatures to this input
+      // to unbond the previousstaking output.
+      signedStakingExpansionTx.ins[0].witness,
+      covenantBuffers,
+      covenantStakingExpansionSignatures,
+      previousParams.covenantQuorum
     );
-    return Psbt3.fromHex(signedStakingPsbtHex).extractTransaction();
+    signedStakingExpansionTx.ins[0].witness = witness;
+    return signedStakingExpansionTx;
   }
   /**
    * Creates a partial signed unbonding transaction that is only signed by the
@@ -1893,10 +2456,7 @@ var BabylonBtcStakingManager = class {
    * @returns The partial signed unbonding transaction and its fee.
    */
   async createPartialSignedBtcUnbondingTransaction(stakerBtcInfo, stakingInput, stakingParamsVersion, stakingTx) {
-    const params = getBabylonParamByVersion(
-      stakingParamsVersion,
-      this.stakingParams
-    );
+    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
     const staking = new Staking(
       this.network,
       stakerBtcInfo,
@@ -1940,18 +2500,13 @@ var BabylonBtcStakingManager = class {
       unbondingFeeSat: params.unbondingFeeSat,
       type: "unbonding"
     });
-    const signedUnbondingPsbtHex = await this.btcProvider.signPsbt(
-      psbt.toHex(),
-      {
-        contracts,
-        action: {
-          name: "sign-btc-unbonding-transaction" /* SIGN_BTC_UNBONDING_TRANSACTION */
-        }
+    const signedUnbondingPsbtHex = await this.btcProvider.signPsbt(psbt.toHex(), {
+      contracts,
+      action: {
+        name: "sign-btc-unbonding-transaction" /* SIGN_BTC_UNBONDING_TRANSACTION */
       }
-    );
-    const signedUnbondingTx = Psbt3.fromHex(
-      signedUnbondingPsbtHex
-    ).extractTransaction();
+    });
+    const signedUnbondingTx = Psbt3.fromHex(signedUnbondingPsbtHex).extractTransaction();
     return {
       transaction: signedUnbondingTx,
       fee
@@ -1972,10 +2527,7 @@ var BabylonBtcStakingManager = class {
    * @returns The signed unbonding transaction and its fee.
    */
   async createSignedBtcUnbondingTransaction(stakerBtcInfo, stakingInput, stakingParamsVersion, stakingTx, unsignedUnbondingTx, covenantUnbondingSignatures) {
-    const params = getBabylonParamByVersion(
-      stakingParamsVersion,
-      this.stakingParams
-    );
+    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
     const { transaction: signedUnbondingTx, fee } = await this.createPartialSignedBtcUnbondingTransaction(
       stakerBtcInfo,
       stakingInput,
@@ -1983,13 +2535,9 @@ var BabylonBtcStakingManager = class {
       stakingTx
     );
     if (signedUnbondingTx.getId() !== unsignedUnbondingTx.getId()) {
-      throw new Error(
-        "Unbonding transaction hash does not match the computed hash"
-      );
+      throw new Error("Unbonding transaction hash does not match the computed hash");
     }
-    const covenantBuffers = params.covenantNoCoordPks.map(
-      (covenant) => Buffer.from(covenant, "hex")
-    );
+    const covenantBuffers = params.covenantNoCoordPks.map((covenant) => Buffer.from(covenant, "hex"));
     const witness = createCovenantWitness(
       // Since unbonding transactions always have a single input and output,
       // we expect exactly one signature in TaprootScriptSpendSig when the
@@ -2018,10 +2566,7 @@ var BabylonBtcStakingManager = class {
    * @returns The signed withdrawal transaction and its fee.
    */
   async createSignedBtcWithdrawEarlyUnbondedTransaction(stakerBtcInfo, stakingInput, stakingParamsVersion, earlyUnbondingTx, feeRate) {
-    const params = getBabylonParamByVersion(
-      stakingParamsVersion,
-      this.stakingParams
-    );
+    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
     const staking = new Staking(
       this.network,
       stakerBtcInfo,
@@ -2044,15 +2589,12 @@ var BabylonBtcStakingManager = class {
       timelockBlocks: params.unbondingTime,
       type: "early-unbonded"
     });
-    const signedWithdrawalPsbtHex = await this.btcProvider.signPsbt(
-      unbondingPsbt2.toHex(),
-      {
-        contracts,
-        action: {
-          name: "sign-btc-withdraw-transaction" /* SIGN_BTC_WITHDRAW_TRANSACTION */
-        }
+    const signedWithdrawalPsbtHex = await this.btcProvider.signPsbt(unbondingPsbt2.toHex(), {
+      contracts,
+      action: {
+        name: "sign-btc-withdraw-transaction" /* SIGN_BTC_WITHDRAW_TRANSACTION */
       }
-    );
+    });
     return {
       transaction: Psbt3.fromHex(signedWithdrawalPsbtHex).extractTransaction(),
       fee
@@ -2073,10 +2615,7 @@ var BabylonBtcStakingManager = class {
    * @returns The signed withdrawal transaction and its fee.
    */
   async createSignedBtcWithdrawStakingExpiredTransaction(stakerBtcInfo, stakingInput, stakingParamsVersion, stakingTx, feeRate) {
-    const params = getBabylonParamByVersion(
-      stakingParamsVersion,
-      this.stakingParams
-    );
+    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
     const staking = new Staking(
       this.network,
       stakerBtcInfo,
@@ -2084,10 +2623,7 @@ var BabylonBtcStakingManager = class {
       stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { psbt, fee } = staking.createWithdrawStakingExpiredPsbt(
-      stakingTx,
-      feeRate
-    );
+    const { psbt, fee } = staking.createWithdrawStakingExpiredPsbt(stakingTx, feeRate);
     const contracts = [
       {
         id: "babylon:withdraw" /* WITHDRAW */,
@@ -2102,15 +2638,12 @@ var BabylonBtcStakingManager = class {
       timelockBlocks: stakingInput.stakingTimelock,
       type: "staking-expired"
     });
-    const signedWithdrawalPsbtHex = await this.btcProvider.signPsbt(
-      psbt.toHex(),
-      {
-        contracts,
-        action: {
-          name: "sign-btc-withdraw-transaction" /* SIGN_BTC_WITHDRAW_TRANSACTION */
-        }
+    const signedWithdrawalPsbtHex = await this.btcProvider.signPsbt(psbt.toHex(), {
+      contracts,
+      action: {
+        name: "sign-btc-withdraw-transaction" /* SIGN_BTC_WITHDRAW_TRANSACTION */
       }
-    );
+    });
     return {
       transaction: Psbt3.fromHex(signedWithdrawalPsbtHex).extractTransaction(),
       fee
@@ -2131,10 +2664,7 @@ var BabylonBtcStakingManager = class {
    * @returns The signed withdrawal transaction and its fee.
    */
   async createSignedBtcWithdrawSlashingTransaction(stakerBtcInfo, stakingInput, stakingParamsVersion, slashingTx, feeRate) {
-    const params = getBabylonParamByVersion(
-      stakingParamsVersion,
-      this.stakingParams
-    );
+    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
     const staking = new Staking(
       this.network,
       stakerBtcInfo,
@@ -2142,10 +2672,7 @@ var BabylonBtcStakingManager = class {
       stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { psbt, fee } = staking.createWithdrawSlashingPsbt(
-      slashingTx,
-      feeRate
-    );
+    const { psbt, fee } = staking.createWithdrawSlashingPsbt(slashingTx, feeRate);
     const contracts = [
       {
         id: "babylon:withdraw" /* WITHDRAW */,
@@ -2160,19 +2687,14 @@ var BabylonBtcStakingManager = class {
       timelockBlocks: params.unbondingTime,
       type: "slashing"
     });
-    const signedWithrawSlashingPsbtHex = await this.btcProvider.signPsbt(
-      psbt.toHex(),
-      {
-        contracts,
-        action: {
-          name: "sign-btc-withdraw-transaction" /* SIGN_BTC_WITHDRAW_TRANSACTION */
-        }
+    const signedWithrawSlashingPsbtHex = await this.btcProvider.signPsbt(psbt.toHex(), {
+      contracts,
+      action: {
+        name: "sign-btc-withdraw-transaction" /* SIGN_BTC_WITHDRAW_TRANSACTION */
       }
-    );
+    });
     return {
-      transaction: Psbt3.fromHex(
-        signedWithrawSlashingPsbtHex
-      ).extractTransaction(),
+      transaction: Psbt3.fromHex(signedWithrawSlashingPsbtHex).extractTransaction(),
       fee
     };
   }
@@ -2186,12 +2708,26 @@ var BabylonBtcStakingManager = class {
     if (isTaproot(stakerBtcAddress, this.network) || isNativeSegwit(stakerBtcAddress, this.network)) {
       sigType = BTCSigType.BIP322;
     }
-    this.ee?.emit(channel, {
+    const [chainId, babyTipHeight] = await Promise.all([
+      this.babylonProvider.getChainId?.(),
+      this.babylonProvider.getCurrentHeight?.()
+    ]);
+    const upgradeConfig = this.upgradeConfig?.pop;
+    const messageToSign = buildPopMessage(
       bech32Address,
+      babyTipHeight,
+      chainId,
+      upgradeConfig && {
+        upgradeHeight: upgradeConfig.upgradeHeight,
+        version: upgradeConfig.version
+      }
+    );
+    this.ee?.emit(channel, {
+      messageToSign,
       type: "proof-of-possession"
     });
     const signedBabylonAddress = await this.btcProvider.signMessage(
-      bech32Address,
+      messageToSign,
       sigType === BTCSigType.BIP322 ? "bip322-simple" : "ecdsa"
     );
     let btcSig;
@@ -2237,10 +2773,14 @@ var BabylonBtcStakingManager = class {
    * @param stakerBtcInfo - The staker's BTC information such as address and
    * public key
    * @param params - The staking parameters.
-   * @param inclusionProof - The inclusion proof of the staking transaction.
+   * @param options - The options for the BTC delegation.
+   * @param options.inclusionProof - The inclusion proof of the staking
+   * transaction.
+   * @param options.delegationExpansionInfo - The information for the BTC
+   * delegation expansion.
    * @returns The protobuf message.
    */
-  async createBtcDelegationMsg(channel, stakingInstance, stakingInput, stakingTx, bech32Address, stakerBtcInfo, params, inclusionProof) {
+  async createBtcDelegationMsg(channel, stakingInstance, stakingInput, stakingTx, bech32Address, stakerBtcInfo, params, options) {
     if (!params.slashing) {
       throw new StakingError(
         "INVALID_PARAMS" /* INVALID_PARAMS */,
@@ -2290,18 +2830,13 @@ var BabylonBtcStakingManager = class {
       slashingPkScriptHex: params.slashing.slashingPkScriptHex,
       type: "staking-slashing"
     });
-    const signedSlashingPsbtHex = await this.btcProvider.signPsbt(
-      slashingPsbt.toHex(),
-      {
-        contracts: slashingContracts,
-        action: {
-          name: "sign-btc-slashing-transaction" /* SIGN_BTC_SLASHING_TRANSACTION */
-        }
+    const signedSlashingPsbtHex = await this.btcProvider.signPsbt(slashingPsbt.toHex(), {
+      contracts: slashingContracts,
+      action: {
+        name: "sign-btc-slashing-transaction" /* SIGN_BTC_SLASHING_TRANSACTION */
       }
-    );
-    const signedSlashingTx = Psbt3.fromHex(
-      signedSlashingPsbtHex
-    ).extractTransaction();
+    });
+    const signedSlashingTx = Psbt3.fromHex(signedSlashingPsbtHex).extractTransaction();
     const slashingSig = extractFirstSchnorrSignatureFromTransaction(signedSlashingTx);
     if (!slashingSig) {
       throw new Error("No signature found in the staking output slashing PSBT");
@@ -2345,58 +2880,49 @@ var BabylonBtcStakingManager = class {
       slashingPkScriptHex: params.slashing.slashingPkScriptHex,
       type: "unbonding-slashing"
     });
-    const signedUnbondingSlashingPsbtHex = await this.btcProvider.signPsbt(
-      unbondingSlashingPsbt.toHex(),
-      {
-        contracts: unbondingSlashingContracts,
-        action: {
-          name: "sign-btc-unbonding-slashing-transaction" /* SIGN_BTC_UNBONDING_SLASHING_TRANSACTION */
-        }
+    const signedUnbondingSlashingPsbtHex = await this.btcProvider.signPsbt(unbondingSlashingPsbt.toHex(), {
+      contracts: unbondingSlashingContracts,
+      action: {
+        name: "sign-btc-unbonding-slashing-transaction" /* SIGN_BTC_UNBONDING_SLASHING_TRANSACTION */
       }
-    );
-    const signedUnbondingSlashingTx = Psbt3.fromHex(
-      signedUnbondingSlashingPsbtHex
-    ).extractTransaction();
-    const unbondingSignatures = extractFirstSchnorrSignatureFromTransaction(
-      signedUnbondingSlashingTx
-    );
+    });
+    const signedUnbondingSlashingTx = Psbt3.fromHex(signedUnbondingSlashingPsbtHex).extractTransaction();
+    const unbondingSignatures = extractFirstSchnorrSignatureFromTransaction(signedUnbondingSlashingTx);
     if (!unbondingSignatures) {
-      throw new Error(
-        "No signature found in the unbonding output slashing PSBT"
-      );
+      throw new Error("No signature found in the unbonding output slashing PSBT");
     }
-    const proofOfPossession = await this.createProofOfPossession(
-      channel,
-      bech32Address,
-      stakerBtcInfo.address
-    );
-    const msg = btcstakingtx.MsgCreateBTCDelegation.fromPartial({
+    const proofOfPossession = await this.createProofOfPossession(channel, bech32Address, stakerBtcInfo.address);
+    const commonMsg = {
       stakerAddr: bech32Address,
       pop: proofOfPossession,
-      btcPk: Uint8Array.from(
-        Buffer.from(stakerBtcInfo.publicKeyNoCoordHex, "hex")
-      ),
-      fpBtcPkList: stakingInput.finalityProviderPksNoCoordHex.map(
-        (pk) => Uint8Array.from(Buffer.from(pk, "hex"))
-      ),
+      btcPk: Uint8Array.from(Buffer.from(stakerBtcInfo.publicKeyNoCoordHex, "hex")),
+      fpBtcPkList: stakingInput.finalityProviderPksNoCoordHex.map((pk) => Uint8Array.from(Buffer.from(pk, "hex"))),
       stakingTime: stakingInput.stakingTimelock,
       stakingValue: stakingInput.stakingAmountSat,
       stakingTx: Uint8Array.from(stakingTx.toBuffer()),
-      slashingTx: Uint8Array.from(
-        Buffer.from(clearTxSignatures(signedSlashingTx).toHex(), "hex")
-      ),
+      slashingTx: Uint8Array.from(Buffer.from(clearTxSignatures(signedSlashingTx).toHex(), "hex")),
       delegatorSlashingSig: Uint8Array.from(slashingSig),
       unbondingTime: params.unbondingTime,
       unbondingTx: Uint8Array.from(unbondingTx.toBuffer()),
       unbondingValue: stakingInput.stakingAmountSat - params.unbondingFeeSat,
-      unbondingSlashingTx: Uint8Array.from(
-        Buffer.from(
-          clearTxSignatures(signedUnbondingSlashingTx).toHex(),
-          "hex"
-        )
-      ),
-      delegatorUnbondingSlashingSig: Uint8Array.from(unbondingSignatures),
-      stakingTxInclusionProof: inclusionProof
+      unbondingSlashingTx: Uint8Array.from(Buffer.from(clearTxSignatures(signedUnbondingSlashingTx).toHex(), "hex")),
+      delegatorUnbondingSlashingSig: Uint8Array.from(unbondingSignatures)
+    };
+    if (options?.delegationExpansionInfo) {
+      const fundingTx = Uint8Array.from(options.delegationExpansionInfo.fundingTx.toBuffer());
+      const msg2 = btcstakingtx.MsgBtcStakeExpand.fromPartial({
+        ...commonMsg,
+        previousStakingTxHash: options.delegationExpansionInfo.previousStakingTx.getId(),
+        fundingTx
+      });
+      return {
+        typeUrl: BABYLON_REGISTRY_TYPE_URLS.MsgBtcStakeExpand,
+        value: msg2
+      };
+    }
+    const msg = btcstakingtx.MsgCreateBTCDelegation.fromPartial({
+      ...commonMsg,
+      stakingTxInclusionProof: options?.inclusionProof
     });
     return {
       typeUrl: BABYLON_REGISTRY_TYPE_URLS.MsgCreateBTCDelegation,
@@ -2412,9 +2938,7 @@ var BabylonBtcStakingManager = class {
   getInclusionProof(inclusionProof) {
     const { pos, merkle, blockHashHex } = inclusionProof;
     const proofHex = deriveMerkleProof(merkle);
-    const hash = reverseBuffer(
-      Uint8Array.from(Buffer.from(blockHashHex, "hex"))
-    );
+    const hash = reverseBuffer(Uint8Array.from(Buffer.from(blockHashHex, "hex")));
     const inclusionProofKey = btccheckpoint.TransactionKey.fromPartial({
       index: pos,
       hash
@@ -2425,39 +2949,11 @@ var BabylonBtcStakingManager = class {
     });
   }
 };
-var extractFirstSchnorrSignatureFromTransaction = (singedTransaction) => {
-  for (const input of singedTransaction.ins) {
-    if (input.witness && input.witness.length > 0) {
-      const schnorrSignature = input.witness[0];
-      if (schnorrSignature.length === 64) {
-        return schnorrSignature;
-      }
-    }
-  }
-  return void 0;
-};
-var clearTxSignatures = (tx) => {
-  tx.ins.forEach((input) => {
-    input.script = Buffer.alloc(0);
-    input.witness = [];
-  });
-  return tx;
-};
-var deriveMerkleProof = (merkle) => {
-  const proofHex = merkle.reduce((acc, m) => {
-    return acc + Buffer.from(m, "hex").reverse().toString("hex");
-  }, "");
-  return proofHex;
-};
 var getUnbondingTxStakerSignature = (unbondingTx) => {
   try {
     return unbondingTx.ins[0].witness[0].toString("hex");
   } catch (error) {
-    throw StakingError.fromUnknown(
-      error,
-      "INVALID_INPUT" /* INVALID_INPUT */,
-      "Failed to get staker signature"
-    );
+    throw StakingError.fromUnknown(error, "INVALID_INPUT" /* INVALID_INPUT */, "Failed to get staker signature");
   }
 };
 
@@ -2675,10 +3171,13 @@ export {
   Staking,
   StakingScriptData,
   buildStakingTransactionOutputs,
+  clearTxSignatures,
   createCovenantWitness,
+  deriveMerkleProof,
   deriveSlashingOutput,
   deriveStakingOutputInfo,
   deriveUnbondingOutputInfo,
+  extractFirstSchnorrSignatureFromTransaction,
   findInputUTXO,
   findMatchingTxOutputIndex,
   getBabylonParamByBtcHeight,
@@ -2696,13 +3195,11 @@ export {
   isValidNoCoordPublicKey,
   slashEarlyUnbondedTransaction,
   slashTimelockUnbondedTransaction,
+  stakingExpansionTransaction,
   stakingTransaction,
   toBuffers,
   transactionIdToHash,
   unbondingTransaction,
-  validateParams,
-  validateStakingTimelock,
-  validateStakingTxInputData,
   withdrawEarlyUnbondedTransaction,
   withdrawSlashingTransaction,
   withdrawTimelockUnbondedTransaction