Return tx instead of psbt

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylonlabs-io/btc-staking-ts",
-  "version": "0.4.0-canary.2",
+  "version": "0.4.0-canary.3",
   "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

@@ -1,4 +1,4 @@
-import { networks, Transaction } from "bitcoinjs-lib";
+import { networks, Psbt, Transaction } from "bitcoinjs-lib";
 import { StakingParams } from "../types/params";
 import { UTXO } from "../types/UTXO";
 import { StakingScriptData, StakingScripts } from "./stakingScript";
@@ -21,8 +21,9 @@ import {
   validateStakingTimelock,
   validateStakingTxInputData,
 } from "../utils/staking";
-import { PsbtTransactionResult } from "../types/transaction";
+import { PsbtResult, TransactionResult } from "../types/transaction";
 import { toBuffers } from "../utils/staking";
+import { stakingPsbt, unbondingPsbt } from "./psbt";
 export * from "./stakingScript";
 
 export interface StakerInfo {
@@ -117,13 +118,15 @@ export class 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 {PsbtTransactionResult} - An object containing the unsigned psbt and fee
+   * @returns {TransactionResult} - An object containing the unsigned transaction
+   * and fee
+   * @throws {StakingError} - If the transaction cannot be built
    */
   public createStakingTransaction(
     stakingAmountSat: number,
     inputUTXOs: UTXO[],
     feeRate: number,
-  ): PsbtTransactionResult {
+  ): TransactionResult {
     validateStakingTxInputData(
       stakingAmountSat,
       this.stakingTimelock,
@@ -135,15 +138,28 @@ export class Staking {
     const scripts = this.buildScripts();
 
     try {
-      return stakingTransaction(
+      const { transaction, fee } = stakingTransaction(
         scripts,
         stakingAmountSat,
         this.stakerInfo.address,
         inputUTXOs,
         this.network,
         feeRate,
-        isTaproot(this.stakerInfo.address, this.network) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : undefined,
       );
+      // Do a dry run of stakingPsbt to ensure the transaction can be converted to PSBT
+      // with all the required properties before returning it
+      stakingPsbt(
+        transaction,
+        this.network,
+        inputUTXOs,
+        isTaproot(
+          this.stakerInfo.address, this.network
+        ) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : undefined,
+      );
+      return {
+        transaction,
+        fee,
+      };
     } catch (error: unknown) {
       throw StakingError.fromUnknown(
         error, StakingErrorCode.BUILD_TRANSACTION_FAILURE,
@@ -152,16 +168,40 @@ export class Staking {
     }
   };
 
+  /**
+   * 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 
+   * transaction. The UTXOs that were used to create the staking transaction should
+   * be included in this array.
+   * @returns {Psbt} - The psbt.
+   */
+  public createStakingPsbt(
+    stakingTx: Transaction,
+    inputUTXOs: UTXO[],
+  ): Psbt {
+    return stakingPsbt(
+      stakingTx,
+      this.network,
+      inputUTXOs,
+      isTaproot(
+        this.stakerInfo.address, this.network
+      ) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : undefined,
+    );
+  }
+
   /**
    * Create an unbonding transaction for staking.
    * 
    * @param {Transaction} stakingTx - The staking transaction to unbond.
-   * @returns {PsbtTransactionResult} - An object containing the unsigned psbt and fee
+   * @returns {TransactionResult} - An object containing the unsigned transaction
+   * and fee
    * @throws {StakingError} - If the transaction cannot be built
    */
   public createUnbondingTransaction(
     stakingTx: Transaction,
-  ) : PsbtTransactionResult {    
+  ) : TransactionResult {    
     // Build scripts
     const scripts = this.buildScripts();
 
@@ -173,14 +213,25 @@ export class Staking {
     )
     // Create the unbonding transaction
     try {
-      const { psbt } = unbondingTransaction(
+      const { transaction } = unbondingTransaction(
         scripts,
         stakingTx,
         this.params.unbondingFeeSat,
         this.network,
         stakingOutputIndex,
       );
-      return { psbt, fee: this.params.unbondingFeeSat };
+      // Do a dry run of unbondingPsbt to ensure the transaction can be converted to PSBT
+      // with all the required properties before returning it
+      unbondingPsbt(
+        scripts,
+        transaction,
+        stakingTx,
+        this.network,
+      );
+      return {
+        transaction,
+        fee: this.params.unbondingFeeSat,
+      };
     } catch (error) {
       throw StakingError.fromUnknown(
         error, StakingErrorCode.BUILD_TRANSACTION_FAILURE,
@@ -190,25 +241,47 @@ export class Staking {
   }
 
   /**
-   * Create a withdrawal transaction that spends an unbonding transaction for observable staking.  
+   * 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.
+   */
+  public createUnbondingPsbt(
+    unbondingTx: Transaction,
+    stakingTx: Transaction,
+  ): Psbt {
+    return unbondingPsbt(
+      this.buildScripts(),
+      unbondingTx,
+      stakingTx,
+      this.network,
+    );
+  }
+
+  /**
+   * Create a withdrawal transaction that spends an unbonding transaction.
    * 
-   * @param {Transaction} unbondingTx - The unbonding transaction to withdraw from.
+   * @param {Transaction} earlyUnbondedTx - The transaction to withdraw from, it can be
+   * an unbonding transaction or a slashing unbonded transaction.
    * @param {number} feeRate - The fee rate for the transaction in satoshis per byte.
-   * @returns {PsbtTransactionResult} - An object containing the unsigned psbt 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
    */
   public createWithdrawEarlyUnbondedTransaction (
-    unbondingTx: Transaction,
+    earlyUnbondedTx: Transaction,
     feeRate: number,
-  ): PsbtTransactionResult {
+  ): PsbtResult {
     // Build scripts
     const scripts = this.buildScripts();
 
     // Create the withdraw early unbonded transaction
     try {
       return withdrawEarlyUnbondedTransaction(
         scripts,
-        unbondingTx,
+        earlyUnbondedTx,
         this.stakerInfo.address,
         this.network,
         feeRate,
@@ -227,13 +300,13 @@ export class Staking {
    * 
    * @param {Transaction} stakingTx - The staking transaction to withdraw from.
    * @param {number} feeRate - The fee rate for the transaction in satoshis per byte.
-   * @returns {PsbtTransactionResult} - An object containing the unsigned psbt 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
    */
   public createWithdrawTimelockUnbondedTransaction(
     stakingTx: Transaction,
     feeRate: number,
-  ): PsbtTransactionResult {
+  ): PsbtResult {
     // Build scripts
     const scripts = this.buildScripts();
 
@@ -266,12 +339,12 @@ export class Staking {
    * Create a slashing transaction spending from the staking output.
    * 
    * @param {Transaction} stakingTx - The staking transaction to slash.
-   * @returns {PsbtTransactionResult} - An object containing the unsigned psbt 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
    */
   public createStakingOutputSlashingTransaction(
     stakingTx: Transaction,
-  ) : PsbtTransactionResult {
+  ) : PsbtResult {
     if (!this.params.slashing) {
       throw new StakingError(
         StakingErrorCode.INVALID_PARAMS,
@@ -292,7 +365,10 @@ export class Staking {
         this.params.slashing.minSlashingTxFeeSat,
         this.network,
       );
-      return { psbt, fee: this.params.slashing.minSlashingTxFeeSat };
+      return {
+        psbt,
+        fee: this.params.slashing.minSlashingTxFeeSat,
+      };
     } catch (error) {
       throw StakingError.fromUnknown(
         error, StakingErrorCode.BUILD_TRANSACTION_FAILURE,
@@ -305,12 +381,12 @@ export class Staking {
    * Create a slashing transaction for an unbonding output.
    * 
    * @param {Transaction} unbondingTx - The unbonding transaction to slash.
-   * @returns {PsbtTransactionResult} - An object containing the unsigned psbt 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
    */
   public createUnbondingOutputSlashingTransaction(
     unbondingTx: Transaction,
-  ): PsbtTransactionResult {
+  ): PsbtResult {
     if (!this.params.slashing) {
       throw new StakingError(
         StakingErrorCode.INVALID_PARAMS,
@@ -330,7 +406,10 @@ export class Staking {
         this.params.slashing.minSlashingTxFeeSat,
         this.network,
       );
-      return { psbt, fee: this.params.slashing.minSlashingTxFeeSat };
+      return {
+        psbt,
+        fee: this.params.slashing.minSlashingTxFeeSat,
+      };
     } catch (error) {
       throw StakingError.fromUnknown(
         error, StakingErrorCode.BUILD_TRANSACTION_FAILURE,

src/staking/observable/index.ts

@@ -4,10 +4,11 @@ import { StakingError, StakingErrorCode } from "../../error";
 import { stakingTransaction } from "../transactions";
 import { isTaproot } from "../../utils/btc";
 import { toBuffers, validateStakingTxInputData } from "../../utils/staking";
-import { PsbtTransactionResult } from "../../types/transaction";
+import { TransactionResult } from "../../types/transaction";
 import { ObservableStakingScriptData, ObservableStakingScripts } from "./observableStakingScript";
 import { StakerInfo, Staking } from "..";
-import { networks } from "bitcoinjs-lib";
+import { networks, Psbt, Transaction } from "bitcoinjs-lib";
+import { stakingPsbt, unbondingPsbt } from "../psbt";
 export * from "./observableStakingScript";
 
 /**
@@ -104,13 +105,14 @@ export class ObservableStaking extends 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 {PsbtTransactionResult} - An object containing the unsigned psbt and fee
+   * @returns {TransactionResult} - An object containing the unsigned transaction,
+   * and fee
    */
   public createStakingTransaction(
     stakingAmountSat: number,
     inputUTXOs: UTXO[],
     feeRate: number,
-  ): PsbtTransactionResult{
+  ): TransactionResult {
     validateStakingTxInputData(
       stakingAmountSat,
       this.stakingTimelock,
@@ -123,25 +125,58 @@ export class ObservableStaking extends Staking {
 
     // Create the staking transaction
     try {
-      return stakingTransaction(
+      const { transaction, fee } = stakingTransaction(
         scripts,
         stakingAmountSat,
         this.stakerInfo.address,
         inputUTXOs,
         this.network,
         feeRate,
-        isTaproot(this.stakerInfo.address, this.network) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : undefined,
         // `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.activationHeight - 1,
       );
+
+      stakingPsbt(
+        transaction,
+        this.network,
+        inputUTXOs,
+        isTaproot(
+          this.stakerInfo.address, this.network
+        ) ? Buffer.from(this.stakerInfo.publicKeyNoCoordHex, "hex") : undefined,
+      );
+
+      return {
+        transaction,
+        fee,
+      };
     } catch (error: unknown) {
       throw StakingError.fromUnknown(
         error, StakingErrorCode.BUILD_TRANSACTION_FAILURE,
         "Cannot build unsigned staking transaction",
       );
     }
   };
+
+   /**
+   * 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.
+   */
+   public createUnbondingPsbt(
+    unbondingTx: Transaction,
+    stakingTx: Transaction,
+  ): Psbt {
+    return unbondingPsbt(
+      this.buildScripts(),
+      unbondingTx,
+      stakingTx,
+      this.network,
+    );
+  }
 }