@teleportdao/bitcoin 1.4.4 → 1.4.7

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

@@ -1,17 +1,41 @@
-import TransactionBuilder from "./transaction-builder/bitcoin-transaction-builder"
-import BitcoinSign from "./sign/sign-transaction"
+import TransactionBuilder, {
+  BitcoinConnectionInfo,
+} from "./transaction-builder/bitcoin-transaction-builder"
 
-const bip39 = require("bip39")
-const bip32 = require("bip32")
-const hdWalletNetworksPath = require("@teleportdao/configs").hdWalletPath
-const { getPubKeyFromPrivateKeyHex } = require("./bitcoin-utils")
-const networks = require("./utils/networks")
+import type { ExtendedUtxo, SignerInfo, Target } from "./transaction-builder/transaction-builder"
+import BitcoinSign from "./sign/sign-transaction"
 
-// eslint-disable-next-line import/prefer-default-export
-export class BitcoinBase {
+import * as bip39 from "bip39"
+import * as 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,
-    connectionInfo = {
+    networkName: string,
+    connectionInfo: BitcoinConnectionInfo = {
       api: {
         enabled: true,
         provider: "BlockStream",
@@ -19,18 +43,18 @@ export class BitcoinBase {
     },
   ) {
     this.network = networks[networkName]
-    this.hdWalletPath = hdWalletNetworksPath[networkName.replace("_testnet", "")]
+    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 = null
-    this.currentAccountType = null
+    this.currentAccount = undefined
+    this.currentAccountType = undefined
 
-    this.privateKey = null
-    this.publicKey = null
+    this.privateKey = undefined
+    this.publicKey = undefined
     // todo multisig
     this.publicKeys = []
   }
@@ -40,14 +64,20 @@ export class BitcoinBase {
     extendedUtxo,
     changeAddress,
     feeRate,
-    fullAmount = false,
+  }: {
+    targets: Target[]
+    extendedUtxo: ExtendedUtxo[]
+    changeAddress: string
+    feeRate: number
+    fullAmount?: boolean
   }) {
     return TransactionBuilder.helperHandleInputsAndOutputs({
       targets,
       extendedUtxo,
-      changeAddress,
+      changeObject: {
+        address: changeAddress,
+      },
       feeRate,
-      fullAmount,
     })
   }
 
@@ -57,14 +87,21 @@ export class BitcoinBase {
     changeAddress,
     feeRate,
     fullAmount = false,
+  }: {
+    targets: Target[]
+    extendedUtxo: ExtendedUtxo[]
+    changeAddress: string
+    feeRate: number
+    fullAmount?: boolean
   }) {
     try {
       TransactionBuilder.helperHandleInputsAndOutputs({
         targets,
         extendedUtxo,
-        changeAddress,
+        changeObject: {
+          address: changeAddress,
+        },
         feeRate,
-        fullAmount,
       })
       return true
     } catch (err) {
@@ -72,6 +109,7 @@ export class BitcoinBase {
     }
   }
 
+  // todo : not completed
   setMultiSigAccount(accountType = "p2sh") {
     /* eslint-disable no-unreachable */
     // todo : not completed
@@ -91,47 +129,48 @@ export class BitcoinBase {
     this.currentAccountType = accountType
   }
 
-  setAccountPrivateKey(privateKeyHex) {
+  setAccountPrivateKey(privateKeyHex: string) {
     this.privateKey = Buffer.from(privateKeyHex, "hex")
     let publicKey = getPubKeyFromPrivateKeyHex(privateKeyHex, this.network)
     this.publicKey = publicKey
   }
 
-  setAccountPublicKey(publicKeyHex) {
+  setAccountPublicKey(publicKeyHex: string) {
     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",
+  }: {
+    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)
 
-    if (!this.hdWalletPath[addressType]) throw new Error("incorrect path or addressType")
-
-    const path = `${this.hdWalletPath[addressType]}/${walletNumber}`
+    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"))
+    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,
@@ -143,36 +182,25 @@ export class BitcoinBase {
     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,
-    })
+  async getExtendedUtxo(input: SignerInfo) {
+    return this.transactionBuilder.getExtendedUtxo(input)
   }
 
-  /**
-   *
-   * @param {*} input
-   * @param {*} input.receiverAddress
-   * @param {*} input.amount
-   * @param {*} input.fullAmount
-   * @param {*} input.speed
-   * @returns
-   */
-  async send({ receiverAddress, amount, fullAmount = false, speed = "normal" }) {
+  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,
@@ -199,22 +227,22 @@ export class BitcoinBase {
     return txId
   }
 
-  async sendSignedPsbt(signedPsbt) {
+  async sendSignedPsbt(signedPsbt: string) {
     let signedTx = this.signer.finalizePsbts([signedPsbt])
     let txId = await this.transactionBuilder.sendTx(signedTx)
     return txId
   }
 
-  async sendSignedTx(signedTx) {
+  async sendSignedTx(signedTx: string) {
     let txId = await this.transactionBuilder.sendTx(signedTx)
     return txId
   }
 
-  async sendMultiSignedPsbt(signedPsbts = []) {
+  async sendMultiSignedPsbt(signedPsbts: string[] = []) {
     let signedTx = this.signer.finalizePsbts(signedPsbts)
     let txId = await this.transactionBuilder.sendTx(signedTx)
     return txId
   }
 }
 
-// export default BitcoinBase
+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