@bitgo-beta/babylonlabs-io-btc-staking-ts 0.4.0-beta.51 → 0.4.0-beta.510

package/dist/index.cjs

@@ -34,7 +34,6 @@ __export(src_exports, {
   BitcoinScriptType: () => BitcoinScriptType,
   ObservableStaking: () => ObservableStaking,
   ObservableStakingScriptData: () => ObservableStakingScriptData,
-  SigningStep: () => SigningStep,
   Staking: () => Staking,
   StakingScriptData: () => StakingScriptData,
   buildStakingTransactionOutputs: () => buildStakingTransactionOutputs,
@@ -50,7 +49,9 @@ __export(src_exports, {
   getPublicKeyNoCoord: () => getPublicKeyNoCoord,
   getScriptType: () => getScriptType,
   getUnbondingTxStakerSignature: () => getUnbondingTxStakerSignature,
+  hasSlashing: () => hasSlashing,
   initBTCCurve: () => initBTCCurve,
+  isNativeSegwit: () => isNativeSegwit,
   isTaproot: () => isTaproot,
   isValidBabylonAddress: () => isValidBabylonAddress,
   isValidBitcoinAddress: () => isValidBitcoinAddress,
@@ -70,13 +71,547 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/staking/stakingScript.ts
+// src/error/index.ts
+var StakingError = class _StakingError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  // Static method to safely handle unknown errors
+  static fromUnknown(error, code, fallbackMsg) {
+    if (error instanceof _StakingError) {
+      return error;
+    }
+    if (error instanceof Error) {
+      return new _StakingError(code, error.message);
+    }
+    return new _StakingError(code, fallbackMsg);
+  }
+};
+
+// src/utils/btc.ts
+var ecc = __toESM(require("@bitcoin-js/tiny-secp256k1-asmjs"), 1);
 var import_bitcoinjs_lib = require("bitcoinjs-lib");
 
-// src/constants/keys.ts
-var NO_COORD_PK_BYTE_LENGTH = 32;
+// src/constants/keys.ts
+var NO_COORD_PK_BYTE_LENGTH = 32;
+
+// src/utils/btc.ts
+var initBTCCurve = () => {
+  (0, import_bitcoinjs_lib.initEccLib)(ecc);
+};
+var isValidBitcoinAddress = (btcAddress, network) => {
+  try {
+    return !!import_bitcoinjs_lib.address.toOutputScript(btcAddress, network);
+  } catch (error) {
+    return false;
+  }
+};
+var isTaproot = (taprootAddress, network) => {
+  try {
+    const decoded = import_bitcoinjs_lib.address.fromBech32(taprootAddress);
+    if (decoded.version !== 1) {
+      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;
+  }
+};
+var isValidNoCoordPublicKey = (pkWithNoCoord) => {
+  try {
+    const keyBuffer = Buffer.from(pkWithNoCoord, "hex");
+    return validateNoCoordPublicKeyBuffer(keyBuffer);
+  } catch (error) {
+    return false;
+  }
+};
+var getPublicKeyNoCoord = (pkHex) => {
+  const publicKey = Buffer.from(pkHex, "hex");
+  const publicKeyNoCoordBuffer = publicKey.length === NO_COORD_PK_BYTE_LENGTH ? publicKey : publicKey.subarray(1, 33);
+  if (!validateNoCoordPublicKeyBuffer(publicKeyNoCoordBuffer)) {
+    throw new Error("Invalid public key without coordinate");
+  }
+  return publicKeyNoCoordBuffer.toString("hex");
+};
+var validateNoCoordPublicKeyBuffer = (pkBuffer) => {
+  if (pkBuffer.length !== NO_COORD_PK_BYTE_LENGTH) {
+    return false;
+  }
+  const compressedKeyEven = Buffer.concat([Buffer.from([2]), pkBuffer]);
+  const compressedKeyOdd = Buffer.concat([Buffer.from([3]), pkBuffer]);
+  return ecc.isPoint(compressedKeyEven) || ecc.isPoint(compressedKeyOdd);
+};
+var transactionIdToHash = (txId) => {
+  if (txId === "") {
+    throw new Error("Transaction id cannot be empty");
+  }
+  return Buffer.from(txId, "hex").reverse();
+};
+
+// src/utils/staking/index.ts
+var import_bitcoinjs_lib2 = require("bitcoinjs-lib");
+
+// src/constants/internalPubkey.ts
+var key = "0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
+var internalPubkey = Buffer.from(key, "hex").subarray(1, 33);
+
+// src/constants/unbonding.ts
+var MIN_UNBONDING_OUTPUT_VALUE = 1e3;
+
+// src/utils/staking/index.ts
+var buildStakingTransactionOutputs = (scripts, network, amount) => {
+  const stakingOutputInfo = deriveStakingOutputInfo(scripts, network);
+  const transactionOutputs = [
+    {
+      scriptPubKey: stakingOutputInfo.scriptPubKey,
+      value: amount
+    }
+  ];
+  if (scripts.dataEmbedScript) {
+    transactionOutputs.push({
+      scriptPubKey: scripts.dataEmbedScript,
+      value: 0
+    });
+  }
+  return transactionOutputs;
+};
+var deriveStakingOutputInfo = (scripts, network) => {
+  const scriptTree = [
+    {
+      output: scripts.slashingScript
+    },
+    [{ output: scripts.unbondingScript }, { output: scripts.timelockScript }]
+  ];
+  const stakingOutput = import_bitcoinjs_lib2.payments.p2tr({
+    internalPubkey,
+    scriptTree,
+    network
+  });
+  if (!stakingOutput.address) {
+    throw new StakingError(
+      "INVALID_OUTPUT" /* INVALID_OUTPUT */,
+      "Failed to build staking output"
+    );
+  }
+  return {
+    outputAddress: stakingOutput.address,
+    scriptPubKey: import_bitcoinjs_lib2.address.toOutputScript(stakingOutput.address, network)
+  };
+};
+var deriveUnbondingOutputInfo = (scripts, network) => {
+  const outputScriptTree = [
+    {
+      output: scripts.slashingScript
+    },
+    { output: scripts.unbondingTimelockScript }
+  ];
+  const unbondingOutput = import_bitcoinjs_lib2.payments.p2tr({
+    internalPubkey,
+    scriptTree: outputScriptTree,
+    network
+  });
+  if (!unbondingOutput.address) {
+    throw new StakingError(
+      "INVALID_OUTPUT" /* INVALID_OUTPUT */,
+      "Failed to build unbonding output"
+    );
+  }
+  return {
+    outputAddress: unbondingOutput.address,
+    scriptPubKey: import_bitcoinjs_lib2.address.toOutputScript(unbondingOutput.address, network)
+  };
+};
+var deriveSlashingOutput = (scripts, network) => {
+  const slashingOutput = import_bitcoinjs_lib2.payments.p2tr({
+    internalPubkey,
+    scriptTree: { output: scripts.unbondingTimelockScript },
+    network
+  });
+  const slashingOutputAddress = slashingOutput.address;
+  if (!slashingOutputAddress) {
+    throw new StakingError(
+      "INVALID_OUTPUT" /* INVALID_OUTPUT */,
+      "Failed to build slashing output address"
+    );
+  }
+  return {
+    outputAddress: slashingOutputAddress,
+    scriptPubKey: import_bitcoinjs_lib2.address.toOutputScript(slashingOutputAddress, network)
+  };
+};
+var findMatchingTxOutputIndex = (tx, outputAddress, network) => {
+  const index = tx.outs.findIndex((output) => {
+    try {
+      return import_bitcoinjs_lib2.address.fromOutputScript(output.script, network) === outputAddress;
+    } catch (error) {
+      return false;
+    }
+  });
+  if (index === -1) {
+    throw new StakingError(
+      "INVALID_OUTPUT" /* INVALID_OUTPUT */,
+      `Matching output not found for address: ${outputAddress}`
+    );
+  }
+  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"));
+  } catch (error) {
+    throw StakingError.fromUnknown(
+      error,
+      "INVALID_INPUT" /* INVALID_INPUT */,
+      "Cannot convert values to buffers"
+    );
+  }
+};
+
+// src/staking/psbt.ts
+var import_bitcoinjs_lib4 = require("bitcoinjs-lib");
+
+// src/constants/transaction.ts
+var REDEEM_VERSION = 192;
+
+// 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 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) {
@@ -118,13 +653,13 @@ var StakingScriptData = class {
     if (allPks.length !== allPksSet.size) {
       return false;
     }
-    if (this.covenantThreshold == 0 || this.covenantThreshold > this.covenantKeys.length) {
+    if (this.covenantThreshold <= 0 || this.covenantThreshold > this.covenantKeys.length) {
       return false;
     }
-    if (this.stakingTimeLock == 0 || this.stakingTimeLock > 65535) {
+    if (this.stakingTimeLock <= 0 || this.stakingTimeLock > 65535) {
       return false;
     }
-    if (this.unbondingTimeLock == 0 || this.unbondingTimeLock > 65535) {
+    if (this.unbondingTimeLock <= 0 || this.unbondingTimeLock > 65535) {
       return false;
     }
     return true;
@@ -138,11 +673,11 @@ var StakingScriptData = class {
    * @returns {Buffer} containing the compiled timelock script.
    */
   buildTimelockScript(timelock) {
-    return import_bitcoinjs_lib.script.compile([
+    return import_bitcoinjs_lib5.script.compile([
       this.stakerKey,
-      import_bitcoinjs_lib.opcodes.OP_CHECKSIGVERIFY,
-      import_bitcoinjs_lib.script.number.encode(timelock),
-      import_bitcoinjs_lib.opcodes.OP_CHECKSEQUENCEVERIFY
+      import_bitcoinjs_lib5.opcodes.OP_CHECKSIGVERIFY,
+      import_bitcoinjs_lib5.script.number.encode(timelock),
+      import_bitcoinjs_lib5.opcodes.OP_CHECKSEQUENCEVERIFY
     ]);
   }
   /**
@@ -245,9 +780,9 @@ var StakingScriptData = class {
     if (pk.length != NO_COORD_PK_BYTE_LENGTH) {
       throw new Error("Invalid key length");
     }
-    return import_bitcoinjs_lib.script.compile([
+    return import_bitcoinjs_lib5.script.compile([
       pk,
-      withVerify ? import_bitcoinjs_lib.opcodes.OP_CHECKSIGVERIFY : import_bitcoinjs_lib.opcodes.OP_CHECKSIG
+      withVerify ? import_bitcoinjs_lib5.opcodes.OP_CHECKSIGVERIFY : import_bitcoinjs_lib5.opcodes.OP_CHECKSIG
     ]);
   }
   /**
@@ -265,131 +800,47 @@ var StakingScriptData = class {
   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) {
-    super(message);
-    this.code = code;
-  }
-  // Static method to safely handle unknown errors
-  static fromUnknown(error, code, fallbackMsg) {
-    if (error instanceof _StakingError) {
-      return error;
-    }
-    if (error instanceof Error) {
-      return new _StakingError(code, error.message);
-    }
-    return new _StakingError(code, fallbackMsg);
-  }
-};
-
-// src/staking/transactions.ts
-var import_bitcoinjs_lib6 = require("bitcoinjs-lib");
-
-// src/constants/dustSat.ts
-var BTC_DUST_SAT = 546;
-
-// src/constants/internalPubkey.ts
-var key = "0250929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
-var internalPubkey = Buffer.from(key, "hex").subarray(1, 33);
-
-// 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);
-};
-var isValidBitcoinAddress = (btcAddress, network) => {
-  try {
-    return !!import_bitcoinjs_lib2.address.toOutputScript(btcAddress, network);
-  } catch (error) {
-    return false;
-  }
-};
-var isTaproot = (taprootAddress, network) => {
-  try {
-    const decoded = import_bitcoinjs_lib2.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;
-    }
-  } catch (error) {
-    return false;
-  }
-};
-var isValidNoCoordPublicKey = (pkWithNoCoord) => {
-  try {
-    const keyBuffer = Buffer.from(pkWithNoCoord, "hex");
-    return validateNoCoordPublicKeyBuffer(keyBuffer);
-  } catch (error) {
-    return false;
-  }
-};
-var getPublicKeyNoCoord = (pkHex) => {
-  const publicKey = Buffer.from(pkHex, "hex");
-  const publicKeyNoCoordBuffer = publicKey.length === NO_COORD_PK_BYTE_LENGTH ? publicKey : publicKey.subarray(1, 33);
-  if (!validateNoCoordPublicKeyBuffer(publicKeyNoCoordBuffer)) {
-    throw new Error("Invalid public key without coordinate");
-  }
-  return publicKeyNoCoordBuffer.toString("hex");
-};
-var validateNoCoordPublicKeyBuffer = (pkBuffer) => {
-  if (pkBuffer.length !== NO_COORD_PK_BYTE_LENGTH) {
-    return false;
-  }
-  const compressedKeyEven = Buffer.concat([Buffer.from([2]), pkBuffer]);
-  const compressedKeyOdd = Buffer.concat([Buffer.from([3]), pkBuffer]);
-  return ecc.isPoint(compressedKeyEven) || ecc.isPoint(compressedKeyOdd);
-};
-var transactionIdToHash = (txId) => {
-  if (txId === "") {
-    throw new Error("Transaction id cannot be empty");
+    }
+    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);
   }
-  return Buffer.from(txId, "hex").reverse();
 };
 
+// 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_lib4 = require("bitcoinjs-lib");
+var import_bitcoinjs_lib7 = require("bitcoinjs-lib");
 
 // src/constants/fee.ts
 var DEFAULT_INPUT_SIZE = 180;
@@ -404,14 +855,14 @@ 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 import_bitcoinjs_lib6 = 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;
+  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_lib3.payments.p2wpkh({
+    const { address: p2wpkhAddress } = import_bitcoinjs_lib6.payments.p2wpkh({
       output: script4
     });
     if (p2wpkhAddress) {
@@ -420,7 +871,7 @@ var getInputSizeByScript = (script4) => {
   } catch (error) {
   }
   try {
-    const { address: p2trAddress } = import_bitcoinjs_lib3.payments.p2tr({
+    const { address: p2trAddress } = import_bitcoinjs_lib6.payments.p2tr({
       output: script4
     });
     if (p2trAddress) {
@@ -444,7 +895,7 @@ var getStakingTxInputUTXOsAndFees = (availableUTXOs, stakingAmount, feeRate, out
   }
   const validUTXOs = availableUTXOs.filter((utxo) => {
     const script4 = Buffer.from(utxo.scriptPubKey, "hex");
-    return !!import_bitcoinjs_lib4.script.decompile(script4);
+    return !!import_bitcoinjs_lib7.script.decompile(script4);
   });
   if (validUTXOs.length === 0) {
     throw new Error("Insufficient funds: no valid UTXOs available for staking");
@@ -483,7 +934,7 @@ var getWithdrawTxFee = (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);
+    const decompiledScript = import_bitcoinjs_lib7.script.decompile(script4);
     if (!decompiledScript) {
       return acc;
     }
@@ -493,260 +944,21 @@ var getEstimatedSize = (inputUtxos, outputs) => {
     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/utils/staking/index.ts
-var buildStakingTransactionOutputs = (scripts, network, amount) => {
-  const stakingOutputInfo = deriveStakingOutputInfo(scripts, network);
-  const transactionOutputs = [
-    {
-      scriptPubKey: stakingOutputInfo.scriptPubKey,
-      value: amount
-    }
-  ];
-  if (scripts.dataEmbedScript) {
-    transactionOutputs.push({
-      scriptPubKey: scripts.dataEmbedScript,
-      value: 0
-    });
-  }
-  return transactionOutputs;
-};
-var deriveStakingOutputInfo = (scripts, network) => {
-  const scriptTree = [
-    {
-      output: scripts.slashingScript
-    },
-    [{ output: scripts.unbondingScript }, { output: scripts.timelockScript }]
-  ];
-  const stakingOutput = import_bitcoinjs_lib5.payments.p2tr({
-    internalPubkey,
-    scriptTree,
-    network
-  });
-  if (!stakingOutput.address) {
-    throw new StakingError(
-      "INVALID_OUTPUT" /* INVALID_OUTPUT */,
-      "Failed to build staking output"
-    );
-  }
-  return {
-    outputAddress: stakingOutput.address,
-    scriptPubKey: import_bitcoinjs_lib5.address.toOutputScript(stakingOutput.address, network)
-  };
-};
-var deriveUnbondingOutputInfo = (scripts, network) => {
-  const outputScriptTree = [
-    {
-      output: scripts.slashingScript
-    },
-    { output: scripts.unbondingTimelockScript }
-  ];
-  const unbondingOutput = import_bitcoinjs_lib5.payments.p2tr({
-    internalPubkey,
-    scriptTree: outputScriptTree,
-    network
-  });
-  if (!unbondingOutput.address) {
-    throw new StakingError(
-      "INVALID_OUTPUT" /* INVALID_OUTPUT */,
-      "Failed to build unbonding output"
-    );
-  }
-  return {
-    outputAddress: unbondingOutput.address,
-    scriptPubKey: import_bitcoinjs_lib5.address.toOutputScript(unbondingOutput.address, network)
-  };
-};
-var deriveSlashingOutput = (scripts, network) => {
-  const slashingOutput = import_bitcoinjs_lib5.payments.p2tr({
-    internalPubkey,
-    scriptTree: { output: scripts.unbondingTimelockScript },
-    network
-  });
-  const slashingOutputAddress = slashingOutput.address;
-  if (!slashingOutputAddress) {
-    throw new StakingError(
-      "INVALID_OUTPUT" /* INVALID_OUTPUT */,
-      "Failed to build slashing output address"
-    );
-  }
-  return {
-    outputAddress: slashingOutputAddress,
-    scriptPubKey: import_bitcoinjs_lib5.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;
-  });
-  if (index === -1) {
-    throw new StakingError(
-      "INVALID_OUTPUT" /* INVALID_OUTPUT */,
-      `Matching output not found for address: ${outputAddress}`
-    );
-  }
-  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"
-    );
-  }
+    return acc + MAX_NON_LEGACY_OUTPUT_SIZE;
+  }, 0);
+  return inputSize + outputSize + TX_BUFFER_SIZE_OVERHEAD;
 };
-var toBuffers = (inputs) => {
-  try {
-    return inputs.map(
-      (i) => Buffer.from(i, "hex")
-    );
-  } catch (error) {
-    throw StakingError.fromUnknown(
-      error,
-      "INVALID_INPUT" /* INVALID_INPUT */,
-      "Cannot convert values to buffers"
-    );
-  }
+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/constants/transaction.ts
-var REDEEM_VERSION = 192;
-
 // 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 +973,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 +989,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)
     );
   }
@@ -851,14 +1063,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 +1079,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 +1090,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 +1172,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 +1186,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 +1198,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 +1224,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 +1246,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(),
@@ -1041,253 +1256,53 @@ function unbondingTransaction(scripts, stakingTx, unbondingFee, network, outputI
   );
   const unbondingOutputInfo = deriveUnbondingOutputInfo(scripts, network);
   const outputValue = stakingTx.outs[outputIndex].value - unbondingFee;
-  if (outputValue < BTC_DUST_SAT) {
-    throw new Error("Output value is less than dust limit for unbonding transaction");
-  }
-  if (!unbondingOutputInfo.outputAddress) {
-    throw new Error("Unbonding output address is not defined");
-  }
-  tx.addOutput(
-    unbondingOutputInfo.scriptPubKey,
-    outputValue
-  );
-  tx.locktime = 0;
-  return {
-    transaction: tx,
-    fee: unbondingFee
-  };
-}
-var createCovenantWitness = (originalWitness, paramsCovenants, covenantSigs, covenantQuorum) => {
-  if (covenantSigs.length < covenantQuorum) {
-    throw new Error(
-      `Not enough covenant signatures. Required: ${covenantQuorum}, got: ${covenantSigs.length}`
-    );
-  }
-  for (const sig of covenantSigs) {
-    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`
-      );
-    }
-  }
-  const covenantSigsBuffers = covenantSigs.slice(0, covenantQuorum).map((sig) => ({
-    btcPkHex: Buffer.from(sig.btcPkHex, "hex"),
-    sigHex: Buffer.from(sig.sigHex, "hex")
-  }));
-  const paramsCovenantsSorted = [...paramsCovenants].sort(Buffer.compare).reverse();
-  const composedCovenantSigs = paramsCovenantsSorted.map((covenant) => {
-    const covenantSig = covenantSigsBuffers.find(
-      (sig) => sig.btcPkHex.compare(covenant) === 0
-    );
-    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 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 {
-  }
-  try {
-    import_bitcoinjs_lib7.payments.p2sh({ output: script4 });
-    return "scripthash" /* P2SH */;
-  } catch {
-  }
-  try {
-    import_bitcoinjs_lib7.payments.p2wpkh({ output: script4 });
-    return "witnesspubkeyhash" /* P2WPKH */;
-  } catch {
-  }
-  try {
-    import_bitcoinjs_lib7.payments.p2wsh({ output: script4 });
-    return "witnessscripthash" /* P2WSH */;
-  } catch {
-  }
-  try {
-    import_bitcoinjs_lib7.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_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);
-  }
-  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")) {
+  if (outputValue < BTC_DUST_SAT) {
+    throw new Error("Output value is less than dust limit for unbonding transaction");
+  }
+  if (!unbondingOutputInfo.outputAddress) {
+    throw new Error("Unbonding output address is not defined");
+  }
+  tx.addOutput(
+    unbondingOutputInfo.scriptPubKey,
+    outputValue
+  );
+  tx.locktime = 0;
+  return {
+    transaction: tx,
+    fee: unbondingFee
+  };
+}
+var createCovenantWitness = (originalWitness, paramsCovenants, covenantSigs, covenantQuorum) => {
+  if (covenantSigs.length < covenantQuorum) {
     throw new Error(
-      "Unbonding output script does not match the expected script while building psbt"
+      `Not enough covenant signatures. Required: ${covenantQuorum}, got: ${covenantSigs.length}`
     );
   }
+  for (const sig of covenantSigs) {
+    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`
+      );
+    }
+  }
+  const covenantSigsBuffers = covenantSigs.slice(0, covenantQuorum).map((sig) => ({
+    btcPkHex: Buffer.from(sig.btcPkHex, "hex"),
+    sigHex: Buffer.from(sig.sigHex, "hex")
+  }));
+  const paramsCovenantsSorted = [...paramsCovenants].sort(Buffer.compare).reverse();
+  const composedCovenantSigs = paramsCovenantsSorted.map((covenant) => {
+    const covenantSig = covenantSigsBuffers.find(
+      (sig) => sig.btcPkHex.compare(covenant) === 0
+    );
+    return covenantSig?.sigHex || Buffer.alloc(0);
+  });
+  return [...composedCovenantSigs, ...originalWitness];
 };
 
 // src/staking/index.ts
 var Staking = class {
-  constructor(network, stakerInfo, params, finalityProviderPkNoCoordHex, stakingTimelock) {
+  constructor(network, stakerInfo, params, finalityProviderPksNoCoordHex, stakingTimelock) {
     if (!isValidBitcoinAddress(stakerInfo.address, network)) {
       throw new StakingError(
         "INVALID_INPUT" /* INVALID_INPUT */,
@@ -1300,10 +1315,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 +1326,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 +1342,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 +1369,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
@@ -1395,9 +1410,9 @@ var Staking = class {
   }
   /**
    * 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 +1429,12 @@ 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
     );
   }
   /**
    * 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 +1471,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 +1489,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,341 +1517,175 @@ 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
    * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
-   */
-  createWithdrawStakingExpiredPsbt(stakingTx, feeRate) {
-    const scripts = this.buildScripts();
-    const { outputAddress } = deriveStakingOutputInfo(scripts, this.network);
-    const stakingOutputIndex = findMatchingTxOutputIndex(
-      stakingTx,
-      outputAddress,
-      this.network
-    );
-    try {
-      return withdrawTimelockUnbondedTransaction(
-        scripts,
-        stakingTx,
-        this.stakerInfo.address,
-        this.network,
-        feeRate,
-        stakingOutputIndex
-      );
-    } catch (error) {
-      throw StakingError.fromUnknown(
-        error,
-        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
-        "Cannot build unsigned timelock unbonded transaction"
-      );
-    }
-  }
-  /**
-   * 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
-   */
-  createStakingOutputSlashingPsbt(stakingTx) {
-    if (!this.params.slashing) {
-      throw new StakingError(
-        "INVALID_PARAMS" /* INVALID_PARAMS */,
-        "Slashing parameters are missing"
-      );
-    }
-    const scripts = this.buildScripts();
-    try {
-      const { psbt } = slashTimelockUnbondedTransaction(
-        scripts,
-        stakingTx,
-        this.params.slashing.slashingPkScriptHex,
-        this.params.slashing.slashingRate,
-        this.params.slashing.minSlashingTxFeeSat,
-        this.network
-      );
-      return {
-        psbt,
-        fee: this.params.slashing.minSlashingTxFeeSat
-      };
-    } catch (error) {
-      throw StakingError.fromUnknown(
-        error,
-        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
-        "Cannot build the slash timelock unbonded transaction"
-      );
-    }
-  }
-  /**
-   * 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
-   */
-  createUnbondingOutputSlashingPsbt(unbondingTx) {
-    if (!this.params.slashing) {
-      throw new StakingError(
-        "INVALID_PARAMS" /* INVALID_PARAMS */,
-        "Slashing parameters are missing"
-      );
-    }
-    const scripts = this.buildScripts();
-    try {
-      const { psbt } = slashEarlyUnbondedTransaction(
-        scripts,
-        unbondingTx,
-        this.params.slashing.slashingPkScriptHex,
-        this.params.slashing.slashingRate,
-        this.params.slashing.minSlashingTxFeeSat,
-        this.network
-      );
-      return {
-        psbt,
-        fee: this.params.slashing.minSlashingTxFeeSat
-      };
-    } catch (error) {
-      throw StakingError.fromUnknown(
-        error,
-        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
-        "Cannot build the slash early unbonded transaction"
-      );
-    }
-  }
-  /**
-   * 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
-   * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
-   */
-  createWithdrawSlashingPsbt(slashingTx, feeRate) {
-    const scripts = this.buildScripts();
-    const slashingOutputInfo = deriveSlashingOutput(scripts, this.network);
-    const slashingOutputIndex = findMatchingTxOutputIndex(
-      slashingTx,
-      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
+   */
+  createWithdrawStakingExpiredPsbt(stakingTx, feeRate) {
+    const scripts = this.buildScripts();
+    const { outputAddress } = deriveStakingOutputInfo(scripts, this.network);
+    const stakingOutputIndex = findMatchingTxOutputIndex(
+      stakingTx,
+      outputAddress,
+      this.network
     );
-    if (!params.tag) {
-      throw new StakingError(
-        "INVALID_INPUT" /* INVALID_INPUT */,
-        "Observable staking parameters must include tag"
+    try {
+      return withdrawTimelockUnbondedTransaction(
+        scripts,
+        stakingTx,
+        this.stakerInfo.address,
+        this.network,
+        feeRate,
+        stakingOutputIndex
       );
-    }
-    if (!params.btcActivationHeight) {
-      throw new StakingError(
-        "INVALID_INPUT" /* INVALID_INPUT */,
-        "Observable staking parameters must include a positive activation height"
+    } catch (error) {
+      throw StakingError.fromUnknown(
+        error,
+        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
+        "Cannot build unsigned timelock unbonded transaction"
       );
     }
-    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.
+   * 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
    */
-  buildScripts() {
-    const { covenantQuorum, covenantNoCoordPks, unbondingTime, tag } = this.params;
-    let stakingScriptData;
+  createStakingOutputSlashingPsbt(stakingTx) {
+    if (!this.params.slashing) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Slashing parameters are missing"
+      );
+    }
+    const scripts = this.buildScripts();
+    const { outputAddress } = deriveStakingOutputInfo(scripts, this.network);
+    const stakingOutputIndex = findMatchingTxOutputIndex(
+      stakingTx,
+      outputAddress,
+      this.network
+    );
     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")
+      const { psbt } = slashTimelockUnbondedTransaction(
+        scripts,
+        stakingTx,
+        this.params.slashing.slashingPkScriptHex,
+        this.params.slashing.slashingRate,
+        this.params.slashing.minSlashingTxFeeSat,
+        this.network,
+        stakingOutputIndex
       );
+      return {
+        psbt,
+        fee: this.params.slashing.minSlashingTxFeeSat
+      };
     } catch (error) {
       throw StakingError.fromUnknown(
         error,
-        "SCRIPT_FAILURE" /* SCRIPT_FAILURE */,
-        "Cannot build staking script data"
+        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
+        "Cannot build the slash timelock unbonded transaction"
       );
     }
-    let scripts;
+  }
+  /**
+   * 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
+   */
+  createUnbondingOutputSlashingPsbt(unbondingTx) {
+    if (!this.params.slashing) {
+      throw new StakingError(
+        "INVALID_PARAMS" /* INVALID_PARAMS */,
+        "Slashing parameters are missing"
+      );
+    }
+    const scripts = this.buildScripts();
     try {
-      scripts = stakingScriptData.buildScripts();
+      const { psbt } = slashEarlyUnbondedTransaction(
+        scripts,
+        unbondingTx,
+        this.params.slashing.slashingPkScriptHex,
+        this.params.slashing.slashingRate,
+        this.params.slashing.minSlashingTxFeeSat,
+        this.network
+      );
+      return {
+        psbt,
+        fee: this.params.slashing.minSlashingTxFeeSat
+      };
     } catch (error) {
       throw StakingError.fromUnknown(
         error,
-        "SCRIPT_FAILURE" /* SCRIPT_FAILURE */,
-        "Cannot build staking scripts"
+        "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
+        "Cannot build the slash early unbonded transaction"
       );
     }
-    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.
+   * 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 {TransactionResult} - An object containing the unsigned transaction,
-   * and fee
+   * @returns {PsbtResult} - An object containing the unsigned psbt and fee
+   * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
    */
-  createStakingTransaction(stakingAmountSat, inputUTXOs, feeRate) {
-    validateStakingTxInputData(
-      stakingAmountSat,
-      this.stakingTimelock,
-      this.params,
-      inputUTXOs,
-      feeRate
-    );
+  createWithdrawSlashingPsbt(slashingTx, feeRate) {
     const scripts = this.buildScripts();
+    const slashingOutputInfo = deriveSlashingOutput(scripts, this.network);
+    const slashingOutputIndex = findMatchingTxOutputIndex(
+      slashingTx,
+      slashingOutputInfo.outputAddress,
+      this.network
+    );
     try {
-      const { transaction, fee } = stakingTransaction(
+      return withdrawSlashingTransaction(
         scripts,
-        stakingAmountSat,
+        slashingTx,
         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
+        slashingOutputIndex
       );
-      return {
-        transaction,
-        fee
-      };
     } catch (error) {
       throw StakingError.fromUnknown(
         error,
         "BUILD_TRANSACTION_FAILURE" /* BUILD_TRANSACTION_FAILURE */,
-        "Cannot build unsigned staking transaction"
+        "Cannot build withdraw slashing 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/staking/manager.ts
+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"
+};
+
+// src/utils/index.ts
+var reverseBuffer = (buffer) => {
+  const clonedBuffer = new Uint8Array(buffer);
+  if (clonedBuffer.length < 1)
+    return clonedBuffer;
+  for (let i = 0, j = clonedBuffer.length - 1; i < clonedBuffer.length / 2; i++, j--) {
+    let tmp = clonedBuffer[i];
+    clonedBuffer[i] = clonedBuffer[j];
+    clonedBuffer[j] = tmp;
   }
+  return clonedBuffer;
 };
 
 // src/utils/babylon.ts
@@ -1873,50 +1719,14 @@ var getBabylonParamByVersion = (version, babylonParams) => {
 };
 
 // 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");
-
-// src/constants/registry.ts
-var BABYLON_REGISTRY_TYPE_URLS = {
-  MsgCreateBTCDelegation: "/babylon.btcstaking.v1.MsgCreateBTCDelegation"
-};
-
-// src/utils/index.ts
-var reverseBuffer = (buffer) => {
-  const clonedBuffer = new Uint8Array(buffer);
-  if (clonedBuffer.length < 1)
-    return clonedBuffer;
-  for (let i = 0, j = clonedBuffer.length - 1; i < clonedBuffer.length / 2; i++, j--) {
-    let tmp = clonedBuffer[i];
-    clonedBuffer[i] = clonedBuffer[j];
-    clonedBuffer[j] = tmp;
-  }
-  return clonedBuffer;
-};
-var uint8ArrayToHex = (uint8Array) => {
-  return Array.from(uint8Array).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-};
-
-// 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) {
     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");
     }
@@ -1931,9 +1741,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) {
@@ -1954,7 +1766,7 @@ var BabylonBtcStakingManager = class {
       this.network,
       stakerBtcInfo,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
     const { transaction } = staking.createStakingTransaction(
@@ -1963,6 +1775,7 @@ var BabylonBtcStakingManager = class {
       feeRate
     );
     const msg = await this.createBtcDelegationMsg(
+      "delegation:create",
       staking,
       stakingInput,
       transaction,
@@ -1970,31 +1783,35 @@ 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 
+   * 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.
    */
   async postStakeRegistrationBabylonTransaction(stakerBtcInfo, stakingTx, stakingTxHeight, stakingInput, inclusionProof, babylonAddress) {
-    const params = getBabylonParamByBtcHeight(stakingTxHeight, this.stakingParams);
+    const params = getBabylonParamByBtcHeight(
+      stakingTxHeight,
+      this.stakingParams
+    );
     if (!isValidBabylonAddress(babylonAddress)) {
       throw new Error("Invalid Babylon address");
     }
@@ -2002,7 +1819,7 @@ var BabylonBtcStakingManager = class {
       this.network,
       stakerBtcInfo,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
     const scripts = stakingInstance.buildScripts();
@@ -2013,6 +1830,7 @@ var BabylonBtcStakingManager = class {
       this.network
     );
     const delegationMsg = await this.createBtcDelegationMsg(
+      "delegation:register",
       stakingInstance,
       stakingInput,
       stakingTx,
@@ -2021,11 +1839,11 @@ var BabylonBtcStakingManager = class {
       params,
       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,7 +1855,9 @@ 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) {
@@ -2052,7 +1872,7 @@ var BabylonBtcStakingManager = class {
       this.network,
       stakerBtcInfo,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
     const { fee: stakingFee } = staking.createStakingTransaction(
@@ -2063,7 +1883,7 @@ var BabylonBtcStakingManager = class {
     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.
@@ -2076,7 +1896,10 @@ var BabylonBtcStakingManager = class {
    * @returns The signed staking transaction.
    */
   async createSignedBtcStakingTransaction(stakerBtcInfo, stakingInput, unsignedStakingTx, inputUTXOs, stakingParamsVersion) {
-    const params = getBabylonParamByVersion(stakingParamsVersion, this.stakingParams);
+    const params = getBabylonParamByVersion(
+      stakingParamsVersion,
+      this.stakingParams
+    );
     if (inputUTXOs.length === 0) {
       throw new Error("No input UTXOs provided");
     }
@@ -2084,18 +1907,42 @@ 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(
-      "staking" /* STAKING */,
-      stakingPsbt2.toHex()
+      stakingPsbt2.toHex(),
+      {
+        contracts,
+        action: {
+          name: "sign-btc-staking-transaction" /* SIGN_BTC_STAKING_TRANSACTION */
+        }
+      }
     );
-    return import_bitcoinjs_lib10.Psbt.fromHex(signedStakingPsbtHex).extractTransaction();
+    return import_bitcoinjs_lib9.Psbt.fromHex(signedStakingPsbtHex).extractTransaction();
   }
   /**
    * Creates a partial signed unbonding transaction that is only signed by the
@@ -2120,19 +1967,55 @@ var BabylonBtcStakingManager = class {
       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 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(
-      "unbonding" /* UNBONDING */,
-      psbt.toHex()
+      psbt.toHex(),
+      {
+        contracts,
+        action: {
+          name: "sign-btc-unbonding-transaction" /* SIGN_BTC_UNBONDING_TRANSACTION */
+        }
+      }
     );
-    const signedUnbondingTx = import_bitcoinjs_lib10.Psbt.fromHex(
+    const signedUnbondingTx = import_bitcoinjs_lib9.Psbt.fromHex(
       signedUnbondingPsbtHex
     ).extractTransaction();
     return {
@@ -2141,7 +2024,7 @@ var BabylonBtcStakingManager = class {
     };
   }
   /**
-   * 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.
@@ -2159,10 +2042,7 @@ var BabylonBtcStakingManager = class {
       stakingParamsVersion,
       this.stakingParams
     );
-    const {
-      transaction: signedUnbondingTx,
-      fee
-    } = await this.createPartialSignedBtcUnbondingTransaction(
+    const { transaction: signedUnbondingTx, fee } = await this.createPartialSignedBtcUnbondingTransaction(
       stakerBtcInfo,
       stakingInput,
       stakingParamsVersion,
@@ -2192,13 +2072,15 @@ 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) {
@@ -2210,24 +2092,40 @@ var BabylonBtcStakingManager = class {
       this.network,
       stakerBtcInfo,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
-    const { psbt: unbondingPsbt2, fee } = staking.createWithdrawEarlyUnbondedTransaction(
-      earlyUnbondingTx,
-      feeRate
-    );
+    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(
-      "withdraw-early-unbonded" /* WITHDRAW_EARLY_UNBONDED */,
-      unbondingPsbt2.toHex()
+      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,7 +2133,9 @@ 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) {
@@ -2247,24 +2147,43 @@ var BabylonBtcStakingManager = class {
       this.network,
       stakerBtcInfo,
       params,
-      stakingInput.finalityProviderPkNoCoordHex,
+      stakingInput.finalityProviderPksNoCoordHex,
       stakingInput.stakingTimelock
     );
     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(
-      "withdraw-staking-expired" /* WITHDRAW_STAKING_EXPIRED */,
-      psbt.toHex()
+      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,7 +2191,9 @@ 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) {
@@ -2284,19 +2205,40 @@ var BabylonBtcStakingManager = class {
       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 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 +2247,40 @@ 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);
+  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;
+    }
+    this.ee?.emit(channel, {
+      bech32Address,
+      type: "proof-of-possession"
+    });
     const signedBabylonAddress = await this.btcProvider.signMessage(
-      "proof-of-possession" /* PROOF_OF_POSSESSION */,
-      bech32AddressHex,
-      "ecdsa"
-    );
-    const ecdsaSig = Uint8Array.from(Buffer.from(signedBabylonAddress, "base64"));
+      bech32Address,
+      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,63 +2295,156 @@ 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.
    * @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, inclusionProof) {
+    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 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(
-      "staking-slashing" /* STAKING_SLASHING */,
-      slashingPsbt.toHex()
+      slashingPsbt.toHex(),
+      {
+        contracts: slashingContracts,
+        action: {
+          name: "sign-btc-slashing-transaction" /* SIGN_BTC_SLASHING_TRANSACTION */
+        }
+      }
     );
-    const signedSlashingTx = import_bitcoinjs_lib10.Psbt.fromHex(
+    const signedSlashingTx = import_bitcoinjs_lib9.Psbt.fromHex(
       signedSlashingPsbtHex
     ).extractTransaction();
-    const slashingSig = extractFirstSchnorrSignatureFromTransaction(
-      signedSlashingTx
-    );
+    const slashingSig = extractFirstSchnorrSignatureFromTransaction(signedSlashingTx);
     if (!slashingSig) {
       throw new Error("No signature found in the staking output slashing PSBT");
     }
+    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(
-      "unbonding-slashing" /* UNBONDING_SLASHING */,
-      unbondingSlashingPsbt.toHex()
+      unbondingSlashingPsbt.toHex(),
+      {
+        contracts: unbondingSlashingContracts,
+        action: {
+          name: "sign-btc-unbonding-slashing-transaction" /* SIGN_BTC_UNBONDING_SLASHING_TRANSACTION */
+        }
+      }
     );
-    const signedUnbondingSlashingTx = import_bitcoinjs_lib10.Psbt.fromHex(
+    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");
+      throw new Error(
+        "No signature found in the unbonding output slashing PSBT"
+      );
     }
-    const proofOfPossession = await this.createProofOfPossession(bech32Address);
+    const proofOfPossession = await this.createProofOfPossession(
+      channel,
+      bech32Address,
+      stakerBtcInfo.address
+    );
     const msg = import_babylon_proto_ts.btcstakingtx.MsgCreateBTCDelegation.fromPartial({
       stakerAddr: bech32Address,
       pop: proofOfPossession,
       btcPk: Uint8Array.from(
         Buffer.from(stakerBtcInfo.publicKeyNoCoordHex, "hex")
       ),
-      fpBtcPkList: [
-        Uint8Array.from(
-          Buffer.from(stakingInput.finalityProviderPkNoCoordHex, "hex")
-        )
-      ],
+      fpBtcPkList: stakingInput.finalityProviderPksNoCoordHex.map(
+        (pk) => Uint8Array.from(Buffer.from(pk, "hex"))
+      ),
       stakingTime: stakingInput.stakingTimelock,
       stakingValue: stakingInput.stakingAmountSat,
       stakingTx: Uint8Array.from(stakingTx.toBuffer()),
@@ -2429,13 +2476,11 @@ 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 hash = reverseBuffer(
+      Uint8Array.from(Buffer.from(blockHashHex, "hex"))
+    );
     const inclusionProofKey = import_babylon_proto_ts.btccheckpoint.TransactionKey.fromPartial({
       index: pos,
       hash
@@ -2481,13 +2526,219 @@ var getUnbondingTxStakerSignature = (unbondingTx) => {
     );
   }
 };
+
+// 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,
@@ -2503,7 +2754,9 @@ var getUnbondingTxStakerSignature = (unbondingTx) => {
   getPublicKeyNoCoord,
   getScriptType,
   getUnbondingTxStakerSignature,
+  hasSlashing,
   initBTCCurve,
+  isNativeSegwit,
   isTaproot,
   isValidBabylonAddress,
   isValidBitcoinAddress,
@@ -2521,3 +2774,4 @@ var getUnbondingTxStakerSignature = (unbondingTx) => {
   withdrawSlashingTransaction,
   withdrawTimelockUnbondedTransaction
 });
+//# sourceMappingURL=index.cjs.map