feat: deposit-withdrawal

package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "dlc-btc-lib",
-  "version": "1.0.11",
+  "version": "1.0.14",
   "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

@@ -1,50 +1,78 @@
+import {
+  FundingTXAttestorInfo,
+  WithdrawDepositTXAttestorInfo,
+} from 'src/models/attestor.models.js';
+
 import { AttestorError } from '../models/errors.js';
 
 export class AttestorHandler {
   private attestorRootURLs: string[];
-  private ethereumChainID: string;
 
-  constructor(
-    attestorRootURLs: string[],
-    ethereumChainID: 'evm-arbitrum' | 'evm-arbsepolia' | 'evm-localhost'
-  ) {
+  constructor(attestorRootURLs: string[]) {
     this.attestorRootURLs = attestorRootURLs;
-    this.ethereumChainID = ethereumChainID;
   }
 
-  async createPSBTEvent(
-    vaultUUID: string,
-    fundingTransaction: string,
-    closingPSBT: string,
-    userNativeSegwitAddress: string
-  ): Promise<void> {
-    const createPSBTEndpoints = this.attestorRootURLs.map(url => `${url}/app/create-psbt-event`);
+  private async sendRequest(url: string, body: string): Promise<boolean | string> {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' },
+      body,
+    });
+    if (!response.ok) {
+      throw new AttestorError(`Attestor Response ${url} was not OK: ${response.statusText}`);
+    }
+    return true;
+  }
+
+  async submitFundingPSBT(fundingTXAttestorInfo: FundingTXAttestorInfo): Promise<void> {
+    const fundingEndpoints = this.attestorRootURLs.map(url => `${url}/app/create-psbt-event`);
 
     const body = JSON.stringify({
-      uuid: vaultUUID,
-      funding_transaction: fundingTransaction,
-      closing_psbt: closingPSBT,
-      mint_address: userNativeSegwitAddress,
-      chain: this.ethereumChainID,
+      uuid: fundingTXAttestorInfo.vaultUUID,
+      funding_transaction_psbt: fundingTXAttestorInfo.fundingPSBT,
+      mint_address: fundingTXAttestorInfo.userEthereumAddress,
+      chain: fundingTXAttestorInfo.attestorChainID,
+      alice_pubkey: fundingTXAttestorInfo.userBitcoinTaprootPublicKey,
     });
 
-    const requests = createPSBTEndpoints.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 attestorResponses: (boolean | string)[] = await Promise.all(
+      fundingEndpoints.map(async url =>
+        this.sendRequest(url, body)
+          .then(response => response)
+          .catch(error => error.message)
+      )
     );
 
-    const responses = await Promise.all(requests);
+    if (attestorResponses.every(response => response !== true)) {
+      throw new AttestorError(
+        `Error sending [Funding] Transaction to Attestors:
+          ${attestorResponses.join('| ')}`
+      );
+    }
+  }
+
+  async submitWithdrawDepositPSBT(
+    withdrawDepositTXAttestorInfo: WithdrawDepositTXAttestorInfo
+  ): Promise<void> {
+    const depositWithdrawEndpoints = this.attestorRootURLs.map(url => `${url}/app/withdraw`);
+
+    const body = JSON.stringify({
+      uuid: withdrawDepositTXAttestorInfo.vaultUUID,
+      wd_psbt: withdrawDepositTXAttestorInfo.depositWithdrawPSBT,
+    });
 
-    const failedResponses = responses.filter(response => response !== true);
+    const attestorResponses: (boolean | string)[] = await Promise.all(
+      depositWithdrawEndpoints.map(async url =>
+        this.sendRequest(url, body)
+          .then(response => response)
+          .catch(error => error.message)
+      )
+    );
 
-    if (failedResponses.length === createPSBTEndpoints.length) {
+    if (attestorResponses.every(response => response !== true)) {
       throw new AttestorError(
-        `Error sending Funding and Closing Transaction to Attestors: ${failedResponses.join(', ')}`
+        `Error sending [Deposit/Withdraw] Transaction to Attestors:
+          ${attestorResponses.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,
+  createWithdrawTransaction,
   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
@@ -290,41 +297,34 @@ export class LedgerDLCHandler {
         attestorGroupPublicKey
       );
 
-      if ([multisigPayment.address, fundingPayment.address].some(x => x === undefined)) {
-        throw new Error('Payment Address is undefined');
-      }
-
       const feeRate =
         customFeeRate ??
         BigInt(await getFeeRate(this.bitcoinBlockchainFeeRecommendationAPI, feeRateMultiplier));
 
-      const addressBalance = await getBalance(
-        fundingPayment.address as string,
-        this.bitcoinBlockchainAPI
-      );
+      const addressBalance = await getBalance(fundingPayment, this.bitcoinBlockchainAPI);
 
       if (BigInt(addressBalance) < vault.valueLocked.toBigInt()) {
         throw new Error('Insufficient Funds');
       }
 
-      const fundingPSBT = await createFundingTransaction(
-        vault.valueLocked.toBigInt(),
+      const fundingTransaction = await createFundingTransaction(
+        this.bitcoinBlockchainAPI,
         this.bitcoinNetwork,
-        multisigPayment.address as string,
+        bitcoinAmount,
+        multisigPayment,
         fundingPayment,
         feeRate,
         vault.btcFeeRecipient,
-        vault.btcMintFeeBasisPoints.toBigInt(),
-        this.bitcoinBlockchainAPI
+        vault.btcMintFeeBasisPoints.toBigInt()
       );
 
       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,66 +361,135 @@ export class LedgerDLCHandler {
     }
   }
 
-  async createClosingPSBT(
+  async createWithdrawPSBT(
     vault: RawVault,
+    withdrawAmount: bigint,
+    attestorGroupPublicKey: string,
     fundingTransactionID: string,
     feeRateMultiplier?: number,
     customFeeRate?: bigint
   ): Promise<Psbt> {
     try {
-      const { fundingPayment, multisigPayment, taprootDerivedPublicKey } = this.getPayment();
-
-      if (fundingPayment.address === undefined) {
-        throw new Error('Could not get Addresses from Payments');
-      }
+      const { fundingPayment, taprootDerivedPublicKey, multisigPayment } = await this.createPayment(
+        vault.uuid,
+        attestorGroupPublicKey
+      );
 
       const feeRate =
         customFeeRate ??
         BigInt(await getFeeRate(this.bitcoinBlockchainFeeRecommendationAPI, feeRateMultiplier));
 
-      const closingPSBT = createClosingTransaction(
-        vault.valueLocked.toBigInt(),
+      const withdrawTransaction = await createWithdrawTransaction(
+        this.bitcoinBlockchainAPI,
         this.bitcoinNetwork,
+        withdrawAmount,
         fundingTransactionID,
         multisigPayment,
-        fundingPayment.address,
+        fundingPayment,
         feeRate,
         vault.btcFeeRecipient,
         vault.btcRedeemFeeBasisPoints.toBigInt()
       );
 
-      const closingTransactionSigningConfiguration = createBitcoinInputSigningConfiguration(
-        closingPSBT,
+      const withdrawTransactionSigningConfiguration = createBitcoinInputSigningConfiguration(
+        withdrawTransaction,
         this.walletAccountIndex,
         this.bitcoinNetwork
       );
 
-      const formattedClosingPSBT = Psbt.fromBuffer(Buffer.from(closingPSBT), {
+      const formattedWithdrawPSBT = Psbt.fromBuffer(Buffer.from(withdrawTransaction.toPSBT()), {
         network: this.bitcoinNetwork,
       });
 
-      const closingInputByPaymentTypeArray = getInputByPaymentTypeArray(
-        closingTransactionSigningConfiguration,
-        formattedClosingPSBT.toBuffer(),
+      const withdrawInputByPaymentTypeArray = getInputByPaymentTypeArray(
+        withdrawTransactionSigningConfiguration,
+        formattedWithdrawPSBT.toBuffer(),
         this.bitcoinNetwork
       );
 
-      const taprootInputsToSign = getTaprootInputsToSign(closingInputByPaymentTypeArray);
+      const taprootInputsToSign = getTaprootInputsToSign(withdrawInputByPaymentTypeArray);
 
       await updateTaprootInputs(
         taprootInputsToSign,
         taprootDerivedPublicKey,
         this.masterFingerprint,
-        formattedClosingPSBT
+        formattedWithdrawPSBT
       );
 
-      return formattedClosingPSBT;
+      return formattedWithdrawPSBT;
     } catch (error: any) {
-      throw new Error(`Error creating Closing PSBT: ${error}`);
+      throw new Error(`Error creating Withdraw PSBT: ${error}`);
     }
   }
 
-  async signPSBT(psbt: Psbt, transactionType: 'funding' | 'closing'): Promise<Transaction> {
+  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);
+
+    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 depositInputByPaymentTypeArray = getInputByPaymentTypeArray(
+      depositTransactionSigningConfiguration,
+      formattedDepositPSBT.toBuffer(),
+      this.bitcoinNetwork
+    );
+
+    const taprootInputsToSign = getTaprootInputsToSign(depositInputByPaymentTypeArray);
+    const nativeSegwitInputsToSign = getNativeSegwitInputsToSign(depositInputByPaymentTypeArray);
+
+    await updateTaprootInputs(
+      taprootInputsToSign,
+      taprootDerivedPublicKey,
+      this.masterFingerprint,
+      formattedDepositPSBT
+    );
+
+    await updateNativeSegwitInputs(
+      nativeSegwitInputsToSign,
+      fundingDerivedPublicKey,
+      this.masterFingerprint,
+      formattedDepositPSBT,
+      this.bitcoinBlockchainAPI
+    );
+
+    return formattedDepositPSBT;
+  }
+
+  async signPSBT(
+    psbt: Psbt,
+    transactionType: 'funding' | 'deposit' | 'withdraw'
+  ): Promise<Transaction> {
     try {
       const { fundingWalletPolicy, multisigWalletPolicy, multisigWalletPolicyHMac } =
         this.getPolicyInformation();
@@ -444,13 +513,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: