@teleportdao/bitcoin 1.0.0

package/src/bitcoin-base.js

@@ -0,0 +1,174 @@
+const bip39 = require("bip39")
+const bip32 = require("bip32")
+const hdWalletNetworksPath = require("@teleportdao/configs").hdWalletPath
+
+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 = []
+  }
+
+  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")
+  }
+
+  setAccountPublicKey(publicKeyHex) {
+    this.publicKey = Buffer.from(publicKeyHex, "hex")
+  }
+
+  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"))
+    this.setAccountPublicKey(userKeyPair.publicKey.toString("hex"))
+  }
+
+  setAccount(accountType = "p2pkh") {
+    let addressObj = this.transactionBuilder.createAddressObject({
+      addressType: accountType,
+      publicKey: this.publicKey,
+    })
+    this.currentAccount = addressObj.address
+    this.currentAccountType = accountType
+    this.addressObj = addressObj
+    return addressObj.address
+  }
+
+  /**
+   *
+   * @param {Object} signerInfo
+   * @param {String} signerInfo.address
+   * @param {String} signerInfo.addressType
+   * @param {String?} signerInfo.publicKey
+   * *@param {Array?} signerInfo.publicKeys // todo not used yet- used in multi sig
+   * @param {String?} signerInfo.derivationPath
+   * @param {String?} signerInfo.privateKeyId
+   * @returns
+   */
+  async getExtendedUtxo({ address, addressType, publicKey, derivationPath }) {
+    return this.transactionBuilder.getExtendedUtxo({
+      address,
+      addressType,
+      publicKey,
+      derivationPath,
+    })
+  }
+
+  static checkBalanceIsSufficient({
+    targets,
+    extendedUtxo,
+    changeAddress,
+    feeRate,
+    fullAmount = false,
+  }) {
+    try {
+      TransactionBuilder.helperHandleInputsAndOutputs({
+        targets,
+        extendedUtxo,
+        changeAddress,
+        feeRate,
+        fullAmount,
+      })
+      return true
+    } catch (err) {
+      return false
+    }
+  }
+
+  async send({ receiverAddress, amount, fullAmount = false, speed = "normal" }) {
+    let extendedUtxo = await this.getExtendedUtxo({
+      address: this.currentAccount,
+      addressType: this.currentAccountType,
+      publicKey: this.publicKey.toString("hex"),
+    })
+    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 sendMultiSignedPsbt(signedPsbts = []) {
+    let signedTx = this.signer.finalizePsbts(signedPsbts)
+    let txId = await this.transactionBuilder.sendTx(signedTx)
+    return txId
+  }
+}
+
+module.exports = BitcoinBase

package/src/bitcoin-interface-utils.js

@@ -0,0 +1,42 @@
+const networks = require("./utils/networks")
+const {
+  createAddressObjectByHash,
+  createAddressObjectByAddress,
+  createAddressObjectByPublicKey,
+} = 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,
+    )
+    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

package/src/bitcoin-interface.js

