@teleportdao/bitcoin 1.8.9 → 2.0.0

package/src/bitcoin-wallet-base.ts

@@ -5,17 +5,24 @@ import BIP32Factory from "bip32"
 import ecc from "@bitcoinerlab/secp256k1"
 import BigNumber from "bignumber.js"
 import { BitcoinTransactionBuilder } from "./transaction-builder"
-import type { BitcoinConnectionInfo } from "./type"
+import type { APIConnectionInfo, RPCConnectionInfo, UtxoConnectionInfo } from "./type"
 
-import type { ExtendedUtxo, SignerInfo, Target } from "./transaction-builder/transaction-builder"
+import type {
+  ExtendedUtxo,
+  SignerInfo,
+  Target,
+  TargetAddress,
+} from "./transaction-builder/transaction-builder"
 import BitcoinSign from "./sign/sign-transaction"
 
 import { getPubKeyFromPrivateKeyHex } from "./bitcoin-utils"
 import networks from "./utils/networks"
-import { BitcoinInterface } from "./bitcoin-interface"
+import { BitcoinInterfaceWallet } from "./bitcoin-interface-wallet"
+import { runWithRetries } from "./utils/tools"
 
 const bip32 = BIP32Factory(ecc)
 
+export type FeeRateType = "normal" | "slow" | "fast" | number
 export class BitcoinBaseWallet {
   network: Network
   hdWalletPath: {
@@ -28,7 +35,7 @@ export class BitcoinBaseWallet {
     p2tr: string
   }
   transactionBuilder: BitcoinTransactionBuilder
-  btcInterface: BitcoinInterface
+  btcInterface: BitcoinInterfaceWallet
   signer: BitcoinSign
   currentAccount?: string
   currentAccountType?: string
@@ -39,33 +46,41 @@ export class BitcoinBaseWallet {
   bitcoinAddress: string | undefined
   constructor(
     networkName: string,
-    connectionInfo: BitcoinConnectionInfo = {
-      api: {
-        provider: "BlockStream",
-      },
+    connectionInfo?: {
+      utxo?: UtxoConnectionInfo
+      // rpc used for getRawTransaction in transaction builder if set (optional)
+      rpc?: RPCConnectionInfo
     },
   ) {
     this.network = networks[networkName]
     this.hdWalletPath = hdWalletPath.bitcoin
 
     this.transactionBuilder = new BitcoinTransactionBuilder(
-      connectionInfo,
       networkName,
       this.network,
+      connectionInfo,
     )
     this.btcInterface = this.transactionBuilder.btcInterface
 
     this.signer = new BitcoinSign(this.network)
 
+    // initialize account
     this.currentAccount = undefined
     this.currentAccountType = undefined
-
     this.privateKey = undefined
     this.publicKey = undefined
-    // todo multisig
-    this.publicKeys = []
   }
 
+  static satoshiToBTC(satoshi: number | string) {
+    return new BigNumber(satoshi).dividedBy(1e8).toString()
+  }
+
+  static btcToSatoshi(btc: number | string) {
+    return new BigNumber(btc).multipliedBy(1e8).toFixed(0)
+  }
+
+  // initialize account
+
   get signerInfo() {
     return this.privateKey
       ? {
@@ -76,82 +91,26 @@ export class BitcoinBaseWallet {
       : undefined
   }
 
-  createTransactionInputsAndOutputs({
-    targets,
-    extendedUtxo,
-    changeAddress,
-    feeRate,
-  }: {
-    targets: Target[]
-    extendedUtxo: ExtendedUtxo[]
-    changeAddress: string
-    feeRate: number
-    fullAmount?: boolean
-  }) {
-    return this.transactionBuilder.helperHandleInputsAndOutputs({
-      targets,
-      extendedUtxo,
-      changeObject: {
-        address: changeAddress,
-      },
-      feeRate,
-    })
-  }
-
-  checkBalanceIsSufficient({
-    targets,
-    extendedUtxo,
-    changeAddress,
-    feeRate,
-    fullAmount = false,
-  }: {
-    targets: Target[]
-    extendedUtxo: ExtendedUtxo[]
-    changeAddress: string
-    feeRate: number
-    fullAmount?: boolean
-  }) {
-    try {
-      this.transactionBuilder.helperHandleInputsAndOutputs({
-        targets,
-        extendedUtxo,
-        changeObject: {
-          address: changeAddress,
-        },
-        feeRate,
-      })
-      return true
-    } catch (err) {
-      return false
-    }
-  }
-
-  // todo : not completed
-  setMultiSigAccount(accountType = "p2sh") {
-    throw new Error("not supported yet")
-
-    /* eslint-disable no-unreachable */
-    // todo : not completed
-    switch (accountType) {
-      // case 'p2sh':
-      //   this.currentAccount = ''
-      //   break
-      // case 'p2wsh':
-      //   this.currentAccount = ''
-      //   break
-      // case 'p2sh-p2wsh':
-      //   this.currentAccount = ''
-      //   break
-      default:
-        throw new Error("accountType is incorrect")
-    }
-    this.currentAccountType = accountType
-  }
-
   setAccountPrivateKey(privateKeyHex: string) {
     this.privateKey = Buffer.from(privateKeyHex, "hex")
     let publicKey = getPubKeyFromPrivateKeyHex(privateKeyHex, this.network)
     this.publicKey = publicKey
+    this.setAccountType("p2wpkh")
+  }
+
+  setAccountType(accountType = "p2pkh") {
+    if (!this.publicKey) {
+      throw new Error("account not initialized")
+    }
+    let addressObj = this.transactionBuilder.createAddressObject({
+      addressType: accountType,
+      publicKey: this.publicKey,
+    })
+    this.currentAccount = addressObj.address
+    this.currentAccountType = accountType
+    this.addressObj = addressObj
+    this.bitcoinAddress = addressObj.address
+    return addressObj.address!
   }
 
   setAccountPrivateKeyByMnemonic({
@@ -179,87 +138,162 @@ export class BitcoinBaseWallet {
     const account = node.derivePath(path)
     const userKeyPair = account.derive(index)
     this.setAccountPrivateKey(userKeyPair.privateKey!.toString("hex"))
-    return this.setAccount(addressType)
+    return this.setAccountType(addressType)
   }
 
-  setAccountPublicKey(publicKeyHex: string) {
-    this.publicKey = Buffer.from(publicKeyHex, "hex")
-  }
+  // helper function
 
-  setAccount(accountType = "p2pkh") {
-    if (!this.publicKey) {
-      throw new Error("account not initialized")
+  checkBalanceIsSufficient({
+    targets,
+    extendedUtxo,
+    changeAddress,
+    feeRate,
+  }: {
+    targets: Target[]
+    extendedUtxo: ExtendedUtxo[]
+    changeAddress: string
+    feeRate: number
+  }) {
+    try {
+      this.transactionBuilder.helperHandleInputsAndOutputs({
+        targets,
+        extendedUtxo,
+        changeObject: {
+          address: changeAddress,
+        },
+        feeRate,
+      })
+      return true
+    } catch (err) {
+      return false
     }
-    let addressObj = this.transactionBuilder.createAddressObject({
-      addressType: accountType,
-      publicKey: this.publicKey,
-    })
-    this.currentAccount = addressObj.address
-    this.currentAccountType = accountType
-    this.addressObj = addressObj
-    this.bitcoinAddress = addressObj.address
-    return addressObj.address
   }
 
-  //
-
   async getExtendedUtxo(input: SignerInfo) {
-    return this.transactionBuilder.getExtendedUtxo(input)
+    return this.btcInterface.getExtendedUtxo(input)
+  }
+
+  async getFeeRate(feeRate: FeeRateType = "normal") {
+    if (feeRate === 0) throw new Error("feeRate should be greater than 0")
+    if (+feeRate > 0) return +feeRate
+    if (typeof feeRate === "string") return this.btcInterface.getFeeRate(feeRate)
+    throw new Error("incorrect feeRate")
   }
 
-  async send(
+  // signed methods
+
+  async sendBTC(
     receiverAddress: string,
-    amount: string | number,
-    fullAmount = false,
-    speed: "normal" | "slow" | "fast" = "normal",
+    amountInSatoshi: number | "all",
+    fee: FeeRateType = "normal",
+    staticExtendedUtxo?: ExtendedUtxo[],
   ) {
-    if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
+    if (!this.signerInfo! || !this.privateKey) {
       throw new Error("account not initialized")
     }
+    const unsignedTx = await this.sendBTCUnsignedTx(
+      receiverAddress,
+      amountInSatoshi,
+      this.signerInfo!,
+      fee,
+      staticExtendedUtxo,
+    )
+    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
+    let signedTx = this.signer.finalizePsbts([signedPsbt])
+    let txId = await this.sendSignedTx(signedTx)
+    return txId
+  }
+
+  async sendBTCMultipleAddress(
+    receivers: TargetAddress[],
+    fee: FeeRateType = "normal",
+    staticExtendedUtxo?: ExtendedUtxo[],
+  ) {
+    if (!this.signerInfo! || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+    const unsignedTx = await this.sendBTCToMultipleAddressUnsignedTx(
+      receivers,
+      this.signerInfo!,
+      fee,
+      staticExtendedUtxo,
+    )
+    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
+    let signedTx = this.signer.finalizePsbts([signedPsbt])
+    let txId = await this.sendSignedTx(signedTx)
+    return txId
+  }
+
+  // unsigned methods
+  async sendBTCToMultipleAddressUnsignedTx(
+    receivers: TargetAddress[],
+    signerInfo: SignerInfo,
+    fee: FeeRateType = "normal",
+    staticExtendedUtxo?: ExtendedUtxo[],
+    fullAmount = false,
+  ) {
+    if (!fullAmount) {
+      receivers.forEach((r) => {
+        if (BigNumber(r.value).isEqualTo(0)) throw new Error("incorrect amount")
+      })
+    } else if (receivers.length > 1) throw new Error("fullAmount only support one receiver")
+
+    let feeRate = await this.getFeeRate(fee)
+    let extendedUtxo = staticExtendedUtxo || (await this.getExtendedUtxo(signerInfo))
 
-    let extendedUtxo = await this.getExtendedUtxo({
-      address: this.currentAccount,
-      addressType: this.currentAccountType,
-      publicKey: this.publicKey.toString("hex"),
-    })
-    if (!fullAmount && BigNumber(amount).isEqualTo(0))
-      throw new Error("incorrect amount. amount should be in satoshi")
-    let feeRate = await this.transactionBuilder._getFeeRate(speed)
     let unsignedTx = await this.transactionBuilder.processUnsignedTransaction({
       extendedUtxo,
-      targets: [
-        {
-          address: receiverAddress,
-          value: +amount,
-        },
-      ],
-      changeAddress: this.currentAccount,
+      targets: receivers,
+      changeAddress: signerInfo.address,
       feeRate,
       fullAmount,
     })
-    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
-    let signedTx = this.signer.finalizePsbts([signedPsbt])
-    let txId = await this.transactionBuilder.sendTx(signedTx)
+    return unsignedTx
+  }
+
+  async sendBTCUnsignedTx(
+    receiver: string,
+    amountInSatoshi: number | "all",
+    signerInfo: SignerInfo,
+    fee: FeeRateType = "normal",
+    staticExtendedUtxo?: ExtendedUtxo[],
+  ) {
+    return this.sendBTCToMultipleAddressUnsignedTx(
+      [{ address: receiver, value: amountInSatoshi === "all" ? 0 : amountInSatoshi }],
+      signerInfo,
+      fee,
+      staticExtendedUtxo,
+      amountInSatoshi === "all",
+    )
+  }
+
+  // send tx
+
+  async sendSignedTx(signedTx: string) {
+    let txId = await this.btcInterface.sendRawTransaction(signedTx)
     return txId
   }
 
   async sendSignedPsbt(signedPsbt: string) {
     let signedTx = this.signer.finalizePsbts([signedPsbt])
-    let txId = await this.transactionBuilder.sendTx(signedTx)
+    let txId = await this.sendSignedTx(signedTx)
     return txId
   }
 
-  async sendSignedTx(signedTx: string) {
-    let txId = await this.transactionBuilder.sendTx(signedTx)
-    return txId
+  async sendSignedPsbtWithRetry(signedPsbt: string, { maxTries = 5, retrySleep = 5000 } = {}) {
+    return runWithRetries(() => this.sendSignedPsbt(signedPsbt), {
+      retrySleep,
+      maxTries,
+    })
   }
 
   async sendMultiSignedPsbt(signedPsbts: string[] = []) {
     let signedTx = this.signer.finalizePsbts(signedPsbts)
-    let txId = await this.transactionBuilder.sendTx(signedTx)
+    let txId = await this.btcInterface.sendRawTransaction(signedTx)
     return txId
   }
 
+  // increase transaction fee (beta vesrion)
   async increaseTransactionFeeUnsignedPsbt(
     txId: string,
     signerInfos: SignerInfo[],
@@ -284,7 +318,7 @@ export class BitcoinBaseWallet {
       transaction.vin.find((vi) => vo.address === vi.address || vo.address === changeAddress),
     )
 
-    const feeRate = staticFeeRate || (await this.transactionBuilder._getFeeRate("fast"))
+    const feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("fast"))
 
     let targets = transaction.vout
       .filter((_, index) => index !== changeIndex)