@teleportdao/bitcoin 3.0.0 → 4.0.0-alpha.0

package/src/helper/ordinal-helper.ts

@@ -3,89 +3,6 @@ import ecc from "@bitcoinerlab/secp256k1"
 
 bitcoin.initEccLib(ecc)
 
-// eslint-disable-next-line consistent-return
-export function createAddressObjectByScriptNoType(
-  script: Buffer,
-  network: bitcoin.Network = bitcoin.networks.bitcoin,
-) {
-  let addressObject: bitcoin.payments.Payment
-
-  try {
-    addressObject = bitcoin.payments.p2pkh({
-      output: script,
-      network,
-    })
-    if (addressObject.address) {
-      return {
-        addressObject,
-        addressType: "p2pkh",
-      }
-    }
-  } catch (err) {
-    /* empty */
-  }
-
-  try {
-    addressObject = bitcoin.payments.p2wpkh({
-      output: script,
-      network,
-    })
-    if (addressObject.address) {
-      return {
-        addressObject,
-        addressType: "p2wpkh",
-      }
-    }
-  } catch (err) {
-    /* empty */
-  }
-
-  try {
-    addressObject = bitcoin.payments.p2sh({
-      output: script,
-      network,
-    })
-    if (addressObject.address) {
-      return {
-        addressObject,
-        addressType: "p2sh",
-      }
-    }
-  } catch (err) {
-    /* empty */
-  }
-
-  try {
-    addressObject = bitcoin.payments.p2wsh({
-      output: script,
-      network,
-    })
-    if (addressObject.address) {
-      return {
-        addressObject,
-        addressType: "p2wsh",
-      }
-    }
-  } catch (err) {
-    /* empty */
-  }
-
-  try {
-    addressObject = bitcoin.payments.p2tr({
-      output: script,
-      network,
-    })
-    if (addressObject.address) {
-      return {
-        addressObject,
-        addressType: "p2tr",
-      }
-    }
-  } catch (err) {
-    /* empty */
-  }
-}
-
 export function splitBuffer(buffer: Buffer, partLength: number) {
   const parts: Buffer[] = []
   for (let i = 0; i < buffer.length; i += partLength) {

package/src/index.ts

@@ -6,6 +6,8 @@ export * from "./teleswap-wallet"
 export * from "./ordinal-wallet"
 export * from "./bitcoin-wallet-base"
 //
+export * from "./multisig-wallet-helper"
+//
 export * from "./bitcoin-interface-utils"
 export * from "./bitcoin-interface"
 export * from "./bitcoin-interface-teleswap"

package/src/multisig-wallet-helper.ts

@@ -0,0 +1,296 @@
+import { TeleportdaoMultisigCoordinator, TxRequest } from "@teleportdao/providers"
+import BigNumber from "bignumber.js"
+import { BitcoinBaseWallet, FeeRateType } from "./bitcoin-wallet-base"
+import {
+  ExtendedUnsignedTransaction,
+  ExtendedUtxo,
+  SignerInfo,
+  TargetAddress,
+} from "./transaction-builder"
+
+export class MultisigWalletHelper {
+  baseWallet: BitcoinBaseWallet
+  coordinator: TeleportdaoMultisigCoordinator
+  acceptableFeeDiff: number
+  txCheckConfig: { sleepTime: number; maxRetry: number }
+  txCounter?: number
+  txCounterMonitor: boolean
+  coordinatorUrl: string
+  coordinatorApiKey?: string
+  constructor(
+    baseWallet: BitcoinBaseWallet,
+    coordinatorUrl: string,
+    coordinatorApiKey?: string,
+    txCounterMonitor = true,
+    acceptableFeeDiffPercentage?: number,
+    txCheckConfig?: { sleepTime: number; maxRetry: number },
+  ) {
+    this.baseWallet = baseWallet
+    this.coordinatorUrl = coordinatorUrl
+    this.coordinator = new TeleportdaoMultisigCoordinator(coordinatorUrl, coordinatorApiKey)
+    this.acceptableFeeDiff = acceptableFeeDiffPercentage || 30
+    this.txCheckConfig = txCheckConfig || {
+      sleepTime: 1500,
+      maxRetry: 30,
+    }
+    this.txCounterMonitor = txCounterMonitor
+    this.txCounter = undefined
+  }
+
+  get bitcoinAddress() {
+    return this.baseWallet.bitcoinAddress
+  }
+
+  setAccountType(
+    addressType: "p2sh" | "p2wsh" | "p2sh-p2wsh",
+    publicKeys: string[],
+    numberOfSigners?: number,
+  ) {
+    if (
+      !this.baseWallet.publicKey ||
+      !publicKeys.includes(this.baseWallet.publicKey.toString("hex"))
+    ) {
+      throw new Error("public keys not match with the key")
+    }
+
+    return this.baseWallet.setAccountType(addressType, {
+      publicKeys,
+      numberOfSigners,
+    })
+  }
+
+  async setAPIKey() {
+    if (
+      !this.baseWallet.signerInfo ||
+      !this.baseWallet.signerInfo.publicKeys ||
+      !this.baseWallet.bitcoinAddress
+    ) {
+      throw new Error("wallet not initialized")
+    }
+    let response = await this.coordinator.registerOrGetWallet(
+      this.baseWallet.signerInfo.publicKey,
+      this.baseWallet.signerInfo.publicKeys,
+      this.baseWallet.bitcoinAddress,
+      this.baseWallet.signerInfo.addressType,
+      this.baseWallet.signerInfo.numberOfSigners,
+    )
+    this.coordinator = new TeleportdaoMultisigCoordinator(this.coordinatorUrl, response.apiKey)
+    return response
+  }
+
+  async setTxCounter(txCounter: number) {
+    if (this.txCounterMonitor) this.txCounter = txCounter
+  }
+
+  async resetTxCounter() {
+    const wallet = await this.coordinator.getWallet()
+    this.setTxCounter(wallet.txCounter)
+    return wallet.txCounter
+  }
+
+  async step1SendBTCToMultipleAddressUnsigned(
+    receivers: TargetAddress[],
+    signerInfo: SignerInfo,
+    fee: FeeRateType = "normal",
+    staticExtendedUtxo?: ExtendedUtxo[],
+    fullAmount = false,
+  ) {
+    try {
+      let unsignedTx = await this.baseWallet.sendBTCToMultipleAddressUnsignedTx(
+        receivers,
+        signerInfo,
+        fee,
+        staticExtendedUtxo,
+        fullAmount,
+      )
+
+      console.log("this.txCounter step 1 start", this.txCounter)
+
+      let txRequest = await this.coordinator.createOrConfirmNewTx({
+        inputs: unsignedTx.inputs.map((x) => ({
+          hash: x.hash,
+          index: x.index,
+          value: x.value,
+        })),
+        outputs: unsignedTx.outputs as any,
+        feeRate: unsignedTx.feeRate,
+        unsignedPsbt: unsignedTx.unsignedTransaction,
+        txCounter: this.txCounter,
+      })
+
+      if (txRequest.status !== "Rejected" && txRequest.status !== "Broadcasted") {
+        this.setTxCounter(txRequest.txCounter)
+      } else {
+        await this.resetTxCounter()
+      }
+
+      console.log("this.txCounter step 1 end", this.txCounter)
+      return {
+        txRequest,
+        unsignedTx,
+      }
+    } catch (e) {
+      await this.resetTxCounter()
+      throw e
+    }
+  }
+
+  async step2WaitForUnsignedTxApproval(input: {
+    unsignedTx: ExtendedUnsignedTransaction
+    txRequest: TxRequest
+  }) {
+    const feeRateDiffPercentage = this.acceptableFeeDiff
+    let newUnsignedTx = input.unsignedTx
+    let newTxRequest = input.txRequest
+
+    // Wait for approval
+    if (newTxRequest.status === "Pending") {
+      this.setTxCounter(newTxRequest.txCounter)
+
+      if (newTxRequest.unsignedPsbt !== newUnsignedTx.unsignedTransaction) {
+        const feeDiff = BigNumber(newTxRequest.feeRate)
+          .minus(newUnsignedTx.feeRate)
+          .abs()
+          .dividedBy(newUnsignedTx.feeRate)
+        if (!feeDiff.isLessThan(feeRateDiffPercentage / 100)) {
+          const txRequest = await this.coordinator.rejectTxRequest(newTxRequest.id)
+          this.setTxCounter((this.txCounter || txRequest.txCounter) + 1)
+          throw new Error("Reject because of Invalid FeeRate")
+        }
+
+        const { signerInfo } = newUnsignedTx.inputs[0]
+
+        console.log(newUnsignedTx.outputs, newTxRequest.outputs)
+
+        newUnsignedTx = await this.baseWallet.sendBTCToMultipleAddressUnsignedTx(
+          newUnsignedTx.outputs as TargetAddress[],
+          signerInfo,
+          +newTxRequest.feeRate,
+          newTxRequest.inputs.map((x) => ({
+            ...x,
+            signerInfo,
+          })),
+        )
+
+        let updatedTxRequest = await this.coordinator.confirmOrRejectTxRequest(
+          newTxRequest.id,
+          newUnsignedTx.unsignedTransaction,
+        )
+
+        if (
+          updatedTxRequest.status === "Rejected" ||
+          updatedTxRequest.unsignedPsbt !== newUnsignedTx.unsignedTransaction
+        ) {
+          console.log("not equal unsignedPsbt")
+          console.log(updatedTxRequest.unsignedPsbt)
+          console.log(newUnsignedTx.unsignedTransaction)
+          this.setTxCounter((this.txCounter || updatedTxRequest.txCounter) + 1)
+          throw new Error("Reject because of invalid outputs")
+        }
+        newTxRequest = updatedTxRequest
+      }
+
+      const updatedTxRequest = await this.coordinator.waitTxStatusChange(
+        newTxRequest.id,
+        "Pending",
+        this.txCheckConfig.sleepTime,
+        this.txCheckConfig.maxRetry,
+      )
+
+      if (!updatedTxRequest) {
+        await this.coordinator.rejectTxRequest(newTxRequest.id)
+        if (this.txCounter) this.setTxCounter(this.txCounter + 1)
+        throw new Error("Tx Timeout")
+      }
+      newTxRequest = updatedTxRequest
+
+      if (newTxRequest.status === "Rejected") {
+        if (this.txCounter) this.setTxCounter(this.txCounter + 1)
+        throw new Error("Tx Rejected")
+      }
+    }
+
+    if (newTxRequest.status === "Rejected") {
+      await this.resetTxCounter()
+      throw new Error("Tx was Rejected")
+    }
+    console.log("this.txCounter step 2 end", this.txCounter)
+
+    return {
+      unsignedTx: newUnsignedTx,
+      txRequest: newTxRequest,
+    }
+  }
+
+  // this step need privatekey
+  async step3SignTxAndWaitForBroadcast(input: {
+    unsignedTx: ExtendedUnsignedTransaction
+    txRequest: TxRequest
+  }) {
+    if (!this.baseWallet.privateKey) throw new Error("account is not initialized")
+    const { unsignedTx, txRequest } = input
+    let newTxRequest = txRequest
+    if (newTxRequest.status === "Approved") {
+      const signed = await this.baseWallet.signer.signPsbt(unsignedTx, this.baseWallet.privateKey!)
+      newTxRequest = await this.coordinator.submitSignedPsbt(newTxRequest.id, signed)
+    }
+
+    // Wait for broadcast
+    if (newTxRequest.status === "Approved") {
+      if (this.txCounter) this.setTxCounter(newTxRequest.txCounter)
+      const finalTx = await this.coordinator.waitTxStatusChange(
+        newTxRequest.id,
+        "Approved",
+        this.txCheckConfig.sleepTime,
+        this.txCheckConfig.maxRetry,
+      )
+      if (!finalTx || finalTx.status === "Failed") {
+        throw new Error("Tx not broadcasted for long time")
+      }
+      newTxRequest = finalTx
+    }
+
+    if (this.txCounter) this.setTxCounter(this.txCounter + 1)
+
+    console.log("this.txCounter step3", this.txCounter)
+
+    return newTxRequest
+  }
+
+  async sendBTCMultipleAddress(
+    receivers: TargetAddress[],
+    fee: FeeRateType = "normal",
+    staticExtendedUtxo?: ExtendedUtxo[],
+    fullAmount = false,
+  ) {
+    if (!this.baseWallet.signerInfo || !this.baseWallet.privateKey) {
+      throw new Error("account not initialized")
+    }
+    // todo catch error on different step and customize error so we can distinguish important error from regular error
+    let unsignedResponse = await this.step1SendBTCToMultipleAddressUnsigned(
+      receivers,
+      this.baseWallet.signerInfo,
+      fee,
+      staticExtendedUtxo,
+      fullAmount,
+    )
+    unsignedResponse = await this.step2WaitForUnsignedTxApproval(unsignedResponse)
+    const txRequest = await this.step3SignTxAndWaitForBroadcast(unsignedResponse)
+    return txRequest
+  }
+
+  async sendBTC(
+    receiverAddress: string,
+    amountInSatoshi: number | "all",
+    fee: FeeRateType = "normal",
+    staticExtendedUtxo?: ExtendedUtxo[],
+  ) {
+    const txRequest = await this.sendBTCMultipleAddress(
+      [{ address: receiverAddress, value: amountInSatoshi === "all" ? 0 : amountInSatoshi }],
+      fee,
+      staticExtendedUtxo,
+      amountInSatoshi === "all",
+    )
+    return txRequest
+  }
+}

package/src/sign/sign-transaction.ts

@@ -93,15 +93,13 @@ class BitcoinLikeSignTransaction {
     const finals = psbtsBase64.map((psbtBase64) =>
       Psbt.fromBase64(psbtBase64, { network: this.network }),
     )
-    const psbt =
-      finals.length === 1 ? finals[0] : new Psbt({ network: this.network }).combine(...finals)
-
+    let psbt = finals[0]
+    for (let i = 1; i < finals.length; i += 1) {
+      psbt.combine(finals[i])
+    }
     psbt.finalizeAllInputs()
-
     let finalizeTx = psbt.extractTransaction()
-    // const rawTx = finalizeTx.toBuffer()
-    // const hex = rawTx.toString("hex")
-    return finalizeTx.toHex()
+    return { hex: finalizeTx.toHex(), txId: finalizeTx.getId(), vBytes: finalizeTx.virtualSize() }
   }
 }