@@ -0,0 +1,267 @@
+const { getRpcProvider, getApiProvider } = require("@teleportdao/providers").bitcoin
+const { runWithRetries, sleep } = require("./utils/tools")
+const {
+  parseRawTransaction,
+  calculateMerkleProof,
+  parseBlockHeader,
+  extractTransactionsAndBlockInfoFromRawBlock,
+} = require("./bitcoin-utils")
+const { checkAndParseProtocolRequest } = require("./helper/teleport-request-helper")
+const { getBurnTransactionInfo } = require("./helper/burn-request-helper")
+const BitcoinInterfaceUtils = require("./bitcoin-interface-utils")
+
+class BitcoinInterface extends BitcoinInterfaceUtils {
+  constructor(connectionInfo, networkName, config = { minTeleporterFeeAmount: 0 }) {
+    super(networkName)
+    if (connectionInfo.rpc?.enabled) {
+      this.rpcProvider = getRpcProvider(connectionInfo.rpc)
+    } else if (connectionInfo.api.provider !== "BlockStream") {
+      throw new Error("if rpc is disabled, we just support BlockStream as api provider")
+    }
+
+    if (connectionInfo.api.enabled) {
+      this.apiProviderName = connectionInfo.api.provider
+      this.apiProvider = getApiProvider(connectionInfo.api, networkName)
+    }
+
+    this.minTeleporterFeeAmount = config.minTeleporterFeeAmount
+    this.provider = this.rpcProvider || this.apiProvider
+  }
+
+  // rpc + api
+
+  // general
+  async getLatestBlockNumber() {
+    let latestHeight = await this.provider.getLatestBlockNumber()
+    return latestHeight
+  }
+
+  async getBlockHash(blockNumber) {
+    let headerHash = await runWithRetries(() => this.provider.getBlockHash(blockNumber))
+    return headerHash
+  }
+
+  async getBlockHeaderHex(blockNumber) {
+    let headerHex = await runWithRetries(() => this.provider.getBlockHeaderHex(blockNumber))
+    return headerHex
+  }
+
+  async getTransaction(txId) {
+    return this.provider.getTransaction(txId)
+  }
+
+  // speed : low normal fast
+  async getFeeRate(speed = "normal") {
+    if (!(speed === "normal" || speed === "slow" || speed === "fast")) {
+      throw new Error("incorrect speed")
+    }
+    let fee = await this.provider.getFeeRate(speed)
+    return fee
+  }
+
+  // ----------- specific
+
+  // relayer
+  async getHexBlockHeaders(startBlockNumber, endBlockNumber) {
+    const blockHeaders = []
+    let difficulty = null
+    let hexBlockHeaders = ""
+
+    let fromBlockNumber = startBlockNumber
+    for (let blockNumber = startBlockNumber; blockNumber <= endBlockNumber; blockNumber += 1) {
+      let blockHeader = await this.getBlockHeaderHex(blockNumber)
+      console.log("block", blockNumber)
+      let parsedBlockHeader = parseBlockHeader(blockHeader)
+      if (difficulty && parsedBlockHeader.difficulty !== difficulty) {
+        blockHeaders.push({
+          hexBlockHeaders,
+          fromBlockNumber,
+          toBlockNumber: blockNumber - 1,
+          difficulty,
+        })
+        hexBlockHeaders = blockHeader
+        fromBlockNumber = blockNumber
+      } else {
+        hexBlockHeaders += blockHeader
+      }
+      difficulty = parsedBlockHeader.difficulty
+    }
+    if (hexBlockHeaders) {
+      blockHeaders.push({
+        hexBlockHeaders,
+        fromBlockNumber,
+        toBlockNumber: endBlockNumber,
+        difficulty,
+      })
+    }
+
+    return blockHeaders
+  }
+
+  async getRequestProof(transaction) {
+    let transactionHex =
+      transaction.hex || (await this.provider.getRawTransaction(transaction.txId))
+
+    let txInfo
+    if (!(transaction.blockHash && transaction.blockNumber)) {
+      txInfo = await this.provider.getTransaction(transaction.txId)
+    }
+    let blockHash = transaction.blockHash || txInfo.blockHash
+    let blockNumber = transaction.blockNumber || txInfo.blockNumber
+    let parsedTx = parseRawTransaction(transactionHex)
+    let merkleProof =
+      transaction.merkleProof || (await this.getMerkleProof(transaction.txId, blockHash))
+
+    return {
+      parsedTx,
+      merkleProof,
+      blockNumber,
+      blockHash,
+    }
+  }
+
+  async getMerkleProof(txId, blockHash) {
+    let txIds = await this.provider.getBlockTransactionIds(blockHash)
+    // let a = await this.provider.getMerkleProof(txId)
+    let proof = calculateMerkleProof(txIds, txId)
+    // console.log(a.intermediateNodes === proof.intermediateNodes)
+    return proof
+  }
+
+  // ------------------ utxo providers --------------------------------
+
+  // teleporter + locker
+  async getAddressesUtxo(addresses) {
+    if (!this.apiProvider) {
+      throw new Error("this function need an api provider")
+    }
+    const allPromises = []
+    for (let address of addresses) {
+      let promise = await this.apiProvider.getUtxos(address)
+      allPromises.push(promise)
+    }
+    let result = await Promise.all(allPromises)
+    return result.flat(1)
+  }
+
+  async getBalance(address) {
+    if (!this.apiProvider) {
+      throw new Error("this function need an api provider")
+    }
+    let utxos = (await this.apiProvider.getUtxos(address)) ?? []
+    return utxos.reduce((a, tx) => a + Number(tx.value), 0)
+  }
+
+  // ------------------ utxo provider + rpc or blockstream----------------
+  // teleporter
+  async getBlockTransactions(addresses, blockNumber) {
+    let utxos = await this.getAddressesUtxo(addresses)
+    let rawBlockHex = await this.rpcProvider.getBlockByBlockNumber(blockNumber, 0)
+    let { withdrawTxs, depositTxs } = extractTransactionsAndBlockInfoFromRawBlock(
+      rawBlockHex,
+      blockNumber,
+      addresses,
+      utxos,
+      this.network,
+    )
+    // todo : check
+    return depositTxs.concat(withdrawTxs)
+  }
+
+  // teleporter
+  async getMultipleBlocksTransactions(addresses, startBlockNumber, endBlockNumber) {
+    if (endBlockNumber - startBlockNumber > 20) {
+      throw new Error("cant get more than 20 block per function call")
+    }
+    let blockTxs = []
+    for (let blockNumber = +startBlockNumber + 1; blockNumber <= endBlockNumber; blockNumber += 1) {
+      console.log("get block transactions. blockNumber: ", blockNumber)
+      const response = this.getBlockTransactions(addresses, blockNumber)
+      blockTxs.push(response)
+      await sleep(200)
+    }
+    blockTxs = await Promise.all(blockTxs)
+    return blockTxs.flat(1)
+  }
+
+  // teleporter
+  async getTransactionHistory(addresses, startBlockNumber, endBlockNumber) {
+    if (this.rpcProvider) {
+      let endBlock = endBlockNumber || (await this.getLatestBlockNumber())
+      let startBlock = Math.max(+startBlockNumber, +endBlock - 20)
+      return this.getMultipleBlocksTransactions(addresses, startBlock, endBlock)
+    }
+    if (this.apiProviderName !== "BlockStream") {
+      throw new Error("just support BlockStream as api provider for this function")
+    }
+    let txs = await this.apiProvider.getTransactionHistoryForMultipleAddresses(
+      addresses,
+      startBlockNumber,
+    )
+    return txs.flat(1)
+  }
+
+  // ------------------just blockstream----------------------
+  async getMempoolTransactionHistory(addresses) {
+    if (this.apiProviderName !== "BlockStream") {
+      throw new Error("teleporter just support BlockStream as api provider")
+    }
+    let txs = await this.apiProvider.getMempoolTransactionHistoryForMultipleAddresses(addresses)
+    return txs.flat(1)
+  }
+
+  //
+
+  async getTeleporterRequests(addresses, startblockNumber, endBlockNumber, mempool = false) {
+    // transaction in StartBlock is not returned --> (startblockNumber,endBlockNumber]
+    let transactions = mempool
+      ? await this.getMempoolTransactionHistory(addresses)
+      : await this.getTransactionHistory(addresses, startblockNumber, endBlockNumber)
+
+    let requests = []
+    let invalidRequests = []
+    for (let transaction of transactions) {
+      console.log(`received tx to check for teleport: ${transaction.txId}`)
+
+      let address = transaction.address
+      let request = checkAndParseProtocolRequest(transaction.vout, address, {
+        minTeleporterFeeAmount: this.minTeleporterFeeAmount,
+      })
+      let lockerLockingScript =
+        transaction.addressScript || this.convertAddressToScript(address).script.toString("hex")
+      if (request.status) {
+        requests.push({ transaction, request, lockerAddress: address, lockerLockingScript })
+      } else if (request.code !== "NO_OP_RETURN") {
+        invalidRequests.push({ transaction, request, lockerAddress: address, lockerLockingScript })
+      }
+    }
+    return { requests, invalidRequests }
+  }
+
+  async getLockersBurnTransactions(addresses, startBlockNumber, endBlockNumber, mempool = false) {
+    let transactions = mempool
+      ? await this.getMempoolTransactionHistory(addresses)
+      : await this.getTransactionHistory(addresses, startBlockNumber, endBlockNumber)
+
+    let validTxs = []
+    for (let transaction of transactions) {
+      let address = transaction.address
+      console.log(`received tx to check burn: ${transaction.txId}`)
+      // check if its a transaction to spend btc
+      let burnInfo = getBurnTransactionInfo(address, transaction.vin, transaction.vout)
+      if (burnInfo) {
+        validTxs.push({
+          transaction,
+          burnInfo,
+          lockerAddress: address,
+          lockerLockingScript:
+            transaction.addressScript ||
+            this.convertAddressToScript(address).script.toString("hex"),
+        })
+      }
+    }
+    return validTxs
+  }
+}
+
+module.exports = BitcoinInterface