feat: deposit-withdrawal

src/attestor-handlers/attestor-handler.ts

@@ -1,79 +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,
-    fundingTransactionPsbt: string,
-    mintAddress: string,
-    alicePubkey: 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_psbt: fundingTransactionPsbt,
-      mint_address: mintAddress,
-      chain: this.ethereumChainID,
-      alice_pubkey: alicePubkey,
+      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);
-
-    const failedResponses = responses.filter(response => response !== true);
-
-    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 [Funding] Transaction to Attestors:
+          ${attestorResponses.join('| ')}`
       );
     }
   }
 
-  async submitWithdrawRequest(vaultUUID: string, withdrawPSBT: string): Promise<void> {
-    const withdrawEndpoints = this.attestorRootURLs.map(url => `${url}/app/withdraw`);
+  async submitWithdrawDepositPSBT(
+    withdrawDepositTXAttestorInfo: WithdrawDepositTXAttestorInfo
+  ): Promise<void> {
+    const depositWithdrawEndpoints = this.attestorRootURLs.map(url => `${url}/app/withdraw`);
 
     const body = JSON.stringify({
-      uuid: vaultUUID,
-      wd_psbt: withdrawPSBT,
+      uuid: withdrawDepositTXAttestorInfo.vaultUUID,
+      wd_psbt: withdrawDepositTXAttestorInfo.depositWithdrawPSBT,
     });
 
-    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 attestorResponses: (boolean | string)[] = await Promise.all(
+      depositWithdrawEndpoints.map(async url =>
+        this.sendRequest(url, body)
+          .then(response => response)
+          .catch(error => error.message)
+      )
     );
 
-    const responses = await Promise.all(requests);
-
-    const failedResponses = responses.filter(response => response !== true);
-
-    if (failedResponses.length === withdrawEndpoints.length) {
+    if (attestorResponses.every(response => response !== true)) {
       throw new AttestorError(
-        `Error sending Withdraw Transaction to Attestors: ${failedResponses.join(', ')}`
+        `Error sending [Deposit/Withdraw] Transaction to Attestors:
+          ${attestorResponses.join('| ')}`
       );
     }
   }

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

@@ -20,7 +20,7 @@ import {
   addTaprootInputSignaturesToPSBT,
   createDepositTransaction,
   createFundingTransaction,
-  createWithdrawalTransaction,
+  createWithdrawTransaction,
   getNativeSegwitInputsToSign,
   getTaprootInputsToSign,
   updateNativeSegwitInputs,
@@ -297,32 +297,25 @@ 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 fundingTransaction = await createFundingTransaction(
-        bitcoinAmount,
+        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(
@@ -368,7 +361,7 @@ export class LedgerDLCHandler {
     }
   }
 
-  async createWithdrawalPSBT(
+  async createWithdrawPSBT(
     vault: RawVault,
     withdrawAmount: bigint,
     attestorGroupPublicKey: string,
@@ -382,54 +375,50 @@ export class LedgerDLCHandler {
         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 withdrawalTransaction = await createWithdrawalTransaction(
+      const withdrawTransaction = await createWithdrawTransaction(
         this.bitcoinBlockchainAPI,
-        withdrawAmount,
         this.bitcoinNetwork,
+        withdrawAmount,
         fundingTransactionID,
         multisigPayment,
-        fundingPayment.address,
+        fundingPayment,
         feeRate,
         vault.btcFeeRecipient,
         vault.btcRedeemFeeBasisPoints.toBigInt()
       );
 
-      const withdrawalTransactionSigningConfiguration = createBitcoinInputSigningConfiguration(
-        withdrawalTransaction,
+      const withdrawTransactionSigningConfiguration = createBitcoinInputSigningConfiguration(
+        withdrawTransaction,
         this.walletAccountIndex,
         this.bitcoinNetwork
       );
 
-      const formattedWithdrawalPSBT = Psbt.fromBuffer(Buffer.from(withdrawalTransaction.toPSBT()), {
+      const formattedWithdrawPSBT = Psbt.fromBuffer(Buffer.from(withdrawTransaction.toPSBT()), {
         network: this.bitcoinNetwork,
       });
 
-      const withdrawalInputByPaymentTypeArray = getInputByPaymentTypeArray(
-        withdrawalTransactionSigningConfiguration,
-        formattedWithdrawalPSBT.toBuffer(),
+      const withdrawInputByPaymentTypeArray = getInputByPaymentTypeArray(
+        withdrawTransactionSigningConfiguration,
+        formattedWithdrawPSBT.toBuffer(),
         this.bitcoinNetwork
       );
 
-      const taprootInputsToSign = getTaprootInputsToSign(withdrawalInputByPaymentTypeArray);
+      const taprootInputsToSign = getTaprootInputsToSign(withdrawInputByPaymentTypeArray);
 
       await updateTaprootInputs(
         taprootInputsToSign,
         taprootDerivedPublicKey,
         this.masterFingerprint,
-        formattedWithdrawalPSBT
+        formattedWithdrawPSBT
       );
 
-      return formattedWithdrawalPSBT;
+      return formattedWithdrawPSBT;
     } catch (error: any) {
-      throw new Error(`Error creating Withdrawal PSBT: ${error}`);
+      throw new Error(`Error creating Withdraw PSBT: ${error}`);
     }
   }
 
@@ -444,10 +433,6 @@ export class LedgerDLCHandler {
     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));
@@ -474,14 +459,14 @@ export class LedgerDLCHandler {
       network: this.bitcoinNetwork,
     });
 
-    const withdrawalInputByPaymentTypeArray = getInputByPaymentTypeArray(
+    const depositInputByPaymentTypeArray = getInputByPaymentTypeArray(
       depositTransactionSigningConfiguration,
       formattedDepositPSBT.toBuffer(),
       this.bitcoinNetwork
     );
 
-    const taprootInputsToSign = getTaprootInputsToSign(withdrawalInputByPaymentTypeArray);
-    const nativeSegwitInputsToSign = getNativeSegwitInputsToSign(withdrawalInputByPaymentTypeArray);
+    const taprootInputsToSign = getTaprootInputsToSign(depositInputByPaymentTypeArray);
+    const nativeSegwitInputsToSign = getNativeSegwitInputsToSign(depositInputByPaymentTypeArray);
 
     await updateTaprootInputs(
       taprootInputsToSign,

src/dlc-handlers/private-key-dlc-handler.ts

@@ -19,7 +19,7 @@ import {
 import {
   createDepositTransaction,
   createFundingTransaction,
-  createWithdrawalTransaction,
+  createWithdrawTransaction,
 } from '../functions/bitcoin/psbt-functions.js';
 import { PaymentInformation } from '../models/bitcoin-models.js';
 import { RawVault } from '../models/ethereum-models.js';
@@ -213,14 +213,7 @@ export class PrivateKeyDLCHandler {
       attestorGroupPublicKey
     );
 
-    if ([multisigPayment.address, fundingPayment.address].some(x => x === undefined)) {
-      throw new Error('Payment Address is undefined');
-    }
-
-    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');
@@ -231,20 +224,20 @@ export class PrivateKeyDLCHandler {
       BigInt(await getFeeRate(this.bitcoinBlockchainFeeRecommendationAPI, feeRateMultiplier));
 
     const fundingTransaction = await createFundingTransaction(
-      bitcoinAmount,
+      this.bitcoinBlockchainAPI,
       this.bitcoinNetwork,
-      multisigPayment.address as string,
+      bitcoinAmount,
+      multisigPayment,
       fundingPayment,
       feeRate,
       vault.btcFeeRecipient,
-      vault.btcMintFeeBasisPoints.toBigInt(),
-      this.bitcoinBlockchainAPI
+      vault.btcMintFeeBasisPoints.toBigInt()
     );
 
     return fundingTransaction;
   }
 
-  async createWithdrawalPSBT(
+  async createWithdrawPSBT(
     vault: RawVault,
     withdrawAmount: bigint,
     attestorGroupPublicKey: string,
@@ -258,28 +251,24 @@ export class PrivateKeyDLCHandler {
         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 withdrawalTransaction = await createWithdrawalTransaction(
+      const withdrawTransaction = await createWithdrawTransaction(
         this.bitcoinBlockchainAPI,
-        withdrawAmount,
         this.bitcoinNetwork,
+        withdrawAmount,
         fundingTransactionID,
         multisigPayment,
-        fundingPayment.address!,
+        fundingPayment,
         feeRate,
         vault.btcFeeRecipient,
         vault.btcRedeemFeeBasisPoints.toBigInt()
       );
-      return withdrawalTransaction;
+      return withdrawTransaction;
     } catch (error: any) {
-      throw new Error(`Error creating Withdrawal PSBT: ${error}`);
+      throw new Error(`Error creating Withdraw PSBT: ${error}`);
     }
   }
 
@@ -325,10 +314,6 @@ export class PrivateKeyDLCHandler {
       attestorGroupPublicKey
     );
 
-    if (multisigPayment.address === undefined || fundingPayment.address === undefined) {
-      throw new Error('Payment Address is undefined');
-    }
-
     const feeRate =
       customFeeRate ??
       BigInt(await getFeeRate(this.bitcoinBlockchainFeeRecommendationAPI, feeRateMultiplier));