Support slashing & simply data structure for phase 2

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylonlabs-io/btc-staking-ts",
-  "version": "0.4.0-canary.1",
+  "version": "0.4.0-canary.2",
   "description": "Library exposing methods for the creation and consumption of Bitcoin transactions pertaining to Babylon's Bitcoin Staking protocol.",
   "module": "dist/index.js",
   "main": "dist/index.cjs",

src/staking/index.ts

@@ -4,11 +4,14 @@ import { UTXO } from "../types/UTXO";
 import { StakingScriptData, StakingScripts } from "./stakingScript";
 import { StakingError, StakingErrorCode } from "../error";
 import { 
+  slashEarlyUnbondedTransaction,
+  slashTimelockUnbondedTransaction,
   stakingTransaction, unbondingTransaction,
   withdrawEarlyUnbondedTransaction,
   withdrawTimelockUnbondedTransaction
 } from "./transactions";
 import { 
+  deriveAddressFromPkScript,
   isTaproot,
   isValidBitcoinAddress, isValidNoCoordPublicKey
 } from "../utils/btc";
@@ -176,6 +179,32 @@ export class Staking {
         "Covenant quorum must be greater than 0",
       );
     }
+    if (params.slashing) {
+      if (params.slashing.slashingRate <= 0) {
+        throw new StakingError(
+          StakingErrorCode.INVALID_PARAMS,
+          "Slashing rate must be greater than 0",
+        );
+      }
+      if (params.slashing.slashingRate > 1) {
+        throw new StakingError(
+          StakingErrorCode.INVALID_PARAMS,
+          "Slashing rate must be less or equal to 1",
+        );
+      }
+      if (params.slashing.slashingPkScript.length == 0) {
+        throw new StakingError(
+          StakingErrorCode.INVALID_PARAMS,
+          "Slashing public key script is missing",
+        );
+      }
+      if (params.slashing.minSlashingTxFeeSat <= 0) {
+        throw new StakingError(
+          StakingErrorCode.INVALID_PARAMS,
+          "Minimum slashing transaction fee must be greater than 0",
+        );
+      }
+    }
   }
 
   /**
@@ -246,7 +275,7 @@ export class Staking {
    * 
    * @returns {PsbtTransactionResult} - An object containing the unsigned psbt and fee
    */
