@teleportdao/bitcoin 1.4.3 → 1.4.6

package/src/{bitcoin-base.js → bitcoin-base.ts}

@@ -1,219 +1,248 @@
-const bip39 = require("bip39")
-const bip32 = require("bip32")
-const hdWalletNetworksPath = require("@teleportdao/configs").hdWalletPath
-const { getPubKeyFromPrivateKeyHex } = require("./bitcoin-utils")
-const networks = require("./utils/networks")
-
-const TransactionBuilder = require("./transaction-builder/bitcoin-transaction-builder")
-const BitcoinSign = require("./sign/sign-transaction")
-
-class BitcoinBase {
-  constructor(
-    networkName,
-    connectionInfo = {
-      api: {
-        enabled: true,
-        provider: "BlockStream",
-      },
-    },
-  ) {
-    this.network = networks[networkName]
-    this.hdWalletPath = hdWalletNetworksPath[networkName.replace("_testnet", "")]
-
-    this.transactionBuilder = new TransactionBuilder(connectionInfo, networkName, this.network)
-    this.btcInterface = this.transactionBuilder.btcInterface
-
-    this.signer = new BitcoinSign(this.network)
-
-    this.currentAccount = null
-    this.currentAccountType = null
-
-    this.privateKey = null
-    this.publicKey = null
-    // todo multisig
-    this.publicKeys = []
-  }
-
-  static createTransactionInputsAndOutputs({
-    targets,
-    extendedUtxo,
-    changeAddress,
-    feeRate,
-    fullAmount = false,
-  }) {
-    return TransactionBuilder.helperHandleInputsAndOutputs({
-      targets,
-      extendedUtxo,
-      changeAddress,
-      feeRate,
-      fullAmount,
-    })
-  }
-
-  static checkBalanceIsSufficient({
-    targets,
-    extendedUtxo,
-    changeAddress,
-    feeRate,
-    fullAmount = false,
-  }) {
-    try {
-      TransactionBuilder.helperHandleInputsAndOutputs({
-        targets,
-        extendedUtxo,
-        changeAddress,
-        feeRate,
-        fullAmount,
-      })
-      return true
-    } catch (err) {
-      return false
-    }
-  }
-
-  setMultiSigAccount(accountType = "p2sh") {
-    /* 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) {
-    this.privateKey = Buffer.from(privateKeyHex, "hex")
-    let publicKey = getPubKeyFromPrivateKeyHex(privateKeyHex, this.network)
-    this.publicKey = publicKey
-  }
-
-  setAccountPublicKey(publicKeyHex) {
-    this.publicKey = Buffer.from(publicKeyHex, "hex")
-  }
-
-  /**
-   *
-   * @param {*} input
-   * @param {*} input.mnemonic
-   * @param {*} input.mnemonicPassword
-   * @param {*} input.index
-   * @param {*} input.walletNumber
-   * @param {*} input.addressType
-   * @returns
-   */
-  setAccountPrivateKeyByMnemonic({
-    mnemonic,
-    mnemonicPassword = "",
-    index = 0,
-    walletNumber = 0,
-    addressType = "p2sh-p2wpkh",
-  }) {
-    if (!bip39.validateMnemonic(mnemonic)) throw new Error("invalid mnemonic")
-    const seed = bip39.mnemonicToSeedSync(mnemonic, mnemonicPassword)
-    const node = bip32.fromSeed(seed)
-
-    if (!this.hdWalletPath[addressType]) throw new Error("incorrect path or addressType")
-
-    const path = `${this.hdWalletPath[addressType]}/${walletNumber}`
-    const account = node.derivePath(path)
-    const userKeyPair = account.derive(index)
-    this.setAccountPrivateKey(userKeyPair.privateKey.toString("hex"))
-    return this.setAccount(addressType)
-  }
-
-  setAccount(accountType = "p2pkh") {
-    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
-  }
-
-  /**
-   *
-   * @param {Object} signerInfo
-   * @param {*} signerInfo.address
-   * @param {*} signerInfo.addressType
-   * @param {*} signerInfo.publicKey
-   * @param {*} signerInfo.derivationPath
-   * @param {*} signerInfo.masterFingerprint
-   * @returns
-   */
-  async getExtendedUtxo({ address, addressType, publicKey, derivationPath, masterFingerprint }) {
-    return this.transactionBuilder.getExtendedUtxo({
-      address,
-      addressType,
-      publicKey,
-      derivationPath,
-      masterFingerprint,
-    })
-  }
-
-  /**
-   *
-   * @param {*} input
-   * @param {*} input.receiverAddress
-   * @param {*} input.amount
-   * @param {*} input.fullAmount
-   * @param {*} input.speed
-   * @returns
-   */
-  async send({ receiverAddress, amount, fullAmount = false, speed = "normal" }) {
-    let extendedUtxo = await this.getExtendedUtxo({
-      address: this.currentAccount,
-      addressType: this.currentAccountType,
-      publicKey: this.publicKey.toString("hex"),
-    })
-    if (amount - +amount.toFixed() !== 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,
-      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 txId
-  }
-
-  async sendSignedPsbt(signedPsbt) {
-    let signedTx = this.signer.finalizePsbts([signedPsbt])
-    let txId = await this.transactionBuilder.sendTx(signedTx)
-    return txId
-  }
-
-  async sendSignedTx(signedTx) {
-    let txId = await this.transactionBuilder.sendTx(signedTx)
-    return txId
-  }
-
-  async sendMultiSignedPsbt(signedPsbts = []) {
-    let signedTx = this.signer.finalizePsbts(signedPsbts)
-    let txId = await this.transactionBuilder.sendTx(signedTx)
-    return txId
-  }
-}
-
-module.exports = BitcoinBase
+import TransactionBuilder, {
+  BitcoinConnectionInfo,
+} from "./transaction-builder/bitcoin-transaction-builder"
+
+import type { ExtendedUtxo, SignerInfo, Target } from "./transaction-builder/transaction-builder"
+import BitcoinSign from "./sign/sign-transaction"
+
+import bip39 from "bip39"
+import bip32 from "bip32"
+import { hdWalletPath } from "@teleportdao/configs"
+import { getPubKeyFromPrivateKeyHex } from "./bitcoin-utils"
+import networks from "./utils/networks"
+import { Network, Payment } from "bitcoinjs-lib"
+import { BitcoinInterface } from "./bitcoin-interface"
+
+class BitcoinBase {
+  network: Network
+  hdWalletPath: {
+    p2pkh: string
+    p2wpkh: string
+    "p2sh-p2wpkh": string
+    p2sh: string
+    p2wsh: string
+    "p2sh-p2wsh": string
+  }
+  transactionBuilder: TransactionBuilder
+  btcInterface: BitcoinInterface
+  signer: BitcoinSign
+  currentAccount?: string
+  currentAccountType?: string
+  privateKey?: Buffer
+  publicKey?: Buffer
+  publicKeys?: Buffer[]
+  addressObj?: Payment
+  bitcoinAddress: string | undefined
+  constructor(
+    networkName: string,
+    connectionInfo: BitcoinConnectionInfo = {
+      api: {
+        enabled: true,
+        provider: "BlockStream",
+      },
+    },
+  ) {
+    this.network = networks[networkName]
+    this.hdWalletPath = hdWalletPath.bitcoin
+
+    this.transactionBuilder = new TransactionBuilder(connectionInfo, networkName, this.network)
+    this.btcInterface = this.transactionBuilder.btcInterface
+
+    this.signer = new BitcoinSign(this.network)
+
+    this.currentAccount = undefined
+    this.currentAccountType = undefined
+
+    this.privateKey = undefined
+    this.publicKey = undefined
+    // todo multisig
+    this.publicKeys = []
+  }
+
+  static createTransactionInputsAndOutputs({
+    targets,
+    extendedUtxo,
+    changeAddress,
+    feeRate,
+  }: {
+    targets: Target[]
+    extendedUtxo: ExtendedUtxo[]
+    changeAddress: string
+    feeRate: number
+    fullAmount?: boolean
+  }) {
+    return TransactionBuilder.helperHandleInputsAndOutputs({
+      targets,
+      extendedUtxo,
+      changeObject: {
+        address: changeAddress,
+      },
+      feeRate,
+    })
+  }
+
+  static checkBalanceIsSufficient({
+    targets,
+    extendedUtxo,
+    changeAddress,
+    feeRate,
+    fullAmount = false,
+  }: {
+    targets: Target[]
+    extendedUtxo: ExtendedUtxo[]
+    changeAddress: string
+    feeRate: number
+    fullAmount?: boolean
+  }) {
+    try {
+      TransactionBuilder.helperHandleInputsAndOutputs({
+        targets,
+        extendedUtxo,
+        changeObject: {
+          address: changeAddress,
+        },
+        feeRate,
+      })
+      return true
+    } catch (err) {
+      return false
+    }
+  }
+
+  // todo : not completed
+  setMultiSigAccount(accountType = "p2sh") {
+    /* 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
+  }
+
+  setAccountPublicKey(publicKeyHex: string) {
+    this.publicKey = Buffer.from(publicKeyHex, "hex")
+  }
+
+  setAccountPrivateKeyByMnemonic({
+    mnemonic,
+    mnemonicPassword = "",
+    index = 0,
+    walletNumber = 0,
+    addressType = "p2sh-p2wpkh",
+  }: {
+    mnemonic: string
+    mnemonicPassword?: string
+    index?: number
+    walletNumber?: number
+    addressType?: string
+  }) {
+    if (!bip39.validateMnemonic(mnemonic)) throw new Error("invalid mnemonic")
+    const seed = bip39.mnemonicToSeedSync(mnemonic, mnemonicPassword)
+    const node = bip32.fromSeed(seed)
+
+    let basePath = this.hdWalletPath[addressType as keyof typeof this.hdWalletPath]
+    if (!basePath) {
+      throw new Error("incorrect path or addressType")
+    }
+    const path = `${basePath}/${walletNumber}`
+    const account = node.derivePath(path)
+    const userKeyPair = account.derive(index)
+    this.setAccountPrivateKey(userKeyPair.privateKey!.toString("hex"))
+    return this.setAccount(addressType)
+  }
+
+  setAccount(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
+  }
+
+  async getExtendedUtxo(input: SignerInfo) {
+    return this.transactionBuilder.getExtendedUtxo(input)
+  }
+
+  async send({
+    receiverAddress,
+    amount,
+    fullAmount = false,
+    speed = "normal",
+  }: {
+    receiverAddress: string
+    amount: number
+    fullAmount?: boolean
+    speed?: "normal" | "fast" | "slow"
+  }) {
+    if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+
+    let extendedUtxo = await this.getExtendedUtxo({
+      address: this.currentAccount,
+      addressType: this.currentAccountType,
+      publicKey: this.publicKey.toString("hex"),
+    })
+    if (amount - +amount.toFixed() !== 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,
+      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 txId
+  }
+
+  async sendSignedPsbt(signedPsbt: string) {
+    let signedTx = this.signer.finalizePsbts([signedPsbt])
+    let txId = await this.transactionBuilder.sendTx(signedTx)
+    return txId
+  }
+
+  async sendSignedTx(signedTx: string) {
+    let txId = await this.transactionBuilder.sendTx(signedTx)
+    return txId
+  }
+
+  async sendMultiSignedPsbt(signedPsbts: string[] = []) {
+    let signedTx = this.signer.finalizePsbts(signedPsbts)
+    let txId = await this.transactionBuilder.sendTx(signedTx)
+    return txId
+  }
+}
+
+export { BitcoinBase }

package/src/{bitcoin-interface-utils.js → bitcoin-interface-utils.ts}

@@ -1,53 +1,59 @@
-const networks = require("./utils/networks")
-const {
-  createAddressObjectByHash,
-  createAddressObjectByAddress,
-  createAddressObjectByPublicKey,
-  createAddressObjectByScript,
-} = require("./bitcoin-utils")
-
-class BitcoinInterfaceUtils {
-  constructor(networkName) {
-    this.testnet = networkName.includes("_testnet")
-    this.network = networks[networkName]
-  }
-
-  convertHashToAddress(hashHex, addressType) {
-    let addressObj = createAddressObjectByHash(
-      { addressType, hash: Buffer.from(hashHex, "hex") },
-      this.network,
-    )
-    if (!addressObj.address) throw new Error("incorrect input")
-    return addressObj.address
-  }
-
-  convertScriptToAddress(scriptHex, addressType) {
-    let addressObj = createAddressObjectByScript(
-      { addressType, script: Buffer.from(scriptHex, "hex") },
-      this.network,
-    )
-    if (!addressObj.address) throw new Error("incorrect input")
-    return addressObj.address
-  }
-
-  convertAddressToScript(address) {
-    let { addressObject, addressType } = createAddressObjectByAddress(address, this.network)
-    return {
-      script: addressObject.output,
-      hash: addressObject.hash,
-      addressType,
-    }
-  }
-
-  convertAddressToObject(address) {
-    let addObj = createAddressObjectByAddress(address, this.network)
-    return addObj
-  }
-
-  createAddressObjectByPublicKey(address, addressType) {
-    let addObj = createAddressObjectByPublicKey({ address, addressType }, this.network)
-    return addObj
-  }
-}
-
-module.exports = BitcoinInterfaceUtils
+import networks from "./utils/networks"
+import {
+  createAddressObjectByHash,
+  createAddressObjectByAddress,
+  createAddressObjectByPublicKey,
+  createAddressObjectByScript,
+} from "./bitcoin-utils"
+import type { Network } from "bitcoinjs-lib"
+
+export class BitcoinInterfaceUtils {
+  testnet: boolean
+  network: Network
+  constructor(networkName: string) {
+    this.testnet = networkName.includes("_testnet")
+    this.network = networks[networkName]
+  }
+
+  convertHashToAddress(hashHex: string, addressType: string) {
+    let addressObj = createAddressObjectByHash(
+      { addressType, hash: Buffer.from(hashHex, "hex") },
+      this.network,
+    )
+    if (!addressObj.address) throw new Error("incorrect input")
+    return addressObj.address
+  }
+
+  convertScriptToAddress(scriptHex: string, addressType: string) {
+    let addressObj = createAddressObjectByScript(
+      { addressType, script: Buffer.from(scriptHex, "hex") },
+      this.network,
+    )
+    if (!addressObj.address) throw new Error("incorrect input")
+    return addressObj.address
+  }
+
+  convertAddressToScript(address: string) {
+    let { addressObject, addressType } = createAddressObjectByAddress(address, this.network)
+    return {
+      script: addressObject.output,
+      hash: addressObject.hash,
+      addressType,
+    }
+  }
+
+  convertAddressToObject(address: string) {
+    let addObj = createAddressObjectByAddress(address, this.network)
+    return addObj
+  }
+
+  createAddressObjectByPublicKey(publicKey: string, addressType: string) {
+    let addObj = createAddressObjectByPublicKey(
+      { publicKey: Buffer.from(publicKey, "hex"), addressType },
+      this.network,
+    )
+    return addObj
+  }
+}
+
+export default BitcoinInterfaceUtils