feat: deposit-withdrawal

package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "dlc-btc-lib",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "This library provides a comprehensive set of interfaces and functions for minting dlcBTC tokens on supported blockchains.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/attestor-handlers/attestor-handler.ts

@@ -14,18 +14,18 @@ export class AttestorHandler {
 
   async createPSBTEvent(
     vaultUUID: string,
-    fundingTransaction: string,
-    closingPSBT: string,
-    userNativeSegwitAddress: string
+    fundingTransactionPsbt: string,
+    mintAddress: string,
+    alicePubkey: string
   ): Promise<void> {
     const createPSBTEndpoints = this.attestorRootURLs.map(url => `${url}/app/create-psbt-event`);
 
     const body = JSON.stringify({
       uuid: vaultUUID,
-      funding_transaction: fundingTransaction,
-      closing_psbt: closingPSBT,
-      mint_address: userNativeSegwitAddress,
+      funding_transaction_psbt: fundingTransactionPsbt,
+      mint_address: mintAddress,
       chain: this.ethereumChainID,
+      alice_pubkey: alicePubkey,
     });
 
     const requests = createPSBTEndpoints.map(async url =>
@@ -48,4 +48,33 @@ export class AttestorHandler {
       );
     }
   }
+
+  async submitWithdrawRequest(vaultUUID: string, withdrawPSBT: string): Promise<void> {
+    const withdrawEndpoints = this.attestorRootURLs.map(url => `${url}/app/withdraw`);
+
+    const body = JSON.stringify({
+      uuid: vaultUUID,
+      wd_psbt: withdrawPSBT,
+    });
+
+    const requests = withdrawEndpoints.map(async url =>
+      fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' },
+        body,
+      })
+        .then(response => (response.ok ? true : response.statusText))
+        .catch(error => error.message)
+    );
+
+    const responses = await Promise.all(requests);
+
+    const failedResponses = responses.filter(response => response !== true);
+
+    if (failedResponses.length === withdrawEndpoints.length) {
+      throw new AttestorError(
+        `Error sending Withdraw Transaction to Attestors: ${failedResponses.join(', ')}`
+      );
+    }
+  }
 }

src/constants/ethereum-constants.ts