-  public createStakingTransaction (
+  public createStakingTransaction(
     params: StakingParams,
     stakingAmountSat: number,
     timelock: number,
@@ -290,19 +319,19 @@ export class Staking {
   };
 
   /**
-   * Create an unbonding transaction for observable staking.
+   * Create an unbonding transaction for staking.
    * 
-   * @param {ObservableStakingParams} stakingParams - The staking parameters for observable staking.
+   * @param {ObservableStakingParams} stakingParams - The staking parameters for staking.
    * @param {Delegation} delegation - The delegation to unbond.
    * 
    * @returns {Psbt} - The unsigned unbonding transaction
    * 
    * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
    */
-  public createUnbondingTransaction = (
+  public createUnbondingTransaction(
     stakingParams: StakingParams,
     delegation: Delegation,
-  ) : PsbtTransactionResult => {
+  ) : PsbtTransactionResult {
     this.validateParams(stakingParams);
     this.validateDelegationInputs(
       delegation, stakingParams, this.stakerInfo,
@@ -351,12 +380,12 @@ export class Staking {
    * 
    * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
    */
-  public createWithdrawEarlyUnbondedTransaction = (
+  public createWithdrawEarlyUnbondedTransaction (
     stakingParams: StakingParams,
     delegation: Delegation,
     unbondingTx: Transaction,
     feeRate: number,
-  ): PsbtTransactionResult => {
+  ): PsbtTransactionResult {
     this.validateParams(stakingParams);
     this.validateDelegationInputs(
       delegation, stakingParams, this.stakerInfo,
@@ -402,11 +431,11 @@ export class Staking {
    * 
    * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
    */
-  public createWithdrawTimelockUnbondedTransaction = (
+  public createWithdrawTimelockUnbondedTransaction(
     stakingParams: StakingParams,
     delegation: Delegation,
     feeRate: number,
-  ): PsbtTransactionResult => {
+  ): PsbtTransactionResult {
     this.validateParams(stakingParams);
     this.validateDelegationInputs(
       delegation, stakingParams, this.stakerInfo,
@@ -444,4 +473,128 @@ export class Staking {
       );
     }
   }
+
+  /**
+   * Create a slash timelock unbonded transaction for staking.
+   * 
+   * @param {StakingParams} stakingParams - The staking parameters for staking.
+   * @param {Delegation} delegation - The delegation to slash.
+   * 
+   * @returns {PsbtTransactionResult} - An object containing the unsigned psbt and fee
+   * 
+   * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
+   */
+  public createSlashTimelockUnbondedTransaction(
+    stakingParams: StakingParams,
+    delegation: Delegation,
+  ) : PsbtTransactionResult {
+    this.validateParams(stakingParams);
+    if (!stakingParams.slashing) {
+      throw new StakingError(
+        StakingErrorCode.INVALID_PARAMS,
+        "Slashing parameters are missing",
+      );
+    }
+    this.validateDelegationInputs(
+      delegation, stakingParams, this.stakerInfo,
+    );
+    const slashingAddress = deriveAddressFromPkScript(
+      stakingParams.slashing.slashingPkScript, this.network,
+    );
+    const { 
+      stakingTx,
+      timelock,
+      finalityProviderPkNoCoordHex,
+      stakerPkNoCoordHex,
+    } = delegation;
+
+    // Build scripts
+    const scripts = this.buildScripts(
+      stakingParams,
+      finalityProviderPkNoCoordHex,
+      timelock,
+      stakerPkNoCoordHex,
+    );
+
+    // create the slash timelock unbonded transaction
+    try {
+      const { psbt } = slashTimelockUnbondedTransaction(
+        scripts,
+        stakingTx,
+        slashingAddress,
+        stakingParams.slashing.slashingRate,
+        stakingParams.slashing.minSlashingTxFeeSat,
+        this.network,
+      );
+      return { psbt, fee: stakingParams.slashing.minSlashingTxFeeSat };
+    } catch (error) {
+      throw StakingError.fromUnknown(
+        error, StakingErrorCode.BUILD_TRANSACTION_FAILURE,
+        "Cannot build the slash timelock unbonded transaction",
+      );
+    }
+  }
+
+  /**
+   * Create a slash early unbonded transaction for staking.
+   * 
+   * @param {StakingParams} stakingParams - The staking parameters for staking.
+   * @param {Delegation} delegation - The delegation to slash.
+   * @param {Transaction} unbondingTx - The unbonding transaction to slash.
+   * 
+   * @returns {PsbtTransactionResult} - An object containing the unsigned psbt and fee
+   * 
+   * @throws {StakingError} - If the delegation is invalid or the transaction cannot be built
+   */
+  public createSlashEarlyUnbondedTransaction(
+    stakingParams: StakingParams,
+    delegation: Delegation,
+    unbondingTx: Transaction,
+  ): PsbtTransactionResult {
+    this.validateParams(stakingParams);
+    if (!stakingParams.slashing) {
+      throw new StakingError(
+        StakingErrorCode.INVALID_PARAMS,
+        "Slashing parameters are missing",
+      );
+    }
+    this.validateDelegationInputs(
+      delegation, stakingParams, this.stakerInfo,
+    );
+    const slashingAddress = deriveAddressFromPkScript(
+      stakingParams.slashing.slashingPkScript, this.network,
+    );
+
+    const {
+      timelock,
+      finalityProviderPkNoCoordHex,
+      stakerPkNoCoordHex,
+    } = delegation;
+
+    // Build scripts
+    const scripts = this.buildScripts(
+      stakingParams,
+      finalityProviderPkNoCoordHex,
+      timelock,
+      stakerPkNoCoordHex,
+    );
+
+    // create the slash timelock unbonded transaction
+    try {
+      const { psbt } = slashEarlyUnbondedTransaction(
+        scripts,
+        unbondingTx,
+        slashingAddress,
+        stakingParams.slashing.slashingRate,
+        stakingParams.slashing.minSlashingTxFeeSat,
+        this.network,
+      );
+      return { psbt, fee: stakingParams.slashing.minSlashingTxFeeSat };
+    } catch (error) {
+      throw StakingError.fromUnknown(
+        error, StakingErrorCode.BUILD_TRANSACTION_FAILURE,
+        "Cannot build the slash early unbonded transaction",
+      );
+    }
+  }
 }

src/staking/observable/index.ts

@@ -137,7 +137,7 @@ export class ObservableStaking extends Staking {
    * 
    * @returns {PsbtTransactionResult} - An object containing the unsigned psbt and fee
    */
-  public createStakingTransaction (
+  public createStakingTransaction(
     params: ObservableStakingParams,
     stakingAmountSat: number,
     timelock: number,

src/types/params.ts

@@ -10,6 +10,7 @@ export interface StakingParams {
   slashing?: {
     slashingPkScript: string;
     slashingRate: number;
+    minSlashingTxFeeSat: number;
   }
 }
 

src/utils/btc.ts

@@ -103,4 +103,22 @@ const validateNoCoordPublicKeyBuffer = (pkBuffer: Buffer): boolean => {
   return (
     ecc.isPoint(compressedKeyEven) || ecc.isPoint(compressedKeyOdd)
   );
+};
+
+/**
+ * Derive the Bitcoin address from the public key script.
+ * 
+ * @param {string} scriptPubKey - The public key script in hex.
+ * @param {networks.Network} network - The Bitcoin network (e.g., bitcoin.networks.bitcoin).
+ * 
+ * @returns {string} - The Bitcoin address.
+ * @throws {Error} - If the address cannot be derived from the public key script.
+ */
+export const deriveAddressFromPkScript = (scriptPubKey: string, network: networks.Network): string => {
+  try {
+    const scriptPubKeyBuffer = Buffer.from(scriptPubKey, "hex");
+    return address.fromOutputScript(scriptPubKeyBuffer, network);  
+  } catch (error) {
+    throw new Error(`Failed to derive address from public key script: ${error}`);
+  }
 };

tests/helper/datagen/base.ts

@@ -42,6 +42,8 @@ export class StakingDataGenerator {
     const maxStakingTimeBlocks = fixedTerm ? minStakingTimeBlocks : this.getRandomIntegerBetween(minStakingTimeBlocks, minStakingTimeBlocks + 1000);
     const timelock = this.generateRandomTimelock({minStakingTimeBlocks, maxStakingTimeBlocks});
     const unbondingTime = this.generateRandomUnbondingTime(timelock);
+    const slashingRate = this.generateRandomSlashingRate();
+    const minSlashingTxFeeSat = this.getRandomIntegerBetween(1000, 100000);
     return {
       covenantNoCoordPks,
       covenantQuorum,
@@ -53,6 +55,11 @@ export class StakingDataGenerator {
       ),
       minStakingTimeBlocks,
       maxStakingTimeBlocks,
+      slashing: {
+        slashingRate,
+        slashingPkScript: getRandomPaymentScriptHex(this.generateRandomKeyPair().publicKey),
+        minSlashingTxFeeSat,
+      }
     };
   }
 
@@ -309,3 +316,25 @@ export class StakingDataGenerator {
     };
   };
 }
+
+function getRandomPaymentScriptHex(pubKeyHex: string): string {
+  const pubKeyBuf = Buffer.from(pubKeyHex, "hex");
+
+  // Define the possible payment types
+  const paymentTypes = [
+    bitcoin.payments.p2pkh({ pubkey: pubKeyBuf }),
+    bitcoin.payments.p2sh({ redeem: bitcoin.payments.p2wpkh({ pubkey: pubKeyBuf }) }),
+    bitcoin.payments.p2wpkh({ pubkey: pubKeyBuf }),
+  ];
+
+  // Randomly pick one payment type
+  const randomIndex = Math.floor(Math.random() * paymentTypes.length);
+  const payment = paymentTypes[randomIndex];
+
+  // Get the scriptPubKey from the selected payment type and return its hex representation
+  if (!payment.output) {
+    throw new Error("Failed to generate scriptPubKey.");
+  }
+
+  return payment.output.toString("hex");
+}