@bitgo-beta/babylonlabs-io-btc-staking-ts 0.4.0-beta.62 → 0.4.0-beta.621

package/dist/index.cjs

@@ -34,14 +34,16 @@ __export(src_exports, {
   BitcoinScriptType: () => BitcoinScriptType,
   ObservableStaking: () => ObservableStaking,
   ObservableStakingScriptData: () => ObservableStakingScriptData,
-  SigningStep: () => SigningStep,
   Staking: () => Staking,
   StakingScriptData: () => StakingScriptData,
   buildStakingTransactionOutputs: () => buildStakingTransactionOutputs,
+  clearTxSignatures: () => clearTxSignatures,
   createCovenantWitness: () => createCovenantWitness,
+  deriveMerkleProof: () => deriveMerkleProof,
   deriveSlashingOutput: () => deriveSlashingOutput,
   deriveStakingOutputInfo: () => deriveStakingOutputInfo,
   deriveUnbondingOutputInfo: () => deriveUnbondingOutputInfo,
+  extractFirstSchnorrSignatureFromTransaction: () => extractFirstSchnorrSignatureFromTransaction,
   findInputUTXO: () => findInputUTXO,
   findMatchingTxOutputIndex: () => findMatchingTxOutputIndex,
   getBabylonParamByBtcHeight: () => getBabylonParamByBtcHeight,
@@ -50,254 +52,26 @@ __export(src_exports, {
   getPublicKeyNoCoord: () => getPublicKeyNoCoord,
   getScriptType: () => getScriptType,
   getUnbondingTxStakerSignature: () => getUnbondingTxStakerSignature,
+  hasSlashing: () => hasSlashing,
   initBTCCurve: () => initBTCCurve,
+  isNativeSegwit: () => isNativeSegwit,
   isTaproot: () => isTaproot,
   isValidBabylonAddress: () => isValidBabylonAddress,
   isValidBitcoinAddress: () => isValidBitcoinAddress,
   isValidNoCoordPublicKey: () => isValidNoCoordPublicKey,
   slashEarlyUnbondedTransaction: () => slashEarlyUnbondedTransaction,
   slashTimelockUnbondedTransaction: () => slashTimelockUnbondedTransaction,
+  stakingExpansionTransaction: () => stakingExpansionTransaction,
   stakingTransaction: () => stakingTransaction,
   toBuffers: () => toBuffers,
   transactionIdToHash: () => transactionIdToHash,
   unbondingTransaction: () => unbondingTransaction,
-  validateParams: () => validateParams,
-  validateStakingTimelock: () => validateStakingTimelock,
-  validateStakingTxInputData: () => validateStakingTxInputData,
   withdrawEarlyUnbondedTransaction: () => withdrawEarlyUnbondedTransaction,
   withdrawSlashingTransaction: () => withdrawSlashingTransaction,
   withdrawTimelockUnbondedTransaction: () => withdrawTimelockUnbondedTransaction
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/staking/stakingScript.ts
-var import_bitcoinjs_lib = require("bitcoinjs-lib");
-
-// src/constants/keys.ts
-var NO_COORD_PK_BYTE_LENGTH = 32;
-
-// src/staking/stakingScript.ts
-var MAGIC_BYTES_LEN = 4;
-var StakingScriptData = class {
-  constructor(stakerKey, finalityProviderKeys, covenantKeys, covenantThreshold, stakingTimelock, unbondingTimelock) {
-    if (!stakerKey || !finalityProviderKeys || !covenantKeys || !covenantThreshold || !stakingTimelock || !unbondingTimelock) {
-      throw new Error("Missing required input values");
-    }
-    this.stakerKey = stakerKey;
-    this.finalityProviderKeys = finalityProviderKeys;
-    this.covenantKeys = covenantKeys;
-    this.covenantThreshold = covenantThreshold;
-    this.stakingTimeLock = stakingTimelock;
-    this.unbondingTimeLock = unbondingTimelock;
-    if (!this.validate()) {
-      throw new Error("Invalid script data provided");
-    }
-  }
-  /**
-   * Validates the staking script.
-   * @returns {boolean} Returns true if the staking script is valid, otherwise false.
-   */
-  validate() {
-    if (this.stakerKey.length != NO_COORD_PK_BYTE_LENGTH) {
-      return false;
-    }
-    if (this.finalityProviderKeys.some(
-      (finalityProviderKey) => finalityProviderKey.length != NO_COORD_PK_BYTE_LENGTH
-    )) {
-      return false;
-    }
-    if (this.covenantKeys.some((covenantKey) => covenantKey.length != NO_COORD_PK_BYTE_LENGTH)) {
-      return false;
-    }
-    const allPks = [
-      this.stakerKey,
-      ...this.finalityProviderKeys,
-      ...this.covenantKeys
-    ];
-    const allPksSet = new Set(allPks);
-    if (allPks.length !== allPksSet.size) {
-      return false;
-    }
-    if (this.covenantThreshold == 0 || this.covenantThreshold > this.covenantKeys.length) {
-      return false;
-    }
-    if (this.stakingTimeLock == 0 || this.stakingTimeLock > 65535) {
-      return false;
-    }
-    if (this.unbondingTimeLock == 0 || this.unbondingTimeLock > 65535) {
-      return false;
-    }
-    return true;
-  }
-  // The staking script allows for multiple finality provider public keys
-  // to support (re)stake to multiple finality providers
-  // Covenant members are going to have multiple keys
-  /**
-   * Builds a timelock script.
-   * @param timelock - The timelock value to encode in the script.
-   * @returns {Buffer} containing the compiled timelock script.
-   */
-  buildTimelockScript(timelock) {
-    return import_bitcoinjs_lib.script.compile([
-      this.stakerKey,
-      import_bitcoinjs_lib.opcodes.OP_CHECKSIGVERIFY,
-      import_bitcoinjs_lib.script.number.encode(timelock),
-      import_bitcoinjs_lib.opcodes.OP_CHECKSEQUENCEVERIFY
-    ]);
-  }
-  /**
-   * Builds the staking timelock script.
-   * Only holder of private key for given pubKey can spend after relative lock time
-   * Creates the timelock script in the form:
-   *    <stakerPubKey>
-   *    OP_CHECKSIGVERIFY
-   *    <stakingTimeBlocks>
-   *    OP_CHECKSEQUENCEVERIFY
-   * @returns {Buffer} The staking timelock script.
-   */
-  buildStakingTimelockScript() {
-    return this.buildTimelockScript(this.stakingTimeLock);
-  }
-  /**
-   * Builds the unbonding timelock script.
-   * Creates the unbonding timelock script in the form:
-   *    <stakerPubKey>
-   *    OP_CHECKSIGVERIFY
-   *    <unbondingTimeBlocks>
-   *    OP_CHECKSEQUENCEVERIFY
-   * @returns {Buffer} The unbonding timelock script.
-   */
-  buildUnbondingTimelockScript() {
-    return this.buildTimelockScript(this.unbondingTimeLock);
-  }
-  /**
-   * Builds the unbonding script in the form:
-   *    buildSingleKeyScript(stakerPk, true) ||
-   *    buildMultiKeyScript(covenantPks, covenantThreshold, false)
-   *    || means combining the scripts
-   * @returns {Buffer} The unbonding script.
-   */
-  buildUnbondingScript() {
-    return Buffer.concat([
-      this.buildSingleKeyScript(this.stakerKey, true),
-      this.buildMultiKeyScript(
-        this.covenantKeys,
-        this.covenantThreshold,
-        false
-      )
-    ]);
-  }
-  /**
-   * Builds the slashing script for staking in the form:
-   *    buildSingleKeyScript(stakerPk, true) ||
-   *    buildMultiKeyScript(finalityProviderPKs, 1, true) ||
-   *    buildMultiKeyScript(covenantPks, covenantThreshold, false)
-   *    || means combining the scripts
-   * The slashing script is a combination of single-key and multi-key scripts.
-   * The single-key script is used for staker key verification.
-   * The multi-key script is used for finality provider key verification and covenant key verification.
-   * @returns {Buffer} The slashing script as a Buffer.
-   */
-  buildSlashingScript() {
-    return Buffer.concat([
-      this.buildSingleKeyScript(this.stakerKey, true),
-      this.buildMultiKeyScript(
-        this.finalityProviderKeys,
-        // The threshold is always 1 as we only need one
-        // finalityProvider signature to perform slashing
-        // (only one finalityProvider performs an offence)
-        1,
-        // OP_VERIFY/OP_CHECKSIGVERIFY is added at the end
-        true
-      ),
-      this.buildMultiKeyScript(
-        this.covenantKeys,
-        this.covenantThreshold,
-        // No need to add verify since covenants are at the end of the script
-        false
-      )
-    ]);
-  }
-  /**
-   * Builds the staking scripts.
-   * @returns {StakingScripts} The staking scripts.
-   */
-  buildScripts() {
-    return {
-      timelockScript: this.buildStakingTimelockScript(),
-      unbondingScript: this.buildUnbondingScript(),
-      slashingScript: this.buildSlashingScript(),
-      unbondingTimelockScript: this.buildUnbondingTimelockScript()
-    };
-  }
-  // buildSingleKeyScript and buildMultiKeyScript allow us to reuse functionality
-  // for creating Bitcoin scripts for the unbonding script and the slashing script
-  /**
-   * Builds a single key script in the form:
-   * buildSingleKeyScript creates a single key script
-   *    <pk> OP_CHECKSIGVERIFY (if withVerify is true)
-   *    <pk> OP_CHECKSIG (if withVerify is false)
-   * @param pk - The public key buffer.
-   * @param withVerify - A boolean indicating whether to include the OP_CHECKSIGVERIFY opcode.
-   * @returns The compiled script buffer.
-   */
-  buildSingleKeyScript(pk, withVerify) {
-    if (pk.length != NO_COORD_PK_BYTE_LENGTH) {
-      throw new Error("Invalid key length");
-    }
-    return import_bitcoinjs_lib.script.compile([
-      pk,
-      withVerify ? import_bitcoinjs_lib.opcodes.OP_CHECKSIGVERIFY : import_bitcoinjs_lib.opcodes.OP_CHECKSIG
-    ]);
-  }
-  /**
-   * Builds a multi-key script in the form:
-   *    <pk1> OP_CHEKCSIG <pk2> OP_CHECKSIGADD <pk3> OP_CHECKSIGADD ... <pkN> OP_CHECKSIGADD <threshold> OP_NUMEQUAL
-   *    <withVerify -> OP_NUMEQUALVERIFY>
-   * It validates whether provided keys are unique and the threshold is not greater than number of keys
-   * If there is only one key provided it will return single key sig script
-   * @param pks - An array of public keys.
-   * @param threshold - The required number of valid signers.
-   * @param withVerify - A boolean indicating whether to include the OP_VERIFY opcode.
-   * @returns The compiled multi-key script as a Buffer.
-   * @throws {Error} If no keys are provided, if the required number of valid signers is greater than the number of provided keys, or if duplicate keys are provided.
-   */
-  buildMultiKeyScript(pks, threshold, withVerify) {
-    if (!pks || pks.length === 0) {
-      throw new Error("No keys provided");
-    }
-    if (pks.some((pk) => pk.length != NO_COORD_PK_BYTE_LENGTH)) {
-      throw new Error("Invalid key length");
-    }
-    if (threshold > pks.length) {
-      throw new Error(
-        "Required number of valid signers is greater than number of provided keys"
-      );
-    }
-    if (pks.length === 1) {
-      return this.buildSingleKeyScript(pks[0], withVerify);
-    }
-    const sortedPks = [...pks].sort(Buffer.compare);
-    for (let i = 0; i < sortedPks.length - 1; ++i) {
-      if (sortedPks[i].equals(sortedPks[i + 1])) {
-        throw new Error("Duplicate keys provided");
-      }
-    }
-    const scriptElements = [sortedPks[0], import_bitcoinjs_lib.opcodes.OP_CHECKSIG];
-    for (let i = 1; i < sortedPks.length; i++) {
-      scriptElements.push(sortedPks[i]);
-      scriptElements.push(import_bitcoinjs_lib.opcodes.OP_CHECKSIGADD);
-    }
-    scriptElements.push(import_bitcoinjs_lib.script.number.encode(threshold));
-    if (withVerify) {
-      scriptElements.push(import_bitcoinjs_lib.opcodes.OP_NUMEQUALVERIFY);
-    } else {
-      scriptElements.push(import_bitcoinjs_lib.opcodes.OP_NUMEQUAL);
-    }
-    return import_bitcoinjs_lib.script.compile(scriptElements);
-  }
-};
-
 // src/error/index.ts
 var StakingError = class _StakingError extends Error {
   constructor(code, message) {
@@ -316,43 +90,52 @@ var StakingError = class _StakingError extends Error {
   }
 };
 
-// src/staking/transactions.ts
-var import_bitcoinjs_lib6 = require("bitcoinjs-lib");
-
-// src/constants/dustSat.ts
-var BTC_DUST_SAT = 546;
+// src/utils/btc.ts
+var ecc = __toESM(require("@bitcoin-js/tiny-secp256k1-asmjs"), 1);
+var import_bitcoinjs_lib = require("bitcoinjs-lib");
 
-// src/constants/internalPubkey.ts
-var key = "0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
-var internalPubkey = Buffer.from(key, "hex").subarray(1, 33);
+// src/constants/keys.ts
+var NO_COORD_PK_BYTE_LENGTH = 32;
 
 // src/utils/btc.ts
-var ecc = __toESM(require("@bitcoin-js/tiny-secp256k1-asmjs"), 1);
-var import_bitcoinjs_lib2 = require("bitcoinjs-lib");
 var initBTCCurve = () => {
-  (0, import_bitcoinjs_lib2.initEccLib)(ecc);
+  (0, import_bitcoinjs_lib.initEccLib)(ecc);
 };
 var isValidBitcoinAddress = (btcAddress, network) => {
   try {
-    return !!import_bitcoinjs_lib2.address.toOutputScript(btcAddress, network);
+    return !!import_bitcoinjs_lib.address.toOutputScript(btcAddress, network);
   } catch (error) {
     return false;
   }
 };
 var isTaproot = (taprootAddress, network) => {
   try {
-    const decoded = import_bitcoinjs_lib2.address.fromBech32(taprootAddress);
+    const decoded = import_bitcoinjs_lib.address.fromBech32(taprootAddress);
     if (decoded.version !== 1) {
       return false;
     }
-    switch (network) {
-      case import_bitcoinjs_lib2.networks.bitcoin:
-        return taprootAddress.startsWith("bc1p");
-      case import_bitcoinjs_lib2.networks.testnet:
-        return taprootAddress.startsWith("tb1p") || taprootAddress.startsWith("sb1p");
-      default:
-        return false;
+    if (network.bech32 === import_bitcoinjs_lib.networks.bitcoin.bech32) {
+      return taprootAddress.startsWith("bc1p");
+    } else if (network.bech32 === import_bitcoinjs_lib.networks.testnet.bech32) {
+      return taprootAddress.startsWith("tb1p") || taprootAddress.startsWith("sb1p");
+    }
+    return false;
+  } catch (error) {
+    return false;
+  }
+};
+var isNativeSegwit = (segwitAddress, network) => {
+  try {
+    const decoded = import_bitcoinjs_lib.address.fromBech32(segwitAddress);
+    if (decoded.version !== 0) {
+      return false;
+    }
+    if (network.bech32 === import_bitcoinjs_lib.networks.bitcoin.bech32) {
+      return segwitAddress.startsWith("bc1q");
+    } else if (network.bech32 === import_bitcoinjs_lib.networks.testnet.bech32) {
+      return segwitAddress.startsWith("tb1q");
     }
+    return false;
   } catch (error) {
     return false;
   }
@@ -388,124 +171,12 @@ var transactionIdToHash = (txId) => {
   return Buffer.from(txId, "hex").reverse();
 };
 
-// src/utils/fee/index.ts
-var import_bitcoinjs_lib4 = require("bitcoinjs-lib");
+// src/utils/staking/index.ts
+var import_bitcoinjs_lib2 = require("bitcoinjs-lib");
 
-// src/constants/fee.ts
-var DEFAULT_INPUT_SIZE = 180;
-var P2WPKH_INPUT_SIZE = 68;
-var P2TR_INPUT_SIZE = 58;
-var TX_BUFFER_SIZE_OVERHEAD = 11;
-var LOW_RATE_ESTIMATION_ACCURACY_BUFFER = 30;
-var MAX_NON_LEGACY_OUTPUT_SIZE = 43;
-var WITHDRAW_TX_BUFFER_SIZE = 17;
-var WALLET_RELAY_FEE_RATE_THRESHOLD = 2;
-var OP_RETURN_OUTPUT_VALUE_SIZE = 8;
-var OP_RETURN_VALUE_SERIALIZE_SIZE = 1;
-
-// src/utils/fee/utils.ts
-var import_bitcoinjs_lib3 = require("bitcoinjs-lib");
-var isOP_RETURN = (script4) => {
-  const decompiled = import_bitcoinjs_lib3.script.decompile(script4);
-  return !!decompiled && decompiled[0] === import_bitcoinjs_lib3.opcodes.OP_RETURN;
-};
-var getInputSizeByScript = (script4) => {
-  try {
-    const { address: p2wpkhAddress } = import_bitcoinjs_lib3.payments.p2wpkh({
-      output: script4
-    });
-    if (p2wpkhAddress) {
-      return P2WPKH_INPUT_SIZE;
-    }
-  } catch (error) {
-  }
-  try {
-    const { address: p2trAddress } = import_bitcoinjs_lib3.payments.p2tr({
-      output: script4
-    });
-    if (p2trAddress) {
-      return P2TR_INPUT_SIZE;
-    }
-  } catch (error) {
-  }
-  return DEFAULT_INPUT_SIZE;
-};
-var getEstimatedChangeOutputSize = () => {
-  return MAX_NON_LEGACY_OUTPUT_SIZE;
-};
-var inputValueSum = (inputUTXOs) => {
-  return inputUTXOs.reduce((acc, utxo) => acc + utxo.value, 0);
-};
-
-// src/utils/fee/index.ts
-var getStakingTxInputUTXOsAndFees = (availableUTXOs, stakingAmount, feeRate, outputs) => {
-  if (availableUTXOs.length === 0) {
-    throw new Error("Insufficient funds");
-  }
-  const validUTXOs = availableUTXOs.filter((utxo) => {
-    const script4 = Buffer.from(utxo.scriptPubKey, "hex");
-    return !!import_bitcoinjs_lib4.script.decompile(script4);
-  });
-  if (validUTXOs.length === 0) {
-    throw new Error("Insufficient funds: no valid UTXOs available for staking");
-  }
-  const sortedUTXOs = validUTXOs.sort((a, b) => b.value - a.value);
-  const selectedUTXOs = [];
-  let accumulatedValue = 0;
-  let estimatedFee = 0;
-  for (const utxo of sortedUTXOs) {
-    selectedUTXOs.push(utxo);
-    accumulatedValue += utxo.value;
-    const estimatedSize = getEstimatedSize(selectedUTXOs, outputs);
-    estimatedFee = estimatedSize * feeRate + rateBasedTxBufferFee(feeRate);
-    if (accumulatedValue - (stakingAmount + estimatedFee) > BTC_DUST_SAT) {
-      estimatedFee += getEstimatedChangeOutputSize() * feeRate;
-    }
-    if (accumulatedValue >= stakingAmount + estimatedFee) {
-      break;
-    }
-  }
-  if (accumulatedValue < stakingAmount + estimatedFee) {
-    throw new Error(
-      "Insufficient funds: unable to gather enough UTXOs to cover the staking amount and fees"
-    );
-  }
-  return {
-    selectedUTXOs,
-    fee: estimatedFee
-  };
-};
-var getWithdrawTxFee = (feeRate) => {
-  const inputSize = P2TR_INPUT_SIZE;
-  const outputSize = getEstimatedChangeOutputSize();
-  return feeRate * (inputSize + outputSize + TX_BUFFER_SIZE_OVERHEAD + WITHDRAW_TX_BUFFER_SIZE) + rateBasedTxBufferFee(feeRate);
-};
-var getEstimatedSize = (inputUtxos, outputs) => {
-  const inputSize = inputUtxos.reduce((acc, u) => {
-    const script4 = Buffer.from(u.scriptPubKey, "hex");
-    const decompiledScript = import_bitcoinjs_lib4.script.decompile(script4);
-    if (!decompiledScript) {
-      return acc;
-    }
-    return acc + getInputSizeByScript(script4);
-  }, 0);
-  const outputSize = outputs.reduce((acc, output) => {
-    if (isOP_RETURN(output.scriptPubKey)) {
-      return acc + output.scriptPubKey.length + OP_RETURN_OUTPUT_VALUE_SIZE + OP_RETURN_VALUE_SERIALIZE_SIZE;
-    }
-    return acc + MAX_NON_LEGACY_OUTPUT_SIZE;
-  }, 0);
-  return inputSize + outputSize + TX_BUFFER_SIZE_OVERHEAD;
-};
-var rateBasedTxBufferFee = (feeRate) => {
-  return feeRate <= WALLET_RELAY_FEE_RATE_THRESHOLD ? LOW_RATE_ESTIMATION_ACCURACY_BUFFER : 0;
-};
-
-// src/utils/staking/index.ts
-var import_bitcoinjs_lib5 = require("bitcoinjs-lib");
-
-// src/constants/unbonding.ts
-var MIN_UNBONDING_OUTPUT_VALUE = 1e3;
+// src/constants/internalPubkey.ts
+var key = "0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
+var internalPubkey = Buffer.from(key, "hex").subarray(1, 33);
 
 // src/utils/staking/index.ts
 var buildStakingTransactionOutputs = (scripts, network, amount) => {
@@ -531,7 +202,7 @@ var deriveStakingOutputInfo = (scripts, network) => {
     },
     [{ output: scripts.unbondingScript }, { output: scripts.timelockScript }]
   ];
-  const stakingOutput = import_bitcoinjs_lib5.payments.p2tr({
+  const stakingOutput = import_bitcoinjs_lib2.payments.p2tr({
     internalPubkey,
     scriptTree,
     network
@@ -544,7 +215,7 @@ var deriveStakingOutputInfo = (scripts, network) => {
   }
   return {
     outputAddress: stakingOutput.address,
-    scriptPubKey: import_bitcoinjs_lib5.address.toOutputScript(stakingOutput.address, network)
+    scriptPubKey: import_bitcoinjs_lib2.address.toOutputScript(stakingOutput.address, network)
   };
 };
 var deriveUnbondingOutputInfo = (scripts, network) => {
@@ -554,7 +225,7 @@ var deriveUnbondingOutputInfo = (scripts, network) => {
     },
     { output: scripts.unbondingTimelockScript }
   ];
-  const unbondingOutput = import_bitcoinjs_lib5.payments.p2tr({
+  const unbondingOutput = import_bitcoinjs_lib2.payments.p2tr({
     internalPubkey,
     scriptTree: outputScriptTree,
     network
@@ -567,11 +238,11 @@ var deriveUnbondingOutputInfo = (scripts, network) => {
   }
   return {
     outputAddress: unbondingOutput.address,
-    scriptPubKey: import_bitcoinjs_lib5.address.toOutputScript(unbondingOutput.address, network)
+    scriptPubKey: import_bitcoinjs_lib2.address.toOutputScript(unbondingOutput.address, network)
   };
 };
 var deriveSlashingOutput = (scripts, network) => {
-  const slashingOutput = import_bitcoinjs_lib5.payments.p2tr({
+  const slashingOutput = import_bitcoinjs_lib2.payments.p2tr({
     internalPubkey,
     scriptTree: { output: scripts.unbondingTimelockScript },
     network
@@ -585,12 +256,16 @@ var deriveSlashingOutput = (scripts, network) => {
   }
   return {
     outputAddress: slashingOutputAddress,
-    scriptPubKey: import_bitcoinjs_lib5.address.toOutputScript(slashingOutputAddress, network)
+    scriptPubKey: import_bitcoinjs_lib2.address.toOutputScript(slashingOutputAddress, network)
   };
 };
 var findMatchingTxOutputIndex = (tx, outputAddress, network) => {
   const index = tx.outs.findIndex((output) => {
-    return import_bitcoinjs_lib5.address.fromOutputScript(output.script, network) === outputAddress;
+    try {
+      return import_bitcoinjs_lib2.address.fromOutputScript(output.script, network) === outputAddress;
+    } catch (error) {
+      return false;
+    }
   });
   if (index === -1) {
     throw new StakingError(
@@ -600,135 +275,9 @@ 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")
-    );
+    return inputs.map((i) => Buffer.from(i, "hex"));
   } catch (error) {
     throw StakingError.fromUnknown(
       error,
@@ -737,16 +286,695 @@ 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/constants/psbt.ts
-var NON_RBF_SEQUENCE = 4294967295;
-var TRANSACTION_VERSION = 2;
+// src/staking/psbt.ts
+var import_bitcoinjs_lib4 = require("bitcoinjs-lib");
 
 // src/constants/transaction.ts
 var REDEEM_VERSION = 192;
 
-// src/staking/transactions.ts
-var BTC_LOCKTIME_HEIGHT_TIME_CUTOFF = 5e8;
+// src/utils/utxo/findInputUTXO.ts
+var findInputUTXO = (inputUTXOs, input) => {
+  const inputUTXO = inputUTXOs.find(
+    (u) => transactionIdToHash(u.txid).toString("hex") === input.hash.toString("hex") && u.vout === input.index
+  );
+  if (!inputUTXO) {
+    throw new Error(
+      `Input UTXO not found for txid: ${Buffer.from(input.hash).reverse().toString("hex")} and vout: ${input.index}`
+    );
+  }
+  return inputUTXO;
+};
+
+// src/utils/utxo/getScriptType.ts
+var import_bitcoinjs_lib3 = require("bitcoinjs-lib");
+var BitcoinScriptType = /* @__PURE__ */ ((BitcoinScriptType2) => {
+  BitcoinScriptType2["P2PKH"] = "pubkeyhash";
+  BitcoinScriptType2["P2SH"] = "scripthash";
+  BitcoinScriptType2["P2WPKH"] = "witnesspubkeyhash";
+  BitcoinScriptType2["P2WSH"] = "witnessscripthash";
+  BitcoinScriptType2["P2TR"] = "taproot";
+  return BitcoinScriptType2;
+})(BitcoinScriptType || {});
+var getScriptType = (script4) => {
+  try {
+    import_bitcoinjs_lib3.payments.p2pkh({ output: script4 });
+    return "pubkeyhash" /* P2PKH */;
+  } catch {
+  }
+  try {
+    import_bitcoinjs_lib3.payments.p2sh({ output: script4 });
+    return "scripthash" /* P2SH */;
+  } catch {
+  }
+  try {
+    import_bitcoinjs_lib3.payments.p2wpkh({ output: script4 });
+    return "witnesspubkeyhash" /* P2WPKH */;
+  } catch {
+  }
+  try {
+    import_bitcoinjs_lib3.payments.p2wsh({ output: script4 });
+    return "witnessscripthash" /* P2WSH */;
+  } catch {
+  }
+  try {
+    import_bitcoinjs_lib3.payments.p2tr({ output: script4 });
+    return "taproot" /* P2TR */;
+  } catch {
+  }
+  throw new Error("Unknown script type");
+};
+
+// src/utils/utxo/getPsbtInputFields.ts
+var getPsbtInputFields = (utxo, publicKeyNoCoord) => {
+  const scriptPubKey = Buffer.from(utxo.scriptPubKey, "hex");
+  const type = getScriptType(scriptPubKey);
+  switch (type) {
+    case "pubkeyhash" /* P2PKH */: {
+      if (!utxo.rawTxHex) {
+        throw new Error("Missing rawTxHex for legacy P2PKH input");
+      }
+      return { nonWitnessUtxo: Buffer.from(utxo.rawTxHex, "hex") };
+    }
+    case "scripthash" /* P2SH */: {
+      if (!utxo.rawTxHex) {
+        throw new Error("Missing rawTxHex for P2SH input");
+      }
+      if (!utxo.redeemScript) {
+        throw new Error("Missing redeemScript for P2SH input");
+      }
+      return {
+        nonWitnessUtxo: Buffer.from(utxo.rawTxHex, "hex"),
+        redeemScript: Buffer.from(utxo.redeemScript, "hex")
+      };
+    }
+    case "witnesspubkeyhash" /* P2WPKH */: {
+      return {
+        witnessUtxo: {
+          script: scriptPubKey,
+          value: utxo.value
+        }
+      };
+    }
+    case "witnessscripthash" /* P2WSH */: {
+      if (!utxo.witnessScript) {
+        throw new Error("Missing witnessScript for P2WSH input");
+      }
+      return {
+        witnessUtxo: {
+          script: scriptPubKey,
+          value: utxo.value
+        },
+        witnessScript: Buffer.from(utxo.witnessScript, "hex")
+      };
+    }
+    case "taproot" /* P2TR */: {
+      return {
+        witnessUtxo: {
+          script: scriptPubKey,
+          value: utxo.value
+        },
+        // this is needed only if the wallet is in taproot mode
+        ...publicKeyNoCoord && { tapInternalKey: publicKeyNoCoord }
+      };
+    }
+    default:
+      throw new Error(`Unsupported script type: ${type}`);
+  }
+};
+
+// src/staking/psbt.ts
+var stakingPsbt = (stakingTx, network, inputUTXOs, publicKeyNoCoord) => {
+  if (publicKeyNoCoord && publicKeyNoCoord.length !== NO_COORD_PK_BYTE_LENGTH) {
+    throw new Error("Invalid public key");
+  }
+  const psbt = new import_bitcoinjs_lib4.Psbt({ network });
+  if (stakingTx.version !== void 0)
+    psbt.setVersion(stakingTx.version);
+  if (stakingTx.locktime !== void 0)
+    psbt.setLocktime(stakingTx.locktime);
+  stakingTx.ins.forEach((input) => {
+    const inputUTXO = findInputUTXO(inputUTXOs, input);
+    const psbtInputData = getPsbtInputFields(inputUTXO, publicKeyNoCoord);
+    psbt.addInput({
+      hash: input.hash,
+      index: input.index,
+      sequence: input.sequence,
+      ...psbtInputData
+    });
+  });
+  stakingTx.outs.forEach((o) => {
+    psbt.addOutput({ script: o.script, value: o.value });
+  });
+  return psbt;
+};
+var stakingExpansionPsbt = (network, stakingTx, previousStakingTxInfo, inputUTXOs, previousScripts, publicKeyNoCoord) => {
+  const psbt = new import_bitcoinjs_lib4.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 = import_bitcoinjs_lib4.payments.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");
+  }
+  if (unbondingTx.ins.length !== 1) {
+    throw new Error("Unbonding transaction must have exactly one input");
+  }
+  validateUnbondingOutput(scripts, unbondingTx, network);
+  const psbt = new import_bitcoinjs_lib4.Psbt({ network });
+  if (unbondingTx.version !== void 0) {
+    psbt.setVersion(unbondingTx.version);
+  }
+  if (unbondingTx.locktime !== void 0) {
+    psbt.setLocktime(unbondingTx.locktime);
+  }
+  const input = unbondingTx.ins[0];
+  const outputIndex = input.index;
+  const inputScriptTree = [
+    { output: scripts.slashingScript },
+    [{ output: scripts.unbondingScript }, { output: scripts.timelockScript }]
+  ];
+  const inputRedeem = {
+    output: scripts.unbondingScript,
+    redeemVersion: REDEEM_VERSION
+  };
+  const p2tr = import_bitcoinjs_lib4.payments.p2tr({
+    internalPubkey,
+    scriptTree: inputScriptTree,
+    redeem: inputRedeem,
+    network
+  });
+  const inputTapLeafScript = {
+    leafVersion: inputRedeem.redeemVersion,
+    script: inputRedeem.output,
+    controlBlock: p2tr.witness[p2tr.witness.length - 1]
+  };
+  psbt.addInput({
+    hash: input.hash,
+    index: input.index,
+    sequence: input.sequence,
+    tapInternalKey: internalPubkey,
+    witnessUtxo: {
+      value: stakingTx.outs[outputIndex].value,
+      script: stakingTx.outs[outputIndex].script
+    },
+    tapLeafScript: [inputTapLeafScript]
+  });
+  psbt.addOutput({
+    script: unbondingTx.outs[0].script,
+    value: unbondingTx.outs[0].value
+  });
+  return psbt;
+};
+var validateUnbondingOutput = (scripts, unbondingTx, network) => {
+  const unbondingOutputInfo = deriveUnbondingOutputInfo(scripts, network);
+  if (unbondingOutputInfo.scriptPubKey.toString("hex") !== unbondingTx.outs[0].script.toString("hex")) {
+    throw new Error(
+      "Unbonding output script does not match the expected script while building psbt"
+    );
+  }
+};
+
+// src/staking/stakingScript.ts
+var import_bitcoinjs_lib5 = require("bitcoinjs-lib");
+var MAGIC_BYTES_LEN = 4;
+var StakingScriptData = class {
+  constructor(stakerKey, finalityProviderKeys, covenantKeys, covenantThreshold, stakingTimelock, unbondingTimelock) {
+    if (!stakerKey || !finalityProviderKeys || !covenantKeys || !covenantThreshold || !stakingTimelock || !unbondingTimelock) {
+      throw new Error("Missing required input values");
+    }
+    this.stakerKey = stakerKey;
+    this.finalityProviderKeys = finalityProviderKeys;
+    this.covenantKeys = covenantKeys;
+    this.covenantThreshold = covenantThreshold;
+    this.stakingTimeLock = stakingTimelock;
+    this.unbondingTimeLock = unbondingTimelock;
+    if (!this.validate()) {
+      throw new Error("Invalid script data provided");
+    }
+  }
+  /**
+   * Validates the staking script.
+   * @returns {boolean} Returns true if the staking script is valid, otherwise false.
+   */
+  validate() {
+    if (this.stakerKey.length != NO_COORD_PK_BYTE_LENGTH) {
+      return false;
+    }
+    if (this.finalityProviderKeys.some(
+      (finalityProviderKey) => finalityProviderKey.length != NO_COORD_PK_BYTE_LENGTH
+    )) {
+      return false;
+    }
+    if (this.covenantKeys.some((covenantKey) => covenantKey.length != NO_COORD_PK_BYTE_LENGTH)) {
+      return false;
+    }
+    const allPks = [
+      this.stakerKey,
+      ...this.finalityProviderKeys,
+      ...this.covenantKeys
+    ];
+    const allPksSet = new Set(allPks);
+    if (allPks.length !== allPksSet.size) {
+      return false;
+    }
+    if (this.covenantThreshold <= 0 || this.covenantThreshold > this.covenantKeys.length) {
+      return false;
+    }
+    if (this.stakingTimeLock <= 0 || this.stakingTimeLock > 65535) {
+      return false;
+    }
+    if (this.unbondingTimeLock <= 0 || this.unbondingTimeLock > 65535) {
+      return false;
+    }
+    return true;
+  }
+  // The staking script allows for multiple finality provider public keys
+  // to support (re)stake to multiple finality providers
+  // Covenant members are going to have multiple keys
+  /**
+   * Builds a timelock script.
+   * @param timelock - The timelock value to encode in the script.
+   * @returns {Buffer} containing the compiled timelock script.
+   */
+  buildTimelockScript(timelock) {
+    return import_bitcoinjs_lib5.script.compile([
+      this.stakerKey,
+      import_bitcoinjs_lib5.opcodes.OP_CHECKSIGVERIFY,
+      import_bitcoinjs_lib5.script.number.encode(timelock),
+      import_bitcoinjs_lib5.opcodes.OP_CHECKSEQUENCEVERIFY
+    ]);
+  }
+  /**
+   * Builds the staking timelock script.
+   * Only holder of private key for given pubKey can spend after relative lock time
+   * Creates the timelock script in the form:
+   *    <stakerPubKey>
+   *    OP_CHECKSIGVERIFY
+   *    <stakingTimeBlocks>
+   *    OP_CHECKSEQUENCEVERIFY
+   * @returns {Buffer} The staking timelock script.
+   */
+  buildStakingTimelockScript() {
+    return this.buildTimelockScript(this.stakingTimeLock);
+  }
+  /**
+   * Builds the unbonding timelock script.
+   * Creates the unbonding timelock script in the form:
+   *    <stakerPubKey>
+   *    OP_CHECKSIGVERIFY
+   *    <unbondingTimeBlocks>
+   *    OP_CHECKSEQUENCEVERIFY
+   * @returns {Buffer} The unbonding timelock script.
+   */
+  buildUnbondingTimelockScript() {
+    return this.buildTimelockScript(this.unbondingTimeLock);
+  }
+  /**
+   * Builds the unbonding script in the form:
+   *    buildSingleKeyScript(stakerPk, true) ||
+   *    buildMultiKeyScript(covenantPks, covenantThreshold, false)
+   *    || means combining the scripts
+   * @returns {Buffer} The unbonding script.
+   */
+  buildUnbondingScript() {
+    return Buffer.concat([
+      this.buildSingleKeyScript(this.stakerKey, true),
+      this.buildMultiKeyScript(
+        this.covenantKeys,
+        this.covenantThreshold,
+        false
+      )
+    ]);
+  }
+  /**
+   * Builds the slashing script for staking in the form:
+   *    buildSingleKeyScript(stakerPk, true) ||
+   *    buildMultiKeyScript(finalityProviderPKs, 1, true) ||
+   *    buildMultiKeyScript(covenantPks, covenantThreshold, false)
+   *    || means combining the scripts
+   * The slashing script is a combination of single-key and multi-key scripts.
+   * The single-key script is used for staker key verification.
+   * The multi-key script is used for finality provider key verification and covenant key verification.
+   * @returns {Buffer} The slashing script as a Buffer.
+   */
+  buildSlashingScript() {
+    return Buffer.concat([
+      this.buildSingleKeyScript(this.stakerKey, true),
+      this.buildMultiKeyScript(
+        this.finalityProviderKeys,
+        // The threshold is always 1 as we only need one
+        // finalityProvider signature to perform slashing
+        // (only one finalityProvider performs an offence)
+        1,
+        // OP_VERIFY/OP_CHECKSIGVERIFY is added at the end
+        true
+      ),
+      this.buildMultiKeyScript(
+        this.covenantKeys,
+        this.covenantThreshold,
+        // No need to add verify since covenants are at the end of the script
+        false
+      )
+    ]);
+  }
+  /**
+   * Builds the staking scripts.
+   * @returns {StakingScripts} The staking scripts.
+   */
+  buildScripts() {
+    return {
+      timelockScript: this.buildStakingTimelockScript(),
+      unbondingScript: this.buildUnbondingScript(),
+      slashingScript: this.buildSlashingScript(),
+      unbondingTimelockScript: this.buildUnbondingTimelockScript()
+    };
+  }
+  // buildSingleKeyScript and buildMultiKeyScript allow us to reuse functionality
+  // for creating Bitcoin scripts for the unbonding script and the slashing script
+  /**
+   * Builds a single key script in the form:
+   * buildSingleKeyScript creates a single key script
+   *    <pk> OP_CHECKSIGVERIFY (if withVerify is true)
+   *    <pk> OP_CHECKSIG (if withVerify is false)
+   * @param pk - The public key buffer.
+   * @param withVerify - A boolean indicating whether to include the OP_CHECKSIGVERIFY opcode.
+   * @returns The compiled script buffer.
+   */
+  buildSingleKeyScript(pk, withVerify) {
+    if (pk.length != NO_COORD_PK_BYTE_LENGTH) {
+      throw new Error("Invalid key length");
+    }
+    return import_bitcoinjs_lib5.script.compile([
+      pk,
+      withVerify ? import_bitcoinjs_lib5.opcodes.OP_CHECKSIGVERIFY : import_bitcoinjs_lib5.opcodes.OP_CHECKSIG
+    ]);
+  }
+  /**
+   * Builds a multi-key script in the form:
+   *    <pk1> OP_CHEKCSIG <pk2> OP_CHECKSIGADD <pk3> OP_CHECKSIGADD ... <pkN> OP_CHECKSIGADD <threshold> OP_NUMEQUAL
+   *    <withVerify -> OP_NUMEQUALVERIFY>
+   * It validates whether provided keys are unique and the threshold is not greater than number of keys
+   * If there is only one key provided it will return single key sig script
+   * @param pks - An array of public keys.
+   * @param threshold - The required number of valid signers.
+   * @param withVerify - A boolean indicating whether to include the OP_VERIFY opcode.
+   * @returns The compiled multi-key script as a Buffer.
+   * @throws {Error} If no keys are provided, if the required number of valid signers is greater than the number of provided keys, or if duplicate keys are provided.
+   */
+  buildMultiKeyScript(pks, threshold, withVerify) {
+    if (!pks || pks.length === 0) {
+      throw new Error("No keys provided");
+    }
+    if (pks.some((pk) => pk.length != NO_COORD_PK_BYTE_LENGTH)) {
+      throw new Error("Invalid key length");
+    }
+    if (threshold > pks.length) {
+      throw new Error(
+        "Required number of valid signers is greater than number of provided keys"
+      );
+    }
+    if (pks.length === 1) {
+      return this.buildSingleKeyScript(pks[0], withVerify);
+    }
+    const sortedPks = [...pks].sort(Buffer.compare);
+    for (let i = 0; i < sortedPks.length - 1; ++i) {
+      if (sortedPks[i].equals(sortedPks[i + 1])) {
+        throw new Error("Duplicate keys provided");
+      }
+    }
+    const scriptElements = [sortedPks[0], import_bitcoinjs_lib5.opcodes.OP_CHECKSIG];
+    for (let i = 1; i < sortedPks.length; i++) {
+      scriptElements.push(sortedPks[i]);
+      scriptElements.push(import_bitcoinjs_lib5.opcodes.OP_CHECKSIGADD);
+    }
+    scriptElements.push(import_bitcoinjs_lib5.script.number.encode(threshold));
+    if (withVerify) {
+      scriptElements.push(import_bitcoinjs_lib5.opcodes.OP_NUMEQUALVERIFY);
+    } else {
+      scriptElements.push(import_bitcoinjs_lib5.opcodes.OP_NUMEQUAL);
+    }
+    return import_bitcoinjs_lib5.script.compile(scriptElements);
+  }
+};
+
+// src/staking/transactions.ts
+var import_bitcoinjs_lib8 = require("bitcoinjs-lib");
+
+// src/constants/dustSat.ts
+var BTC_DUST_SAT = 546;
+
+// src/utils/fee/index.ts
+var import_bitcoinjs_lib7 = require("bitcoinjs-lib");
+
+// src/constants/fee.ts
+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;
+var WITHDRAW_TX_BUFFER_SIZE = 17;
+var WALLET_RELAY_FEE_RATE_THRESHOLD = 2;
+var OP_RETURN_OUTPUT_VALUE_SIZE = 8;
+var OP_RETURN_VALUE_SERIALIZE_SIZE = 1;
+
+// src/utils/fee/utils.ts
+var import_bitcoinjs_lib6 = require("bitcoinjs-lib");
+var isOP_RETURN = (script4) => {
+  const decompiled = import_bitcoinjs_lib6.script.decompile(script4);
+  return !!decompiled && decompiled[0] === import_bitcoinjs_lib6.opcodes.OP_RETURN;
+};
+var getInputSizeByScript = (script4) => {
+  try {
+    const { address: p2wpkhAddress } = import_bitcoinjs_lib6.payments.p2wpkh({
+      output: script4
+    });
+    if (p2wpkhAddress) {
+      return P2WPKH_INPUT_SIZE;
+    }
+  } catch (error) {
+  }
+  try {
+    const { address: p2trAddress } = import_bitcoinjs_lib6.payments.p2tr({
+      output: script4
+    });
+    if (p2trAddress) {
+      return P2TR_INPUT_SIZE;
+    }
+  } catch (error) {
+  }
+  return DEFAULT_INPUT_SIZE;
+};
+var getEstimatedChangeOutputSize = () => {
+  return MAX_NON_LEGACY_OUTPUT_SIZE;
+};
+var inputValueSum = (inputUTXOs) => {
+  return inputUTXOs.reduce((acc, utxo) => acc + utxo.value, 0);
+};
+
+// src/utils/fee/index.ts
+var getStakingTxInputUTXOsAndFees = (availableUTXOs, stakingAmount, feeRate, outputs) => {
+  if (availableUTXOs.length === 0) {
+    throw new Error("Insufficient funds");
+  }
+  const validUTXOs = availableUTXOs.filter((utxo) => {
+    const script4 = Buffer.from(utxo.scriptPubKey, "hex");
+    return !!import_bitcoinjs_lib7.script.decompile(script4);
+  });
+  if (validUTXOs.length === 0) {
+    throw new Error("Insufficient funds: no valid UTXOs available for staking");
+  }
+  const sortedUTXOs = validUTXOs.sort((a, b) => b.value - a.value);
+  const selectedUTXOs = [];
+  let accumulatedValue = 0;
+  let estimatedFee = 0;
+  for (const utxo of sortedUTXOs) {
+    selectedUTXOs.push(utxo);
+    accumulatedValue += utxo.value;
+    const estimatedSize = getEstimatedSize(selectedUTXOs, outputs);
+    estimatedFee = estimatedSize * feeRate + rateBasedTxBufferFee(feeRate);
+    if (accumulatedValue - (stakingAmount + estimatedFee) > BTC_DUST_SAT) {
+      estimatedFee += getEstimatedChangeOutputSize() * feeRate;
+    }
+    if (accumulatedValue >= stakingAmount + estimatedFee) {
+      break;
+    }
+  }
+  if (accumulatedValue < stakingAmount + estimatedFee) {
+    throw new Error(
+      "Insufficient funds: unable to gather enough UTXOs to cover the staking amount and fees"
+    );
+  }
+  return {
+    selectedUTXOs,
+    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 = import_bitcoinjs_lib7.script.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();
+  return feeRate * (inputSize + outputSize + TX_BUFFER_SIZE_OVERHEAD + WITHDRAW_TX_BUFFER_SIZE) + rateBasedTxBufferFee(feeRate);
+};
+var getEstimatedSize = (inputUtxos, outputs) => {
+  const inputSize = inputUtxos.reduce((acc, u) => {
+    const script4 = Buffer.from(u.scriptPubKey, "hex");
+    const decompiledScript = import_bitcoinjs_lib7.script.decompile(script4);
+    if (!decompiledScript) {
+      return acc;
+    }
+    return acc + getInputSizeByScript(script4);
+  }, 0);
+  const outputSize = outputs.reduce((acc, output) => {
+    if (isOP_RETURN(output.scriptPubKey)) {
+      return acc + output.scriptPubKey.length + OP_RETURN_OUTPUT_VALUE_SIZE + OP_RETURN_VALUE_SERIALIZE_SIZE;
+    }
+    return acc + MAX_NON_LEGACY_OUTPUT_SIZE;
+  }, 0);
+  return inputSize + outputSize + TX_BUFFER_SIZE_OVERHEAD;
+};
+var rateBasedTxBufferFee = (feeRate) => {
+  return feeRate <= WALLET_RELAY_FEE_RATE_THRESHOLD ? LOW_RATE_ESTIMATION_ACCURACY_BUFFER : 0;
+};
+
+// src/constants/psbt.ts
+var NON_RBF_SEQUENCE = 4294967295;
+var TRANSACTION_VERSION = 2;
+
+// src/staking/transactions.ts
+var BTC_LOCKTIME_HEIGHT_TIME_CUTOFF = 5e8;
+var BTC_SLASHING_FRACTION_DIGITS = 4;
 function stakingTransaction(scripts, amount, changeAddress, inputUTXOs, network, feeRate, lockHeight) {
   if (amount <= 0 || feeRate <= 0) {
     throw new Error("Amount and fee rate must be bigger than 0");
@@ -761,7 +989,7 @@ function stakingTransaction(scripts, amount, changeAddress, inputUTXOs, network,
     feeRate,
     stakingOutputs
   );
-  const tx = new import_bitcoinjs_lib6.Transaction();
+  const tx = new import_bitcoinjs_lib8.Transaction();
   tx.version = TRANSACTION_VERSION;
   for (let i = 0; i < selectedUTXOs.length; ++i) {
     const input = selectedUTXOs[i];
@@ -777,7 +1005,7 @@ function stakingTransaction(scripts, amount, changeAddress, inputUTXOs, network,
   const inputsSum = inputValueSum(selectedUTXOs);
   if (inputsSum - (amount + fee) > BTC_DUST_SAT) {
     tx.addOutput(
-      import_bitcoinjs_lib6.address.toOutputScript(changeAddress, network),
+      import_bitcoinjs_lib8.address.toOutputScript(changeAddress, network),
       inputsSum - (amount + fee)
     );
   }
@@ -792,6 +1020,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 import_bitcoinjs_lib8.Transaction();
+  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(
+      import_bitcoinjs_lib8.address.toOutputScript(changeAddress, network),
+      selectedUTXO.value - fee
+    );
+  }
+  return {
+    transaction: tx,
+    fee,
+    fundingUTXO: selectedUTXO
+  };
+}
 function withdrawEarlyUnbondedTransaction(scripts, unbondingTx, withdrawalAddress, network, feeRate) {
   const scriptTree = [
     {
@@ -851,14 +1137,14 @@ function withdrawalTransaction(scripts, scriptTree, tx, withdrawalAddress, netwo
     throw new Error("Output index must be bigger or equal to 0");
   }
   const timePosition = 2;
-  const decompiled = import_bitcoinjs_lib6.script.decompile(scripts.timelockScript);
+  const decompiled = import_bitcoinjs_lib8.script.decompile(scripts.timelockScript);
   if (!decompiled) {
     throw new Error("Timelock script is not valid");
   }
   let timelock = 0;
   if (typeof decompiled[timePosition] !== "number") {
     const timeBuffer = decompiled[timePosition];
-    timelock = import_bitcoinjs_lib6.script.number.decode(timeBuffer);
+    timelock = import_bitcoinjs_lib8.script.number.decode(timeBuffer);
   } else {
     const wrap = decompiled[timePosition] % 16;
     timelock = wrap === 0 ? 16 : wrap;
@@ -867,7 +1153,7 @@ function withdrawalTransaction(scripts, scriptTree, tx, withdrawalAddress, netwo
     output: scripts.timelockScript,
     redeemVersion: REDEEM_VERSION
   };
-  const p2tr = import_bitcoinjs_lib6.payments.p2tr({
+  const p2tr = import_bitcoinjs_lib8.payments.p2tr({
     internalPubkey,
     scriptTree,
     redeem,
@@ -878,7 +1164,7 @@ function withdrawalTransaction(scripts, scriptTree, tx, withdrawalAddress, netwo
     script: redeem.output,
     controlBlock: p2tr.witness[p2tr.witness.length - 1]
   };
-  const psbt = new import_bitcoinjs_lib6.Psbt({ network });
+  const psbt = new import_bitcoinjs_lib8.Psbt({ network });
   psbt.setVersion(TRANSACTION_VERSION);
   psbt.addInput({
     hash: tx.getHash(),
@@ -960,7 +1246,7 @@ function slashingTransaction(scripts, scriptTree, transaction, slashingPkScriptH
   if (slashingRate <= 0 || slashingRate >= 1) {
     throw new Error("Slashing rate must be between 0 and 1");
   }
-  slashingRate = parseFloat(slashingRate.toFixed(2));
+  slashingRate = parseFloat(slashingRate.toFixed(BTC_SLASHING_FRACTION_DIGITS));
   if (minimumFee <= 0 || !Number.isInteger(minimumFee)) {
     throw new Error("Minimum fee must be a positve integer");
   }
@@ -974,7 +1260,7 @@ function slashingTransaction(scripts, scriptTree, transaction, slashingPkScriptH
     output: scripts.slashingScript,
     redeemVersion: REDEEM_VERSION
   };
-  const p2tr = import_bitcoinjs_lib6.payments.p2tr({
+  const p2tr = import_bitcoinjs_lib8.payments.p2tr({
     internalPubkey,
     scriptTree,
     redeem,
@@ -986,15 +1272,18 @@ function slashingTransaction(scripts, scriptTree, transaction, slashingPkScriptH
     controlBlock: p2tr.witness[p2tr.witness.length - 1]
   };
   const stakingAmount = transaction.outs[outputIndex].value;
-  const slashingAmount = Math.floor(stakingAmount * slashingRate);
-  if (slashingAmount <= BTC_DUST_SAT) {
-    throw new Error("Slashing amount is less than dust limit");
+  const slashingAmount = Math.round(stakingAmount * slashingRate);
+  const slashingOutput = Buffer.from(slashingPkScriptHex, "hex");
+  if (import_bitcoinjs_lib8.opcodes.OP_RETURN != slashingOutput[0]) {
+    if (slashingAmount <= BTC_DUST_SAT) {
+      throw new Error("Slashing amount is less than dust limit");
+    }
   }
   const userFunds = stakingAmount - slashingAmount - minimumFee;
   if (userFunds <= BTC_DUST_SAT) {
     throw new Error("User funds are less than dust limit");
   }
-  const psbt = new import_bitcoinjs_lib6.Psbt({ network });
+  const psbt = new import_bitcoinjs_lib8.Psbt({ network });
   psbt.setVersion(TRANSACTION_VERSION);
   psbt.addInput({
     hash: transaction.getHash(),
@@ -1009,10 +1298,10 @@ function slashingTransaction(scripts, scriptTree, transaction, slashingPkScriptH
     sequence: NON_RBF_SEQUENCE
   });
   psbt.addOutput({
-    script: Buffer.from(slashingPkScriptHex, "hex"),
+    script: slashingOutput,
     value: slashingAmount
   });
-  const changeOutput = import_bitcoinjs_lib6.payments.p2tr({
+  const changeOutput = import_bitcoinjs_lib8.payments.p2tr({
     internalPubkey,
     scriptTree: { output: scripts.unbondingTimelockScript },
     network
@@ -1031,7 +1320,7 @@ function unbondingTransaction(scripts, stakingTx, unbondingFee, network, outputI
   if (outputIndex < 0) {
     throw new Error("Output index must be bigger or equal to 0");
   }
-  const tx = new import_bitcoinjs_lib6.Transaction();
+  const tx = new import_bitcoinjs_lib8.Transaction();
   tx.version = TRANSACTION_VERSION;
   tx.addInput(
     stakingTx.getHash(),
@@ -1063,13 +1352,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"),
@@ -1082,212 +1372,202 @@ var createCovenantWitness = (originalWitness, paramsCovenants, covenantSigs, cov
     );
     return covenantSig?.sigHex || Buffer.alloc(0);
   });
-  return [...composedCovenantSigs, ...originalWitness];
-};
-
-// src/staking/psbt.ts
-var import_bitcoinjs_lib8 = require("bitcoinjs-lib");
-
-// src/utils/utxo/findInputUTXO.ts
-var findInputUTXO = (inputUTXOs, input) => {
-  const inputUTXO = inputUTXOs.find(
-    (u) => transactionIdToHash(u.txid).toString("hex") === input.hash.toString("hex") && u.vout === input.index
-  );
-  if (!inputUTXO) {
-    throw new Error(
-      `Input UTXO not found for txid: ${Buffer.from(input.hash).reverse().toString("hex")} and vout: ${input.index}`
+  return [...composedCovenantSigs, ...originalWitness];
+};
+
+// src/constants/unbonding.ts
+var MIN_UNBONDING_OUTPUT_VALUE = 1e3;
+
+// src/utils/babylon.ts
+var import_encoding = require("@cosmjs/encoding");
+var isValidBabylonAddress = (address4) => {
+  try {
+    const { prefix } = (0, import_encoding.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"
     );
   }
-  return inputUTXO;
-};
-
-// src/utils/utxo/getScriptType.ts
-var import_bitcoinjs_lib7 = require("bitcoinjs-lib");
-var BitcoinScriptType = /* @__PURE__ */ ((BitcoinScriptType2) => {
-  BitcoinScriptType2["P2PKH"] = "pubkeyhash";
-  BitcoinScriptType2["P2SH"] = "scripthash";
-  BitcoinScriptType2["P2WPKH"] = "witnesspubkeyhash";
-  BitcoinScriptType2["P2WSH"] = "witnessscripthash";
-  BitcoinScriptType2["P2TR"] = "taproot";
-  return BitcoinScriptType2;
-})(BitcoinScriptType || {});
-var getScriptType = (script4) => {
-  try {
-    import_bitcoinjs_lib7.payments.p2pkh({ output: script4 });
-    return "pubkeyhash" /* P2PKH */;
-  } catch {
+  if (params.unbondingFeeSat <= 0) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Unbonding fee must be greater than 0"
+    );
   }
-  try {
-    import_bitcoinjs_lib7.payments.p2sh({ output: script4 });
-    return "scripthash" /* P2SH */;
-  } catch {
+  if (params.maxStakingAmountSat < params.minStakingAmountSat) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Max staking amount must be greater or equal to min staking amount"
+    );
   }
-  try {
-    import_bitcoinjs_lib7.payments.p2wpkh({ output: script4 });
-    return "witnesspubkeyhash" /* P2WPKH */;
-  } catch {
+  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}`
+    );
   }
-  try {
-    import_bitcoinjs_lib7.payments.p2wsh({ output: script4 });
-    return "witnessscripthash" /* P2WSH */;
-  } catch {
+  if (params.maxStakingTimeBlocks < params.minStakingTimeBlocks) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Max staking time must be greater or equal to min staking time"
+    );
   }
-  try {
-    import_bitcoinjs_lib7.payments.p2tr({ output: script4 });
-    return "taproot" /* P2TR */;
-  } catch {
+  if (params.minStakingTimeBlocks <= 0) {
+    throw new StakingError(
+      "INVALID_PARAMS" /* INVALID_PARAMS */,
+      "Min staking time must be greater than 0"
+    );
   }
-  throw new Error("Unknown script type");
-};
-
-// src/utils/utxo/getPsbtInputFields.ts
-var getPsbtInputFields = (utxo, publicKeyNoCoord) => {
-  const scriptPubKey = Buffer.from(utxo.scriptPubKey, "hex");
-  const type = getScriptType(scriptPubKey);
-  switch (type) {
-    case "pubkeyhash" /* P2PKH */: {
-      if (!utxo.rawTxHex) {
-        throw new Error("Missing rawTxHex for legacy P2PKH input");
-      }
-      return { nonWitnessUtxo: Buffer.from(utxo.rawTxHex, "hex") };
-    }
-    case "scripthash" /* P2SH */: {
-      if (!utxo.rawTxHex) {
-        throw new Error("Missing rawTxHex for P2SH input");
-      }
-      if (!utxo.redeemScript) {
-        throw new Error("Missing redeemScript for P2SH input");
-      }
-      return {
-        nonWitnessUtxo: Buffer.from(utxo.rawTxHex, "hex"),
-        redeemScript: Buffer.from(utxo.redeemScript, "hex")
-      };
+  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"
+      );
     }
-    case "witnesspubkeyhash" /* P2WPKH */: {
-      return {
-        witnessUtxo: {
-          script: scriptPubKey,
-          value: utxo.value
-        }
-      };
+    if (params.slashing.slashingRate > 1) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Slashing rate must be less or equal to 1"
+      );
     }
-    case "witnessscripthash" /* P2WSH */: {
-      if (!utxo.witnessScript) {
-        throw new Error("Missing witnessScript for P2WSH input");
-      }
-      return {
-        witnessUtxo: {
-          script: scriptPubKey,
-          value: utxo.value
-        },
-        witnessScript: Buffer.from(utxo.witnessScript, "hex")
-      };
+    if (params.slashing.slashingPkScriptHex.length == 0) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Slashing public key script is missing"
+      );
     }
-    case "taproot" /* P2TR */: {
-      return {
-        witnessUtxo: {
-          script: scriptPubKey,
-          value: utxo.value
-        },
-        // this is needed only if the wallet is in taproot mode
-        ...publicKeyNoCoord && { tapInternalKey: publicKeyNoCoord }
-      };
+    if (params.slashing.minSlashingTxFeeSat <= 0) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Minimum slashing transaction fee must be greater than 0"
+      );
     }
-    default:
-      throw new Error(`Unsupported script type: ${type}`);
-  }
-};
-
-// src/staking/psbt.ts
-var stakingPsbt = (stakingTx, network, inputUTXOs, publicKeyNoCoord) => {
-  if (publicKeyNoCoord && publicKeyNoCoord.length !== NO_COORD_PK_BYTE_LENGTH) {
-    throw new Error("Invalid public key");
   }
-  const psbt = new import_bitcoinjs_lib8.Psbt({ network });
-  if (stakingTx.version !== void 0)
-    psbt.setVersion(stakingTx.version);
-  if (stakingTx.locktime !== void 0)
-    psbt.setLocktime(stakingTx.locktime);
-  stakingTx.ins.forEach((input) => {
-    const inputUTXO = findInputUTXO(inputUTXOs, input);
-    const psbtInputData = getPsbtInputFields(inputUTXO, publicKeyNoCoord);
-    psbt.addInput({
-      hash: input.hash,
-      index: input.index,
-      sequence: input.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");
-  }
-  if (unbondingTx.ins.length !== 1) {
-    throw new Error("Unbonding transaction must have exactly one input");
-  }
-  validateUnbondingOutput(scripts, unbondingTx, network);
-  const psbt = new import_bitcoinjs_lib8.Psbt({ network });
-  if (unbondingTx.version !== void 0) {
-    psbt.setVersion(unbondingTx.version);
-  }
-  if (unbondingTx.locktime !== void 0) {
-    psbt.setLocktime(unbondingTx.locktime);
+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"
+    );
   }
-  const input = unbondingTx.ins[0];
-  const outputIndex = input.index;
-  const inputScriptTree = [
-    { output: scripts.slashingScript },
-    [{ output: scripts.unbondingScript }, { output: scripts.timelockScript }]
-  ];
-  const inputRedeem = {
-    output: scripts.unbondingScript,
-    redeemVersion: REDEEM_VERSION
-  };
-  const p2tr = import_bitcoinjs_lib8.payments.p2tr({
-    internalPubkey,
-    scriptTree: inputScriptTree,
-    redeem: inputRedeem,
-    network
-  });
-  const inputTapLeafScript = {
-    leafVersion: inputRedeem.redeemVersion,
-    script: inputRedeem.output,
-    controlBlock: p2tr.witness[p2tr.witness.length - 1]
-  };
-  psbt.addInput({
-    hash: input.hash,
-    index: input.index,
-    sequence: input.sequence,
-    tapInternalKey: internalPubkey,
-    witnessUtxo: {
-      value: stakingTx.outs[outputIndex].value,
-      script: stakingTx.outs[outputIndex].script
-    },
-    tapLeafScript: [inputTapLeafScript]
-  });
-  psbt.addOutput({
-    script: unbondingTx.outs[0].script,
-    value: unbondingTx.outs[0].value
-  });
-  return psbt;
 };
-var validateUnbondingOutput = (scripts, unbondingTx, network) => {
-  const unbondingOutputInfo = deriveUnbondingOutputInfo(scripts, network);
-  if (unbondingOutputInfo.scriptPubKey.toString("hex") !== unbondingTx.outs[0].script.toString("hex")) {
-    throw new Error(
-      "Unbonding output script does not match the expected script while building psbt"
+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 {
-  constructor(network, stakerInfo, params, finalityProviderPkNoCoordHex, stakingTimelock) {
+var Staking = class _Staking {
+  constructor(network, stakerInfo, params, finalityProviderPksNoCoordHex, stakingTimelock) {
     if (!isValidBitcoinAddress(stakerInfo.address, network)) {
       throw new StakingError(
         "INVALID_INPUT" /* INVALID_INPUT */,
@@ -1300,10 +1580,10 @@ var Staking = class {
         "Invalid staker public key"
       );
     }
-    if (!isValidNoCoordPublicKey(finalityProviderPkNoCoordHex)) {
+    if (finalityProviderPksNoCoordHex.length === 0 || !finalityProviderPksNoCoordHex.every(isValidNoCoordPublicKey)) {
       throw new StakingError(
         "INVALID_INPUT" /* INVALID_INPUT */,
-        "Invalid finality provider public key"
+        "Invalid finality providers public keys"
       );
     }
     validateParams(params);
@@ -1311,14 +1591,14 @@ var Staking = class {
     this.network = network;
     this.stakerInfo = stakerInfo;
     this.params = params;
-    this.finalityProviderPkNoCoordHex = finalityProviderPkNoCoordHex;
+    this.finalityProviderPksNoCoordHex = finalityProviderPksNoCoordHex;
     this.stakingTimelock = stakingTimelock;
   }
   /**
    * buildScripts builds the staking scripts for the staking transaction.
    * Note: different staking types may have different scripts.
    * e.g the observable staking script has a data embed script.
-   * 
+   *
    * @returns {StakingScripts} - The staking scripts.
    */
   buildScripts() {
@@ -1327,7 +1607,7 @@ var Staking = class {
     try {
       stakingScriptData = new StakingScriptData(
         Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex"),
-        [Buffer.from(this.finalityProviderPkNoCoordHex, "hex")],
+        this.finalityProviderPksNoCoordHex.map((pk) => Buffer.from(pk, "hex")),
         toBuffers(covenantNoCoordPks),
         covenantQuorum,
         this.stakingTimelock,
@@ -1354,9 +1634,9 @@ var Staking = class {
   }
   /**
    * Create a staking transaction for staking.
-   * 
+   *
    * @param {number} stakingAmountSat - The amount to stake in satoshis.
-   * @param {UTXO[]} inputUTXOs - The UTXOs to use as inputs for the staking 
+   * @param {UTXO[]} inputUTXOs - The UTXOs to use as inputs for the staking
    * transaction.
    * @param {number} feeRate - The fee rate for the transaction in satoshis per byte.
    * @returns {TransactionResult} - An object containing the unsigned
@@ -1393,11 +1673,86 @@ 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.
-   * 
+   *
    * @param {Transaction} stakingTx - The staking transaction.
-   * @param {UTXO[]} inputUTXOs - The UTXOs to use as inputs for the staking 
+   * @param {UTXO[]} inputUTXOs - The UTXOs to use as inputs for the staking
    * transaction. The UTXOs that were used to create the staking transaction should
    * be included in this array.
    * @returns {Psbt} - The psbt.
@@ -1414,15 +1769,54 @@ var Staking = class {
       stakingTx,
       this.network,
       inputUTXOs,
-      isTaproot(
-        this.stakerInfo.address,
-        this.network
-      ) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : void 0
+      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.
-   * 
+   *
    * @param {Transaction} stakingTx - The staking transaction to unbond.
    * @returns {TransactionResult} - An object containing the unsigned
    * transaction, and fee
@@ -1459,10 +1853,10 @@ var Staking = class {
   /**
    * Create an unbonding psbt based on the existing unbonding transaction and
    * staking transaction.
-   * 
+   *
    * @param {Transaction} unbondingTx - The unbonding transaction.
    * @param {Transaction} stakingTx - The staking transaction.
-   * 
+   *
    * @returns {Psbt} - The psbt.
    */
   toUnbondingPsbt(unbondingTx, stakingTx) {
@@ -1477,7 +1871,7 @@ var Staking = class {
    * Creates a withdrawal transaction that spends from an unbonding or slashing
    * transaction. The timelock on the input transaction must have expired before
    * this withdrawal can be valid.
-   * 
+   *
    * @param {Transaction} earlyUnbondedTx - The unbonding or slashing
    * transaction to withdraw from
    * @param {number} feeRate - Fee rate in satoshis per byte for the withdrawal
@@ -1505,9 +1899,9 @@ var Staking = class {
     }
   }
   /**
-   * Create a withdrawal psbt that spends a naturally expired staking 
+   * Create a withdrawal psbt that spends a naturally expired staking
    * transaction.
-   * 
+   *
    * @param {Transaction} stakingTx - The staking transaction to withdraw from.
    * @param {number} feeRate - The fee rate for the transaction in satoshis per byte.
    * @returns {PsbtResult} - An object containing the unsigned psbt and fee
@@ -1540,7 +1934,7 @@ var Staking = class {
   }
   /**
    * Create a slashing psbt spending from the staking output.
-   * 
+   *
    * @param {Transaction} stakingTx - The staking transaction to slash.
    * @returns {PsbtResult} - An object containing the unsigned psbt and fee
    * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
@@ -1553,6 +1947,12 @@ var Staking = class {
       );
     }
     const scripts = this.buildScripts();
+    const { outputAddress } = deriveStakingOutputInfo(scripts, this.network);
+    const stakingOutputIndex = findMatchingTxOutputIndex(
+      stakingTx,
+      outputAddress,
+      this.network
+    );
     try {
       const { psbt } = slashTimelockUnbondedTransaction(
         scripts,
@@ -1560,7 +1960,8 @@ var Staking = class {
         this.params.slashing.slashingPkScriptHex,
         this.params.slashing.slashingRate,
         this.params.slashing.minSlashingTxFeeSat,
-        this.network
+        this.network,
+        stakingOutputIndex
       );
       return {
         psbt,
@@ -1576,7 +1977,7 @@ var Staking = class {
   }
   /**
    * Create a slashing psbt for an unbonding output.
-   * 
+   *
    * @param {Transaction} unbondingTx - The unbonding transaction to slash.
    * @returns {PsbtResult} - An object containing the unsigned psbt and fee
    * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
@@ -1613,7 +2014,7 @@ var Staking = class {
   /**
    * Create a withdraw slashing psbt that spends a slashing transaction from the
    * staking output.
-   * 
+   *
    * @param {Transaction} slashingTx - The slashing transaction.
    * @param {number} feeRate - The fee rate for the transaction in satoshis per byte.
    * @returns {PsbtResult} - An object containing the unsigned psbt and fee
@@ -1627,260 +2028,34 @@ var Staking = class {
       slashingOutputInfo.outputAddress,
       this.network
     );
-    try {
-      return withdrawSlashingTransaction(
-        scripts,
-        slashingTx,
-        this.stakerInfo.address,
-        this.network,
-        feeRate,
-        slashingOutputIndex
-      );
-    } catch (error) {
-      throw StakingError.fromUnknown(
-        error,
-        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
-        "Cannot build withdraw slashing transaction"
-      );
-    }
-  }
-};
-
-// src/staking/observable/observableStakingScript.ts
-var import_bitcoinjs_lib9 = require("bitcoinjs-lib");
-var ObservableStakingScriptData = class extends StakingScriptData {
-  constructor(stakerKey, finalityProviderKeys, covenantKeys, covenantThreshold, stakingTimelock, unbondingTimelock, magicBytes) {
-    super(
-      stakerKey,
-      finalityProviderKeys,
-      covenantKeys,
-      covenantThreshold,
-      stakingTimelock,
-      unbondingTimelock
-    );
-    if (!magicBytes) {
-      throw new Error("Missing required input values");
-    }
-    if (magicBytes.length != MAGIC_BYTES_LEN) {
-      throw new Error("Invalid script data provided");
-    }
-    this.magicBytes = magicBytes;
-  }
-  /**
-   * Builds a data embed script for staking in the form:
-   *    OP_RETURN || <serializedStakingData>
-   * where serializedStakingData is the concatenation of:
-   *    MagicBytes || Version || StakerPublicKey || FinalityProviderPublicKey || StakingTimeLock
-   * Note: Only a single finality provider key is supported for now in phase 1
-   * @throws {Error} If the number of finality provider keys is not equal to 1.
-   * @returns {Buffer} The compiled data embed script.
-   */
-  buildDataEmbedScript() {
-    if (this.finalityProviderKeys.length != 1) {
-      throw new Error("Only a single finality provider key is supported");
-    }
-    const version = Buffer.alloc(1);
-    version.writeUInt8(0);
-    const stakingTimeLock = Buffer.alloc(2);
-    stakingTimeLock.writeUInt16BE(this.stakingTimeLock);
-    const serializedStakingData = Buffer.concat([
-      this.magicBytes,
-      version,
-      this.stakerKey,
-      this.finalityProviderKeys[0],
-      stakingTimeLock
-    ]);
-    return import_bitcoinjs_lib9.script.compile([import_bitcoinjs_lib9.opcodes.OP_RETURN, serializedStakingData]);
-  }
-  /**
-   * Builds the staking scripts.
-   * @returns {ObservableStakingScripts} The staking scripts that can be used to stake.
-   * contains the timelockScript, unbondingScript, slashingScript,
-   * unbondingTimelockScript, and dataEmbedScript.
-   * @throws {Error} If script data is invalid.
-   */
-  buildScripts() {
-    const scripts = super.buildScripts();
-    return {
-      ...scripts,
-      dataEmbedScript: this.buildDataEmbedScript()
-    };
-  }
-};
-
-// src/staking/observable/index.ts
-var ObservableStaking = class extends Staking {
-  constructor(network, stakerInfo, params, finalityProviderPkNoCoordHex, stakingTimelock) {
-    super(
-      network,
-      stakerInfo,
-      params,
-      finalityProviderPkNoCoordHex,
-      stakingTimelock
-    );
-    if (!params.tag) {
-      throw new StakingError(
-        "INVALID_INPUT" /* INVALID_INPUT */,
-        "Observable staking parameters must include tag"
-      );
-    }
-    if (!params.btcActivationHeight) {
-      throw new StakingError(
-        "INVALID_INPUT" /* INVALID_INPUT */,
-        "Observable staking parameters must include a positive activation height"
-      );
-    }
-    this.params = params;
-  }
-  /**
-   * Build the staking scripts for observable staking.
-   * This method overwrites the base method to include the OP_RETURN tag based 
-   * on the tag provided in the parameters.
-   * 
-   * @returns {ObservableStakingScripts} - The staking scripts for observable staking.
-   * @throws {StakingError} - If the scripts cannot be built.
-   */
-  buildScripts() {
-    const { covenantQuorum, covenantNoCoordPks, unbondingTime, tag } = this.params;
-    let stakingScriptData;
-    try {
-      stakingScriptData = new ObservableStakingScriptData(
-        Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex"),
-        [Buffer.from(this.finalityProviderPkNoCoordHex, "hex")],
-        toBuffers(covenantNoCoordPks),
-        covenantQuorum,
-        this.stakingTimelock,
-        unbondingTime,
-        Buffer.from(tag, "hex")
-      );
-    } catch (error) {
-      throw StakingError.fromUnknown(
-        error,
-        "SCRIPT_FAILURE" /* SCRIPT_FAILURE */,
-        "Cannot build staking script data"
-      );
-    }
-    let scripts;
-    try {
-      scripts = stakingScriptData.buildScripts();
-    } catch (error) {
-      throw StakingError.fromUnknown(
-        error,
-        "SCRIPT_FAILURE" /* SCRIPT_FAILURE */,
-        "Cannot build staking scripts"
-      );
-    }
-    return scripts;
-  }
-  /**
-   * Create a staking transaction for observable staking.
-   * This overwrites the method from the Staking class with the addtion
-   * of the 
-   * 1. OP_RETURN tag in the staking scripts
-   * 2. lockHeight parameter
-   * 
-   * @param {number} stakingAmountSat - The amount to stake in satoshis.
-   * @param {UTXO[]} inputUTXOs - The UTXOs to use as inputs for the staking 
-   * transaction.
-   * @param {number} feeRate - The fee rate for the transaction in satoshis per byte.
-   * @returns {TransactionResult} - An object containing the unsigned transaction,
-   * and fee
-   */
-  createStakingTransaction(stakingAmountSat, inputUTXOs, feeRate) {
-    validateStakingTxInputData(
-      stakingAmountSat,
-      this.stakingTimelock,
-      this.params,
-      inputUTXOs,
-      feeRate
-    );
-    const scripts = this.buildScripts();
-    try {
-      const { transaction, fee } = stakingTransaction(
-        scripts,
-        stakingAmountSat,
-        this.stakerInfo.address,
-        inputUTXOs,
-        this.network,
-        feeRate,
-        // `lockHeight` is exclusive of the provided value.
-        // For example, if a Bitcoin height of X is provided,
-        // the transaction will be included starting from height X+1.
-        // https://learnmeabitcoin.com/technical/transaction/locktime/
-        this.params.btcActivationHeight - 1
-      );
-      return {
-        transaction,
-        fee
-      };
-    } catch (error) {
-      throw StakingError.fromUnknown(
-        error,
-        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
-        "Cannot build unsigned staking transaction"
-      );
-    }
-  }
-  /**
-   * Create a staking psbt for observable staking.
-   * 
-   * @param {Transaction} stakingTx - The staking transaction.
-   * @param {UTXO[]} inputUTXOs - The UTXOs to use as inputs for the staking 
-   * transaction.
-   * @returns {Psbt} - The psbt.
-   */
-  toStakingPsbt(stakingTx, inputUTXOs) {
-    return stakingPsbt(
-      stakingTx,
-      this.network,
-      inputUTXOs,
-      isTaproot(
-        this.stakerInfo.address,
-        this.network
-      ) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : void 0
-    );
-  }
-};
-
-// src/utils/babylon.ts
-var import_encoding = require("@cosmjs/encoding");
-var isValidBabylonAddress = (address4) => {
-  try {
-    const { prefix } = (0, import_encoding.fromBech32)(address4);
-    return prefix === "bbn";
-  } catch (error) {
-    return false;
+    try {
+      return withdrawSlashingTransaction(
+        scripts,
+        slashingTx,
+        this.stakerInfo.address,
+        this.network,
+        feeRate,
+        slashingOutputIndex
+      );
+    } catch (error) {
+      throw StakingError.fromUnknown(
+        error,
+        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
+        "Cannot build withdraw slashing transaction"
+      );
+    }
   }
 };
 
-// src/utils/staking/param.ts
-var getBabylonParamByBtcHeight = (height, babylonParamsVersions) => {
-  const sortedParams = [...babylonParamsVersions].sort(
-    (a, b) => b.btcActivationHeight - a.btcActivationHeight
-  );
-  const params = sortedParams.find(
-    (p) => height >= p.btcActivationHeight
-  );
-  if (!params)
-    throw new Error(`Babylon params not found for height ${height}`);
-  return params;
-};
-var getBabylonParamByVersion = (version, babylonParams) => {
-  const params = babylonParams.find((p) => p.version === version);
-  if (!params)
-    throw new Error(`Babylon params not found for version ${version}`);
-  return params;
-};
-
 // src/staking/manager.ts
-var import_bitcoinjs_lib10 = require("bitcoinjs-lib");
-var import_encoding2 = require("@cosmjs/encoding");
 var import_babylon_proto_ts = require("@babylonlabs-io/babylon-proto-ts");
 var import_pop = require("@babylonlabs-io/babylon-proto-ts/dist/generated/babylon/btcstaking/v1/pop");
+var import_bitcoinjs_lib9 = require("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
@@ -1895,32 +2070,59 @@ var reverseBuffer = (buffer) => {
   }
   return clonedBuffer;
 };
-var uint8ArrayToHex = (uint8Array) => {
-  return Array.from(uint8Array).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+
+// src/utils/pop.ts
+var import_crypto = require("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 (0, import_crypto.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) => {
+  const sortedParams = [...babylonParamsVersions].sort(
+    (a, b) => b.btcActivationHeight - a.btcActivationHeight
+  );
+  const params = sortedParams.find(
+    (p) => height >= p.btcActivationHeight
+  );
+  if (!params)
+    throw new Error(`Babylon params not found for height ${height}`);
+  return params;
+};
+var getBabylonParamByVersion = (version, babylonParams) => {
+  const params = babylonParams.find((p) => p.version === version);
+  if (!params)
+    throw new Error(`Babylon params not found for version ${version}`);
+  return params;
 };
 
 // src/staking/manager.ts
-var SigningStep = /* @__PURE__ */ ((SigningStep2) => {
-  SigningStep2["STAKING_SLASHING"] = "staking-slashing";
-  SigningStep2["UNBONDING_SLASHING"] = "unbonding-slashing";
-  SigningStep2["PROOF_OF_POSSESSION"] = "proof-of-possession";
-  SigningStep2["CREATE_BTC_DELEGATION_MSG"] = "create-btc-delegation-msg";
-  SigningStep2["STAKING"] = "staking";
-  SigningStep2["UNBONDING"] = "unbonding";
-  SigningStep2["WITHDRAW_STAKING_EXPIRED"] = "withdraw-staking-expired";
-  SigningStep2["WITHDRAW_EARLY_UNBONDED"] = "withdraw-early-unbonded";
-  SigningStep2["WITHDRAW_SLASHING"] = "withdraw-slashing";
-  return SigningStep2;
-})(SigningStep || {});
 var BabylonBtcStakingManager = class {
-  constructor(network, stakingParams, btcProvider, babylonProvider) {
+  constructor(network, stakingParams, btcProvider, babylonProvider, ee, upgradeConfig) {
     this.network = network;
+    this.stakingParams = stakingParams;
     this.btcProvider = btcProvider;
     this.babylonProvider = babylonProvider;
+    this.ee = ee;
+    this.network = network;
     if (stakingParams.length === 0) {
       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
@@ -1931,9 +2133,11 @@ var BabylonBtcStakingManager = class {
    * @param babylonBtcTipHeight - The Babylon BTC tip height.
    * @param inputUTXOs - The UTXOs that will be used to pay for the staking
    * transaction.
-   * @param feeRate - The fee rate in satoshis per byte.
+   * @param feeRate - The fee rate in satoshis per byte. Typical value for the
+   * fee rate is above 1. If the fee rate is too low, the transaction will not
+   * be included in a block.
    * @param babylonAddress - The Babylon bech32 encoded address of the staker.
-   * @returns The signed babylon pre-staking registration transaction in base64 
+   * @returns The signed babylon pre-staking registration transaction in base64
    * format.
    */
   async preStakeRegistrationBabylonTransaction(stakerBtcInfo, stakingInput, babylonBtcTipHeight, inputUTXOs, feeRate, babylonAddress) {
@@ -1946,23 +2150,17 @@ 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,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      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,
       stakingInput,
       transaction,
@@ -1970,26 +2168,131 @@ var BabylonBtcStakingManager = class {
       stakerBtcInfo,
       params
     );
+    this.ee?.emit("delegation:create", {
+      type: "create-btc-delegation-msg"
+    });
     return {
-      signedBabylonTx: await this.babylonProvider.signTransaction(
-        "create-btc-delegation-msg" /* CREATE_BTC_DELEGATION_MSG */,
-        msg
-      ),
+      signedBabylonTx: await this.babylonProvider.signTransaction(msg),
       stakingTx: transaction
     };
   }
   /**
-   * 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 
-   * already created and included in a BTC block and we want to register it on 
+   * 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: import_bitcoinjs_lib9.Transaction.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
+   * already created and included in a BTC block and we want to register it on
    * the Babylon chain.
    * @param stakerBtcInfo - The staker BTC info which includes the BTC address
    * and the no-coord public key in hex format.
    * @param stakingTx - The staking transaction.
-   * @param stakingTxHeight - The BTC height in which the staking transaction 
+   * @param stakingTxHeight - The BTC height in which the staking transaction
    * is included.
    * @param stakingInput - The staking inputs.
-   * @param inclusionProof - The inclusion proof of the staking transaction.
+   * @param inclusionProof - Merkle Proof of Inclusion: Verifies transaction
+   * inclusion in a Bitcoin block that is k-deep.
    * @param babylonAddress - The Babylon bech32 encoded address of the staker.
    * @returns The signed babylon transaction in base64 format.
    */
@@ -2002,30 +2305,29 @@ var BabylonBtcStakingManager = class {
       this.network,
       stakerBtcInfo,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
     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,
       stakingInput,
       stakingTx,
       babylonAddress,
       stakerBtcInfo,
       params,
-      this.getInclusionProof(inclusionProof)
+      {
+        inclusionProof: this.getInclusionProof(inclusionProof)
+      }
     );
+    this.ee?.emit("delegation:register", {
+      type: "create-btc-delegation-msg"
+    });
     return {
-      signedBabylonTx: await this.babylonProvider.signTransaction(
-        "create-btc-delegation-msg" /* CREATE_BTC_DELEGATION_MSG */,
-        delegationMsg
-      )
+      signedBabylonTx: await this.babylonProvider.signTransaction(delegationMsg)
     };
   }
   /**
@@ -2037,33 +2339,28 @@ var BabylonBtcStakingManager = class {
    * @param stakingInput - The staking inputs.
    * @param inputUTXOs - The UTXOs that will be used to pay for the staking
    * transaction.
-   * @param feeRate - The fee rate in satoshis per byte.
+   * @param feeRate - The fee rate in satoshis per byte. Typical value for the
+   * fee rate is above 1. If the fee rate is too low, the transaction will not
+   * be included in a block.
    * @returns The estimated BTC fee in satoshis.
    */
   estimateBtcStakingFee(stakerBtcInfo, babylonBtcTipHeight, stakingInput, inputUTXOs, feeRate) {
     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,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { fee: stakingFee } = staking.createStakingTransaction(
-      stakingInput.stakingAmountSat,
-      inputUTXOs,
-      feeRate
-    );
+    const { fee: stakingFee } = staking.createStakingTransaction(stakingInput.stakingAmountSat, inputUTXOs, feeRate);
     return stakingFee;
   }
   /**
-   * Creates a signed staking transaction that is ready to be sent to the BTC 
+   * Creates a signed staking transaction that is ready to be sent to the BTC
    * network.
    * @param stakerBtcInfo - The staker BTC info which includes the BTC address
    * and the no-coord public key in hex format.
@@ -2084,18 +2381,129 @@ var BabylonBtcStakingManager = class {
       this.network,
       stakerBtcInfo,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const stakingPsbt2 = staking.toStakingPsbt(
-      unsignedStakingTx,
-      inputUTXOs
+    const stakingPsbt2 = staking.toStakingPsbt(unsignedStakingTx, inputUTXOs);
+    const contracts = [
+      {
+        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(stakingPsbt2.toHex(), {
+      contracts,
+      action: {
+        name: "sign-btc-staking-transaction" /* SIGN_BTC_STAKING_TRANSACTION */
+      }
+    });
+    return import_bitcoinjs_lib9.Psbt.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 signedStakingPsbtHex = await this.btcProvider.signPsbt(
-      "staking" /* STAKING */,
-      stakingPsbt2.toHex()
+    const previousParams = getBabylonParamByVersion(previousStakingTxInfo.paramVersion, this.stakingParams);
+    const stakingExpansionPsbt2 = staking.toStakingExpansionPsbt(
+      unsignedStakingExpansionTx,
+      inputUTXOs,
+      previousParams,
+      previousStakingTxInfo
+    );
+    const contracts = [
+      {
+        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 = import_bitcoinjs_lib9.Psbt.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 import_bitcoinjs_lib10.Psbt.fromHex(signedStakingPsbtHex).extractTransaction();
+    signedStakingExpansionTx.ins[0].witness = witness;
+    return signedStakingExpansionTx;
   }
   /**
    * Creates a partial signed unbonding transaction that is only signed by the
@@ -2112,36 +2520,64 @@ 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,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const {
-      transaction: unbondingTx,
-      fee
-    } = staking.createUnbondingTransaction(stakingTx);
+    const { transaction: unbondingTx, fee } = staking.createUnbondingTransaction(stakingTx);
     const psbt = staking.toUnbondingPsbt(unbondingTx, stakingTx);
-    const signedUnbondingPsbtHex = await this.btcProvider.signPsbt(
-      "unbonding" /* UNBONDING */,
-      psbt.toHex()
-    );
-    const signedUnbondingTx = import_bitcoinjs_lib10.Psbt.fromHex(
-      signedUnbondingPsbtHex
-    ).extractTransaction();
+    const contracts = [
+      {
+        id: "babylon:staking" /* STAKING */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+          covenantPks: params.covenantNoCoordPks,
+          covenantThreshold: params.covenantQuorum,
+          minUnbondingTime: params.unbondingTime,
+          stakingDuration: stakingInput.stakingTimelock
+        }
+      },
+      {
+        id: "babylon:unbonding" /* UNBONDING */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+          covenantPks: params.covenantNoCoordPks,
+          covenantThreshold: params.covenantQuorum,
+          unbondingTimeBlocks: params.unbondingTime,
+          unbondingFeeSat: params.unbondingFeeSat
+        }
+      }
+    ];
+    this.ee?.emit("delegation:unbond", {
+      stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+      finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+      covenantPks: params.covenantNoCoordPks,
+      covenantThreshold: params.covenantQuorum,
+      stakingDuration: stakingInput.stakingTimelock,
+      unbondingTimeBlocks: params.unbondingTime,
+      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 signedUnbondingTx = import_bitcoinjs_lib9.Psbt.fromHex(signedUnbondingPsbtHex).extractTransaction();
     return {
       transaction: signedUnbondingTx,
       fee
     };
   }
   /**
-   * Creates a signed unbonding transaction that is ready to be sent to the BTC 
+   * Creates a signed unbonding transaction that is ready to be sent to the BTC
    * network.
    * @param stakerBtcInfo - The staker BTC info which includes the BTC address
    * and the no-coord public key in hex format.
@@ -2155,27 +2591,17 @@ 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 {
-      transaction: signedUnbondingTx,
-      fee
-    } = await this.createPartialSignedBtcUnbondingTransaction(
+    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
+    const { transaction: signedUnbondingTx, fee } = await this.createPartialSignedBtcUnbondingTransaction(
       stakerBtcInfo,
       stakingInput,
       stakingParamsVersion,
       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
@@ -2192,42 +2618,54 @@ var BabylonBtcStakingManager = class {
     };
   }
   /**
-   * Creates a signed withdrawal transaction on the unbodning output expiry path 
+   * Creates a signed withdrawal transaction on the unbodning output expiry path
    * that is ready to be sent to the BTC network.
    * @param stakingInput - The staking inputs.
    * @param stakingParamsVersion - The params version that was used to create the
    * delegation in Babylon chain
    * @param earlyUnbondingTx - The early unbonding transaction.
-   * @param feeRate - The fee rate in satoshis per byte.
+   * @param feeRate - The fee rate in satoshis per byte. Typical value for the
+   * fee rate is above 1. If the fee rate is too low, the transaction will not
+   * be included in a block.
    * @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,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { psbt: unbondingPsbt2, fee } = staking.createWithdrawEarlyUnbondedTransaction(
-      earlyUnbondingTx,
-      feeRate
-    );
-    const signedWithdrawalPsbtHex = await this.btcProvider.signPsbt(
-      "withdraw-early-unbonded" /* WITHDRAW_EARLY_UNBONDED */,
-      unbondingPsbt2.toHex()
-    );
+    const { psbt: unbondingPsbt2, fee } = staking.createWithdrawEarlyUnbondedTransaction(earlyUnbondingTx, feeRate);
+    const contracts = [
+      {
+        id: "babylon:withdraw" /* WITHDRAW */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          timelockBlocks: params.unbondingTime
+        }
+      }
+    ];
+    this.ee?.emit("delegation:withdraw", {
+      stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+      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 */
+      }
+    });
     return {
-      transaction: import_bitcoinjs_lib10.Psbt.fromHex(signedWithdrawalPsbtHex).extractTransaction(),
+      transaction: import_bitcoinjs_lib9.Psbt.fromHex(signedWithdrawalPsbtHex).extractTransaction(),
       fee
     };
   }
   /**
-   * Creates a signed withdrawal transaction on the staking output expiry path 
+   * Creates a signed withdrawal transaction on the staking output expiry path
    * that is ready to be sent to the BTC network.
    * @param stakerBtcInfo - The staker BTC info which includes the BTC address
    * and the no-coord public key in hex format.
@@ -2235,36 +2673,48 @@ var BabylonBtcStakingManager = class {
    * @param stakingParamsVersion - The params version that was used to create the
    * delegation in Babylon chain
    * @param stakingTx - The staking transaction.
-   * @param feeRate - The fee rate in satoshis per byte.
+   * @param feeRate - The fee rate in satoshis per byte. Typical value for the
+   * fee rate is above 1. If the fee rate is too low, the transaction will not
+   * be included in a block.
    * @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,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { psbt, fee } = staking.createWithdrawStakingExpiredPsbt(
-      stakingTx,
-      feeRate
-    );
-    const signedWithdrawalPsbtHex = await this.btcProvider.signPsbt(
-      "withdraw-staking-expired" /* WITHDRAW_STAKING_EXPIRED */,
-      psbt.toHex()
-    );
+    const { psbt, fee } = staking.createWithdrawStakingExpiredPsbt(stakingTx, feeRate);
+    const contracts = [
+      {
+        id: "babylon:withdraw" /* WITHDRAW */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          timelockBlocks: stakingInput.stakingTimelock
+        }
+      }
+    ];
+    this.ee?.emit("delegation:withdraw", {
+      stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+      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 */
+      }
+    });
     return {
-      transaction: import_bitcoinjs_lib10.Psbt.fromHex(signedWithdrawalPsbtHex).extractTransaction(),
+      transaction: import_bitcoinjs_lib9.Psbt.fromHex(signedWithdrawalPsbtHex).extractTransaction(),
       fee
     };
   }
   /**
-   * Creates a signed withdrawal transaction for the expired slashing output that 
+   * Creates a signed withdrawal transaction for the expired slashing output that
    * is ready to be sent to the BTC network.
    * @param stakerBtcInfo - The staker BTC info which includes the BTC address
    * and the no-coord public key in hex format.
@@ -2272,31 +2722,43 @@ var BabylonBtcStakingManager = class {
    * @param stakingParamsVersion - The params version that was used to create the
    * delegation in Babylon chain
    * @param slashingTx - The slashing transaction.
-   * @param feeRate - The fee rate in satoshis per byte.
+   * @param feeRate - The fee rate in satoshis per byte. Typical value for the
+   * fee rate is above 1. If the fee rate is too low, the transaction will not
+   * be included in a block.
    * @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,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { psbt, fee } = staking.createWithdrawSlashingPsbt(
-      slashingTx,
-      feeRate
-    );
-    const signedSlashingPsbtHex = await this.btcProvider.signPsbt(
-      "withdraw-slashing" /* WITHDRAW_SLASHING */,
-      psbt.toHex()
-    );
+    const { psbt, fee } = staking.createWithdrawSlashingPsbt(slashingTx, feeRate);
+    const contracts = [
+      {
+        id: "babylon:withdraw" /* WITHDRAW */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          timelockBlocks: params.unbondingTime
+        }
+      }
+    ];
+    this.ee?.emit("delegation:withdraw", {
+      stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+      timelockBlocks: params.unbondingTime,
+      type: "slashing"
+    });
+    const signedWithrawSlashingPsbtHex = await this.btcProvider.signPsbt(psbt.toHex(), {
+      contracts,
+      action: {
+        name: "sign-btc-withdraw-transaction" /* SIGN_BTC_WITHDRAW_TRANSACTION */
+      }
+    });
     return {
-      transaction: import_bitcoinjs_lib10.Psbt.fromHex(signedSlashingPsbtHex).extractTransaction(),
+      transaction: import_bitcoinjs_lib9.Psbt.fromHex(signedWithrawSlashingPsbtHex).extractTransaction(),
       fee
     };
   }
@@ -2305,28 +2767,54 @@ var BabylonBtcStakingManager = class {
    * @param bech32Address - The staker's bech32 address.
    * @returns The proof of possession.
    */
-  async createProofOfPossession(bech32Address) {
-    if (!this.btcProvider.signMessage) {
-      throw new Error("Sign message function not found");
-    }
-    const bech32AddressHex = uint8ArrayToHex((0, import_encoding2.fromBech32)(bech32Address).data);
-    const signedBabylonAddress = await this.btcProvider.signMessage(
-      "proof-of-possession" /* PROOF_OF_POSSESSION */,
-      bech32AddressHex,
-      "ecdsa"
+  async createProofOfPossession(channel, bech32Address, stakerBtcAddress) {
+    let sigType = import_pop.BTCSigType.ECDSA;
+    if (isTaproot(stakerBtcAddress, this.network) || isNativeSegwit(stakerBtcAddress, this.network)) {
+      sigType = import_pop.BTCSigType.BIP322;
+    }
+    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
+      }
     );
-    const ecdsaSig = Uint8Array.from(Buffer.from(signedBabylonAddress, "base64"));
+    this.ee?.emit(channel, {
+      messageToSign,
+      type: "proof-of-possession"
+    });
+    const signedBabylonAddress = await this.btcProvider.signMessage(
+      messageToSign,
+      sigType === import_pop.BTCSigType.BIP322 ? "bip322-simple" : "ecdsa"
+    );
+    let btcSig;
+    if (sigType === import_pop.BTCSigType.BIP322) {
+      const bip322Sig = import_pop.BIP322Sig.fromPartial({
+        address: stakerBtcAddress,
+        sig: Buffer.from(signedBabylonAddress, "base64")
+      });
+      btcSig = import_pop.BIP322Sig.encode(bip322Sig).finish();
+    } else {
+      btcSig = Buffer.from(signedBabylonAddress, "base64");
+    }
     return {
-      btcSigType: import_pop.BTCSigType.ECDSA,
-      btcSig: ecdsaSig
+      btcSigType: sigType,
+      btcSig
     };
   }
   /**
-   * Creates the unbonding, slashing, and unbonding slashing transactions and 
+   * Creates the unbonding, slashing, and unbonding slashing transactions and
    * PSBTs.
    * @param stakingInstance - The staking instance.
    * @param stakingTx - The staking transaction.
-   * @returns The unbonding, slashing, and unbonding slashing transactions and 
+   * @returns The unbonding, slashing, and unbonding slashing transactions and
    * PSBTs.
    */
   async createDelegationTransactionsAndPsbts(stakingInstance, stakingTx) {
@@ -2341,81 +2829,164 @@ var BabylonBtcStakingManager = class {
   }
   /**
    * Creates a protobuf message for the BTC delegation.
+   * @param channel - The event channel to emit the message on.
    * @param stakingInstance - The staking instance.
    * @param stakingInput - The staking inputs.
    * @param stakingTx - The staking transaction.
    * @param bech32Address - The staker's babylon chain bech32 address
-   * @param stakerBtcInfo - The staker's BTC information such as address and 
+   * @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(stakingInstance, stakingInput, stakingTx, bech32Address, stakerBtcInfo, params, inclusionProof) {
-    const {
-      unbondingTx,
-      slashingPsbt,
-      unbondingSlashingPsbt
-    } = await this.createDelegationTransactionsAndPsbts(
+  async createBtcDelegationMsg(channel, stakingInstance, stakingInput, stakingTx, bech32Address, stakerBtcInfo, params, options) {
+    if (!params.slashing) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Slashing parameters are required for creating delegation message"
+      );
+    }
+    const { unbondingTx, slashingPsbt, unbondingSlashingPsbt } = await this.createDelegationTransactionsAndPsbts(
       stakingInstance,
       stakingTx
     );
-    const signedSlashingPsbtHex = await this.btcProvider.signPsbt(
-      "staking-slashing" /* STAKING_SLASHING */,
-      slashingPsbt.toHex()
-    );
-    const signedSlashingTx = import_bitcoinjs_lib10.Psbt.fromHex(
-      signedSlashingPsbtHex
-    ).extractTransaction();
-    const slashingSig = extractFirstSchnorrSignatureFromTransaction(
-      signedSlashingTx
-    );
+    const slashingContracts = [
+      {
+        id: "babylon:staking" /* STAKING */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+          covenantPks: params.covenantNoCoordPks,
+          covenantThreshold: params.covenantQuorum,
+          minUnbondingTime: params.unbondingTime,
+          stakingDuration: stakingInput.stakingTimelock
+        }
+      },
+      {
+        id: "babylon:slashing" /* SLASHING */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          unbondingTimeBlocks: params.unbondingTime,
+          slashingFeeSat: params.slashing.minSlashingTxFeeSat
+        }
+      },
+      {
+        id: "babylon:slashing-burn" /* SLASHING_BURN */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          slashingPkScriptHex: params.slashing.slashingPkScriptHex
+        }
+      }
+    ];
+    this.ee?.emit(channel, {
+      stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+      finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+      covenantPks: params.covenantNoCoordPks,
+      covenantThreshold: params.covenantQuorum,
+      unbondingTimeBlocks: params.unbondingTime,
+      stakingDuration: stakingInput.stakingTimelock,
+      slashingFeeSat: params.slashing.minSlashingTxFeeSat,
+      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 signedSlashingTx = import_bitcoinjs_lib9.Psbt.fromHex(signedSlashingPsbtHex).extractTransaction();
+    const slashingSig = extractFirstSchnorrSignatureFromTransaction(signedSlashingTx);
     if (!slashingSig) {
       throw new Error("No signature found in the staking output slashing PSBT");
     }
-    const signedUnbondingSlashingPsbtHex = await this.btcProvider.signPsbt(
-      "unbonding-slashing" /* UNBONDING_SLASHING */,
-      unbondingSlashingPsbt.toHex()
-    );
-    const signedUnbondingSlashingTx = import_bitcoinjs_lib10.Psbt.fromHex(
-      signedUnbondingSlashingPsbtHex
-    ).extractTransaction();
-    const unbondingSignatures = extractFirstSchnorrSignatureFromTransaction(
-      signedUnbondingSlashingTx
-    );
+    const unbondingSlashingContracts = [
+      {
+        id: "babylon:unbonding" /* UNBONDING */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+          covenantPks: params.covenantNoCoordPks,
+          covenantThreshold: params.covenantQuorum,
+          unbondingTimeBlocks: params.unbondingTime,
+          unbondingFeeSat: params.unbondingFeeSat
+        }
+      },
+      {
+        id: "babylon:slashing" /* SLASHING */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          unbondingTimeBlocks: params.unbondingTime,
+          slashingFeeSat: params.slashing.minSlashingTxFeeSat
+        }
+      },
+      {
+        id: "babylon:slashing-burn" /* SLASHING_BURN */,
+        params: {
+          stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+          slashingPkScriptHex: params.slashing.slashingPkScriptHex
+        }
+      }
+    ];
+    this.ee?.emit(channel, {
+      stakerPk: stakerBtcInfo.publicKeyNoCoordHex,
+      finalityProviders: stakingInput.finalityProviderPksNoCoordHex,
+      covenantPks: params.covenantNoCoordPks,
+      covenantThreshold: params.covenantQuorum,
+      unbondingTimeBlocks: params.unbondingTime,
+      unbondingFeeSat: params.unbondingFeeSat,
+      slashingFeeSat: params.slashing.minSlashingTxFeeSat,
+      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 signedUnbondingSlashingTx = import_bitcoinjs_lib9.Psbt.fromHex(signedUnbondingSlashingPsbtHex).extractTransaction();
+    const unbondingSignatures = extractFirstSchnorrSignatureFromTransaction(signedUnbondingSlashingTx);
     if (!unbondingSignatures) {
       throw new Error("No signature found in the unbonding output slashing PSBT");
     }
-    const proofOfPossession = await this.createProofOfPossession(bech32Address);
-    const msg = import_babylon_proto_ts.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: [
-        Uint8Array.from(
-          Buffer.from(stakingInput.finalityProviderPkNoCoordHex, "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 = import_babylon_proto_ts.btcstakingtx.MsgBtcStakeExpand.fromPartial({
+        ...commonMsg,
+        previousStakingTxHash: options.delegationExpansionInfo.previousStakingTx.getId(),
+        fundingTx
+      });
+      return {
+        typeUrl: BABYLON_REGISTRY_TYPE_URLS.MsgBtcStakeExpand,
+        value: msg2
+      };
+    }
+    const msg = import_babylon_proto_ts.btcstakingtx.MsgCreateBTCDelegation.fromPartial({
+      ...commonMsg,
+      stakingTxInclusionProof: options?.inclusionProof
     });
     return {
       typeUrl: BABYLON_REGISTRY_TYPE_URLS.MsgCreateBTCDelegation,
@@ -2429,11 +3000,7 @@ var BabylonBtcStakingManager = class {
    * @returns The inclusion proof.
    */
   getInclusionProof(inclusionProof) {
-    const {
-      pos,
-      merkle,
-      blockHashHex
-    } = inclusionProof;
+    const { pos, merkle, blockHashHex } = inclusionProof;
     const proofHex = deriveMerkleProof(merkle);
     const hash = reverseBuffer(Uint8Array.from(Buffer.from(blockHashHex, "hex")));
     const inclusionProofKey = import_babylon_proto_ts.btccheckpoint.TransactionKey.fromPartial({
@@ -2446,55 +3013,236 @@ 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");
+  }
+};
+
+// src/staking/observable/observableStakingScript.ts
+var import_bitcoinjs_lib10 = require("bitcoinjs-lib");
+var ObservableStakingScriptData = class extends StakingScriptData {
+  constructor(stakerKey, finalityProviderKeys, covenantKeys, covenantThreshold, stakingTimelock, unbondingTimelock, magicBytes) {
+    super(
+      stakerKey,
+      finalityProviderKeys,
+      covenantKeys,
+      covenantThreshold,
+      stakingTimelock,
+      unbondingTimelock
+    );
+    if (!magicBytes) {
+      throw new Error("Missing required input values");
+    }
+    if (magicBytes.length != MAGIC_BYTES_LEN) {
+      throw new Error("Invalid script data provided");
+    }
+    this.magicBytes = magicBytes;
+  }
+  /**
+   * Builds a data embed script for staking in the form:
+   *    OP_RETURN || <serializedStakingData>
+   * where serializedStakingData is the concatenation of:
+   *    MagicBytes || Version || StakerPublicKey || FinalityProviderPublicKey || StakingTimeLock
+   * Note: Only a single finality provider key is supported for now in phase 1
+   * @throws {Error} If the number of finality provider keys is not equal to 1.
+   * @returns {Buffer} The compiled data embed script.
+   */
+  buildDataEmbedScript() {
+    if (this.finalityProviderKeys.length != 1) {
+      throw new Error("Only a single finality provider key is supported");
+    }
+    const version = Buffer.alloc(1);
+    version.writeUInt8(0);
+    const stakingTimeLock = Buffer.alloc(2);
+    stakingTimeLock.writeUInt16BE(this.stakingTimeLock);
+    const serializedStakingData = Buffer.concat([
+      this.magicBytes,
+      version,
+      this.stakerKey,
+      this.finalityProviderKeys[0],
+      stakingTimeLock
+    ]);
+    return import_bitcoinjs_lib10.script.compile([import_bitcoinjs_lib10.opcodes.OP_RETURN, serializedStakingData]);
+  }
+  /**
+   * Builds the staking scripts.
+   * @returns {ObservableStakingScripts} The staking scripts that can be used to stake.
+   * contains the timelockScript, unbondingScript, slashingScript,
+   * unbondingTimelockScript, and dataEmbedScript.
+   * @throws {Error} If script data is invalid.
+   */
+  buildScripts() {
+    const scripts = super.buildScripts();
+    return {
+      ...scripts,
+      dataEmbedScript: this.buildDataEmbedScript()
+    };
+  }
+};
+
+// src/staking/observable/index.ts
+var ObservableStaking = class extends Staking {
+  constructor(network, stakerInfo, params, finalityProviderPksNoCoordHex, stakingTimelock) {
+    super(
+      network,
+      stakerInfo,
+      params,
+      finalityProviderPksNoCoordHex,
+      stakingTimelock
+    );
+    if (!params.tag) {
+      throw new StakingError(
+        "INVALID_INPUT" /* INVALID_INPUT */,
+        "Observable staking parameters must include tag"
+      );
+    }
+    if (!params.btcActivationHeight) {
+      throw new StakingError(
+        "INVALID_INPUT" /* INVALID_INPUT */,
+        "Observable staking parameters must include a positive activation height"
+      );
+    }
+    if (finalityProviderPksNoCoordHex.length !== 1) {
+      throw new StakingError(
+        "INVALID_INPUT" /* INVALID_INPUT */,
+        "Observable staking requires exactly one finality provider public key"
+      );
+    }
+    this.params = params;
+  }
+  /**
+   * Build the staking scripts for observable staking.
+   * This method overwrites the base method to include the OP_RETURN tag based 
+   * on the tag provided in the parameters.
+   * 
+   * @returns {ObservableStakingScripts} - The staking scripts for observable staking.
+   * @throws {StakingError} - If the scripts cannot be built.
+   */
+  buildScripts() {
+    const { covenantQuorum, covenantNoCoordPks, unbondingTime, tag } = this.params;
+    let stakingScriptData;
+    try {
+      stakingScriptData = new ObservableStakingScriptData(
+        Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex"),
+        this.finalityProviderPksNoCoordHex.map((pk) => Buffer.from(pk, "hex")),
+        toBuffers(covenantNoCoordPks),
+        covenantQuorum,
+        this.stakingTimelock,
+        unbondingTime,
+        Buffer.from(tag, "hex")
+      );
+    } catch (error) {
+      throw StakingError.fromUnknown(
+        error,
+        "SCRIPT_FAILURE" /* SCRIPT_FAILURE */,
+        "Cannot build staking script data"
+      );
+    }
+    let scripts;
+    try {
+      scripts = stakingScriptData.buildScripts();
+    } catch (error) {
+      throw StakingError.fromUnknown(
+        error,
+        "SCRIPT_FAILURE" /* SCRIPT_FAILURE */,
+        "Cannot build staking scripts"
+      );
+    }
+    return scripts;
+  }
+  /**
+   * Create a staking transaction for observable staking.
+   * This overwrites the method from the Staking class with the addtion
+   * of the 
+   * 1. OP_RETURN tag in the staking scripts
+   * 2. lockHeight parameter
+   * 
+   * @param {number} stakingAmountSat - The amount to stake in satoshis.
+   * @param {UTXO[]} inputUTXOs - The UTXOs to use as inputs for the staking 
+   * transaction.
+   * @param {number} feeRate - The fee rate for the transaction in satoshis per byte.
+   * @returns {TransactionResult} - An object containing the unsigned transaction,
+   * and fee
+   */
+  createStakingTransaction(stakingAmountSat, inputUTXOs, feeRate) {
+    validateStakingTxInputData(
+      stakingAmountSat,
+      this.stakingTimelock,
+      this.params,
+      inputUTXOs,
+      feeRate
+    );
+    const scripts = this.buildScripts();
+    try {
+      const { transaction, fee } = stakingTransaction(
+        scripts,
+        stakingAmountSat,
+        this.stakerInfo.address,
+        inputUTXOs,
+        this.network,
+        feeRate,
+        // `lockHeight` is exclusive of the provided value.
+        // For example, if a Bitcoin height of X is provided,
+        // the transaction will be included starting from height X+1.
+        // https://learnmeabitcoin.com/technical/transaction/locktime/
+        this.params.btcActivationHeight - 1
+      );
+      return {
+        transaction,
+        fee
+      };
+    } catch (error) {
+      throw StakingError.fromUnknown(
+        error,
+        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
+        "Cannot build unsigned staking transaction"
+      );
+    }
+  }
+  /**
+   * Create a staking psbt for observable staking.
+   * 
+   * @param {Transaction} stakingTx - The staking transaction.
+   * @param {UTXO[]} inputUTXOs - The UTXOs to use as inputs for the staking 
+   * transaction.
+   * @returns {Psbt} - The psbt.
+   */
+  toStakingPsbt(stakingTx, inputUTXOs) {
+    return stakingPsbt(
+      stakingTx,
+      this.network,
+      inputUTXOs,
+      isTaproot(
+        this.stakerInfo.address,
+        this.network
+      ) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : void 0
     );
   }
 };
+
+// src/types/params.ts
+function hasSlashing(params) {
+  return params.slashing !== void 0;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BabylonBtcStakingManager,
   BitcoinScriptType,
   ObservableStaking,
   ObservableStakingScriptData,
-  SigningStep,
   Staking,
   StakingScriptData,
   buildStakingTransactionOutputs,
+  clearTxSignatures,
   createCovenantWitness,
+  deriveMerkleProof,
   deriveSlashingOutput,
   deriveStakingOutputInfo,
   deriveUnbondingOutputInfo,
+  extractFirstSchnorrSignatureFromTransaction,
   findInputUTXO,
   findMatchingTxOutputIndex,
   getBabylonParamByBtcHeight,
@@ -2503,21 +3251,22 @@ var getUnbondingTxStakerSignature = (unbondingTx) => {
   getPublicKeyNoCoord,
   getScriptType,
   getUnbondingTxStakerSignature,
+  hasSlashing,
   initBTCCurve,
+  isNativeSegwit,
   isTaproot,
   isValidBabylonAddress,
   isValidBitcoinAddress,
   isValidNoCoordPublicKey,
   slashEarlyUnbondedTransaction,
   slashTimelockUnbondedTransaction,
+  stakingExpansionTransaction,
   stakingTransaction,
   toBuffers,
   transactionIdToHash,
   unbondingTransaction,
-  validateParams,
-  validateStakingTimelock,
-  validateStakingTxInputData,
   withdrawEarlyUnbondedTransaction,
   withdrawSlashingTransaction,
   withdrawTimelockUnbondedTransaction
 });
+//# sourceMappingURL=index.cjs.map