@@ -59,4 +59,4 @@ export const addNetworkParams = {
 
 export const GITHUB_SOLIDITY_URL = 'https://raw.githubusercontent.com/DLC-link/dlc-solidity';
 
-export const dlcContractNames: DLCEthereumContractName[] = ['TokenManager', 'DLCManager', 'DLCBTC'];
+export const dlcContractNames: DLCEthereumContractName[] = ['DLCManager', 'DLCBTC'];

src/dlc-handlers/ledger-dlc-handler.ts

@@ -1,3 +1,4 @@
+import { bytesToHex } from '@noble/hashes/utils';
 import { Transaction } from '@scure/btc-signer';
 import { P2Ret, P2TROut, p2tr, p2wpkh } from '@scure/btc-signer/payment';
 import { Network, Psbt } from 'bitcoinjs-lib';
@@ -17,8 +18,9 @@ import {
 import {
   addNativeSegwitSignaturesToPSBT,
   addTaprootInputSignaturesToPSBT,
-  createClosingTransaction,
+  createDepositTransaction,
   createFundingTransaction,
+  createWithdrawalTransaction,
   getNativeSegwitInputsToSign,
   getTaprootInputsToSign,
   updateNativeSegwitInputs,
@@ -130,6 +132,10 @@ export class LedgerDLCHandler {
     return this.payment;
   }
 
+  getTaprootDerivedPublicKey(): string {
+    return bytesToHex(this.getPayment().taprootDerivedPublicKey);
+  }
+
   getVaultRelatedAddress(paymentType: 'funding' | 'multisig'): string {
     const payment = this.getPayment();
 
@@ -280,6 +286,7 @@ export class LedgerDLCHandler {
 
   async createFundingPSBT(
     vault: RawVault,
+    bitcoinAmount: bigint,
     attestorGroupPublicKey: string,
     feeRateMultiplier?: number,
     customFeeRate?: bigint
@@ -307,8 +314,8 @@ export class LedgerDLCHandler {
         throw new Error('Insufficient Funds');
       }
 
-      const fundingPSBT = await createFundingTransaction(
-        vault.valueLocked.toBigInt(),
+      const fundingTransaction = await createFundingTransaction(
+        bitcoinAmount,
         this.bitcoinNetwork,
         multisigPayment.address as string,
         fundingPayment,
@@ -319,12 +326,12 @@ export class LedgerDLCHandler {
       );
 
       const signingConfiguration = createBitcoinInputSigningConfiguration(
-        fundingPSBT,
+        fundingTransaction,
         this.walletAccountIndex,
         this.bitcoinNetwork
       );
 
-      const formattedFundingPSBT = Psbt.fromBuffer(Buffer.from(fundingPSBT), {
+      const formattedFundingPSBT = Psbt.fromBuffer(Buffer.from(fundingTransaction.toPSBT()), {
         network: this.bitcoinNetwork,
       });
 
@@ -361,25 +368,31 @@ export class LedgerDLCHandler {
     }
   }
 
-  async createClosingPSBT(
+  async createWithdrawalPSBT(
     vault: RawVault,
+    withdrawAmount: bigint,
+    attestorGroupPublicKey: string,
     fundingTransactionID: string,
     feeRateMultiplier?: number,
     customFeeRate?: bigint
   ): Promise<Psbt> {
     try {
-      const { fundingPayment, multisigPayment, taprootDerivedPublicKey } = this.getPayment();
+      const { fundingPayment, taprootDerivedPublicKey, multisigPayment } = await this.createPayment(
+        vault.uuid,
+        attestorGroupPublicKey
+      );
 
-      if (fundingPayment.address === undefined) {
-        throw new Error('Could not get Addresses from Payments');
+      if (multisigPayment.address === undefined || fundingPayment.address === undefined) {
+        throw new Error('Payment Address is undefined');
       }
 
       const feeRate =
         customFeeRate ??
         BigInt(await getFeeRate(this.bitcoinBlockchainFeeRecommendationAPI, feeRateMultiplier));
 
-      const closingPSBT = createClosingTransaction(
-        vault.valueLocked.toBigInt(),
+      const withdrawalTransaction = await createWithdrawalTransaction(
+        this.bitcoinBlockchainAPI,
+        withdrawAmount,
         this.bitcoinNetwork,
         fundingTransactionID,
         multisigPayment,
@@ -389,38 +402,109 @@ export class LedgerDLCHandler {
         vault.btcRedeemFeeBasisPoints.toBigInt()
       );
 
-      const closingTransactionSigningConfiguration = createBitcoinInputSigningConfiguration(
-        closingPSBT,
+      const withdrawalTransactionSigningConfiguration = createBitcoinInputSigningConfiguration(
+        withdrawalTransaction,
         this.walletAccountIndex,
         this.bitcoinNetwork
       );
 
-      const formattedClosingPSBT = Psbt.fromBuffer(Buffer.from(closingPSBT), {
+      const formattedWithdrawalPSBT = Psbt.fromBuffer(Buffer.from(withdrawalTransaction.toPSBT()), {
         network: this.bitcoinNetwork,
       });
 
-      const closingInputByPaymentTypeArray = getInputByPaymentTypeArray(
-        closingTransactionSigningConfiguration,
-        formattedClosingPSBT.toBuffer(),
+      const withdrawalInputByPaymentTypeArray = getInputByPaymentTypeArray(
+        withdrawalTransactionSigningConfiguration,
+        formattedWithdrawalPSBT.toBuffer(),
         this.bitcoinNetwork
       );
 
-      const taprootInputsToSign = getTaprootInputsToSign(closingInputByPaymentTypeArray);
+      const taprootInputsToSign = getTaprootInputsToSign(withdrawalInputByPaymentTypeArray);
 
       await updateTaprootInputs(
         taprootInputsToSign,
         taprootDerivedPublicKey,
         this.masterFingerprint,
-        formattedClosingPSBT
+        formattedWithdrawalPSBT
       );
 
-      return formattedClosingPSBT;
+      return formattedWithdrawalPSBT;
     } catch (error: any) {
-      throw new Error(`Error creating Closing PSBT: ${error}`);
+      throw new Error(`Error creating Withdrawal PSBT: ${error}`);
+    }
+  }
+
+  async createDepositPSBT(
+    depositAmount: bigint,
+    vault: RawVault,
+    attestorGroupPublicKey: string,
+    fundingTransactionID: string,
+    feeRateMultiplier?: number,
+    customFeeRate?: bigint
+  ) {
+    const { fundingPayment, taprootDerivedPublicKey, fundingDerivedPublicKey, multisigPayment } =
+      await this.createPayment(vault.uuid, attestorGroupPublicKey);
+
+    if (multisigPayment.address === undefined || fundingPayment.address === undefined) {
+      throw new Error('Payment Address is undefined');
     }
+
+    const feeRate =
+      customFeeRate ??
+      BigInt(await getFeeRate(this.bitcoinBlockchainFeeRecommendationAPI, feeRateMultiplier));
+
+    const depositTransaction = await createDepositTransaction(
+      this.bitcoinBlockchainAPI,
+      this.bitcoinNetwork,
+      depositAmount,
+      fundingTransactionID,
+      multisigPayment,
+      fundingPayment,
+      feeRate,
+      vault.btcFeeRecipient,
+      vault.btcMintFeeBasisPoints.toBigInt()
+    );
+
+    const depositTransactionSigningConfiguration = createBitcoinInputSigningConfiguration(
+      depositTransaction,
+      this.walletAccountIndex,
+      this.bitcoinNetwork
+    );
+
+    const formattedDepositPSBT = Psbt.fromBuffer(Buffer.from(depositTransaction.toPSBT()), {
+      network: this.bitcoinNetwork,
+    });
+
+    const withdrawalInputByPaymentTypeArray = getInputByPaymentTypeArray(
+      depositTransactionSigningConfiguration,
+      formattedDepositPSBT.toBuffer(),
+      this.bitcoinNetwork
+    );
+
+    const taprootInputsToSign = getTaprootInputsToSign(withdrawalInputByPaymentTypeArray);
+    const nativeSegwitInputsToSign = getNativeSegwitInputsToSign(withdrawalInputByPaymentTypeArray);
+
+    await updateTaprootInputs(
+      taprootInputsToSign,
+      taprootDerivedPublicKey,
+      this.masterFingerprint,
+      formattedDepositPSBT
+    );
+
+    await updateNativeSegwitInputs(
+      nativeSegwitInputsToSign,
+      fundingDerivedPublicKey,
+      this.masterFingerprint,
+      formattedDepositPSBT,
+      this.bitcoinBlockchainAPI
+    );
+
+    return formattedDepositPSBT;
   }
 
-  async signPSBT(psbt: Psbt, transactionType: 'funding' | 'closing'): Promise<Transaction> {
+  async signPSBT(
+    psbt: Psbt,
+    transactionType: 'funding' | 'deposit' | 'withdraw'
+  ): Promise<Transaction> {
     try {
       const { fundingWalletPolicy, multisigWalletPolicy, multisigWalletPolicyHMac } =
         this.getPolicyInformation();
@@ -444,13 +528,27 @@ export class LedgerDLCHandler {
           transaction = Transaction.fromPSBT(psbt.toBuffer());
           transaction.finalize();
           return transaction;
-        case 'closing':
+        case 'deposit':
+          signatures = await this.ledgerApp.signPsbt(
+            psbt.toBase64(),
+            multisigWalletPolicy,
+            multisigWalletPolicyHMac
+          );
+          addTaprootInputSignaturesToPSBT('funding', psbt, signatures);
+
+          signatures = await this.ledgerApp.signPsbt(psbt.toBase64(), fundingWalletPolicy, null);
+
+          addNativeSegwitSignaturesToPSBT(psbt, signatures);
+
+          transaction = Transaction.fromPSBT(psbt.toBuffer());
+          return transaction;
+        case 'withdraw':
           signatures = await this.ledgerApp.signPsbt(
             psbt.toBase64(),
             multisigWalletPolicy,
             multisigWalletPolicyHMac
           );
-          addTaprootInputSignaturesToPSBT('closing', psbt, signatures);
+          addTaprootInputSignaturesToPSBT('withdraw', psbt, signatures);
           transaction = Transaction.fromPSBT(psbt.toBuffer());
           return transaction;
         default: