@teleportdao/bitcoin 1.0.0

package/src/teleport-dao-payments.js

@@ -0,0 +1,276 @@
+const BitcoinBase = require("./bitcoin-base")
+
+class TeleportDaoPayment extends BitcoinBase {
+  // payment
+  async payBurnRequest(receivers, feeSpeed = "normal") {
+    let extendedUtxo = await this.transactionBuilder.getExtendedUtxo({
+      address: this.currentAccount,
+      addressType: this.currentAccountType,
+      publicKey: this.publicKey.toString("hex"),
+    })
+
+    let feeRate = await this.transactionBuilder._getFeeRate(feeSpeed)
+    let unsignedTx = await this.transactionBuilder.processUnsignedTransaction({
+      extendedUtxo,
+      targets: receivers,
+      changeAddress: this.currentAccount,
+      feeRate,
+      fullAmount: false,
+    })
+    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
+    let signedTx = this.signer.finalizePsbts([signedPsbt])
+
+    console.log(signedTx, signedPsbt)
+    let txId = await this.transactionBuilder.sendTx(signedTx)
+    console.log(txId)
+    return txId
+  }
+
+  // send
+  async transferBitcoinToEth({
+    lockerAddress,
+    amount,
+    //-----------
+    chainId,
+    appId,
+    recipientAddress, // 20 bytes
+    percentageFee, // 2 bytes in satoshi
+    speed = 0, // 1 byte
+    isExchange = false,
+    exchangeTokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
+    outputAmount = 0, // 28 bytes
+    deadline, // 4 bytes
+    isFixedToken = false, // 1 byte
+    feeSpeed = "normal",
+  }) {
+    let extendedUtxo = await this.getExtendedUtxo({
+      address: this.currentAccount,
+      addressType: this.currentAccountType,
+      publicKey: this.publicKey.toString("hex"),
+    })
+    let unsignedTx = await this.getBitcoinToEthUnsignedPsbt({
+      changeAddress: this.currentAccount,
+      extendedUtxo,
+      lockerAddress,
+      amount,
+      //-----------
+      chainId,
+      appId,
+      recipientAddress,
+      percentageFee,
+      speed,
+      isExchange,
+      exchangeTokenAddress,
+      outputAmount,
+      deadline,
+      isFixedToken,
+      feeSpeed,
+    })
+    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
+    let txId = await this.sendSignedPsbt(signedPsbt)
+    return txId
+  }
+
+  // get
+  async getBitcoinToEthTargetOutputs({
+    lockerAddress,
+    amount,
+    //-----------
+    chainId,
+    appId,
+    recipientAddress, // 20 bytes
+    percentageFee, // 2 bytes in satoshi
+    speed = 0, // 1 byte
+    isExchange = false,
+    exchangeTokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
+    outputAmount = 0, // 28 bytes
+    deadline, // 4 bytes
+    isFixedToken = false, // 1 byte
+  }) {
+    let dataHex = TeleportDaoPayment.getTransferOpReturnData({
+      chainId,
+      appId,
+      recipientAddress,
+      percentageFee,
+      speed,
+      isExchange,
+      exchangeTokenAddress,
+      outputAmount,
+      deadline,
+      isFixedToken,
+    })
+    let opTarget = this.transactionBuilder.getOpReturnTarget(dataHex)
+    return [
+      {
+        address: lockerAddress,
+        value: amount,
+      },
+      opTarget,
+    ]
+  }
+
+  async getBitcoinToEthUnsignedPsbt({
+    changeAddress,
+    extendedUtxo,
+    lockerAddress,
+    amount,
+    //-----------
+    chainId,
+    appId,
+    recipientAddress, // 20 bytes
+    percentageFee, // 2 bytes in satoshi
+    speed = 0, // 1 byte
+    isExchange = false,
+    exchangeTokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
+    outputAmount = 0, // 28 bytes
+    deadline, // 4 bytes
+    isFixedToken = false, // 1 byte
+    feeSpeed = "normal",
+  }) {
+    let feeRate = await this.transactionBuilder._getFeeRate(feeSpeed)
+    let targets = await this.getBitcoinToEthTargetOutputs({
+      lockerAddress,
+      amount,
+      chainId,
+      appId,
+      recipientAddress,
+      percentageFee,
+      speed,
+      isExchange,
+      exchangeTokenAddress,
+      outputAmount,
+      deadline,
+      isFixedToken,
+    })
+    let unsignedTx = await this.transactionBuilder.processUnsignedTransaction({
+      extendedUtxo,
+      targets,
+      changeAddress,
+      feeRate,
+      fullAmount: false,
+    })
+    return unsignedTx
+  }
+
+  // send
+  async bitcoinToEthLend({
+    lockerAddress,
+    amount,
+    //-----------
+    chainId,
+    appId,
+    recipientAddress, // 20 bytes
+    percentageFee, // 2 bytes in satoshi
+    mode = 0, // 1 byte
+    isBorrow = false,
+    tokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
+    borrowAmount = 0, // 28 bytes
+  }) {
+    let dataHex = TeleportDaoPayment.getLendingOpReturnData({
+      chainId,
+      appId,
+      recipientAddress,
+      percentageFee,
+      mode,
+      isBorrow,
+      tokenAddress,
+      borrowAmount,
+    })
+    let opTarget = this.transactionBuilder.getOpReturnTarget(dataHex)
+
+    let extendedUtxo = await this.transactionBuilder.getExtendedUtxo({
+      address: this.currentAccount,
+      addressType: this.currentAccountType,
+      publicKey: this.publicKey.toString("hex"),
+    })
+    let unsignedTx = await this.transactionBuilder.processUnsignedTransaction({
+      extendedUtxo,
+      targets: [
+        {
+          address: lockerAddress,
+          value: amount,
+        },
+        opTarget,
+      ],
+      changeAddress: this.currentAccount,
+      feeRate: 1,
+      fullAmount: false,
+    })
+    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
+    let signedTx = this.signer.finalizePsbts([signedPsbt])
+    console.log(signedTx)
+    let txId = await this.transactionBuilder.sendTx(signedTx)
+    return txId
+  }
+
+  static getTransferOpReturnData({
+    chainId,
+    appId,
+    recipientAddress, // 20 bytes
+    percentageFee, // 2 bytes in satoshi
+    speed = 0, // 1 byte
+    isExchange = false,
+    exchangeTokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
+    outputAmount = 0, // 28 bytes
+    deadline, // 4 bytes
+    isFixedToken = false, // 1 byte
+  }) {
+    let chainIdHex = Number(chainId).toString(16).padStart(2, "0")
+    let appIdHex = Number(appId).toString(16).padStart(4, "0")
+    let recipientAddressHex = recipientAddress.replace("0x", "").toLowerCase().padStart(40, "0")
+    let percentageFeeHex = Number((percentageFee * 100).toFixed(0))
+      .toString(16)
+      .padStart(4, "0")
+    let speedHex = speed ? "01" : "00"
+    let dataHex = chainIdHex + appIdHex + recipientAddressHex + percentageFeeHex + speedHex
+    if (!isExchange) {
+      if (dataHex.length !== 26 * 2) throw new Error("invalid data length")
+      return dataHex
+    }
+
+    let exchangeTokenAddressHex = exchangeTokenAddress
+      .replace("0x", "")
+      .toLowerCase()
+      .padStart(40, "0")
+    let outputAmountHex = Number(outputAmount).toString(16).padStart(56, "0")
+    let deadlineHex = Number(deadline).toString(16).padStart(8, "0")
+    let isFixedTokenHex = isFixedToken ? "01" : "00"
+
+    dataHex = dataHex + exchangeTokenAddressHex + outputAmountHex + deadlineHex + isFixedTokenHex
+    if (dataHex.length !== 79 * 2) throw new Error("invalid data length")
+    return dataHex
+  }
+
+  static getLendingOpReturnData({
+    chainId, // 1 byte
+    appId, // 1 byte
+    recipientAddress, // 20 byte
+    percentageFee, // 2 byte
+    mode, // 1 byte
+    // ------
+    isBorrow = false,
+    tokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
+    borrowAmount = 0, // 28 bytes
+  }) {
+    let chainIdHex = Number(chainId).toString(16).padStart(2, "0")
+    let appIdHex = Number(appId).toString(16).padStart(4, "0")
+    let recipientAddressHex = recipientAddress.replace("0x", "").toLowerCase().padStart(40, "0")
+    let percentageFeeHex = Number((percentageFee * 100).toFixed(0))
+      .toString(16)
+      .padStart(4, "0")
+    let modeHex = Number(mode).toString(16).padStart(2, "0")
+    let dataHex = chainIdHex + appIdHex + recipientAddressHex + percentageFeeHex + modeHex
+    if (!isBorrow) {
+      if (dataHex.length !== 26 * 2) throw new Error("invalid data length")
+      return dataHex
+    }
+
+    let tokenAddressHex = tokenAddress.replace("0x", "").toLowerCase().padStart(40, "0")
+    let borrowAmountHex = Number(borrowAmount).toString(16).padStart(56, "0")
+    dataHex = dataHex + tokenAddressHex + borrowAmountHex
+    if (dataHex.length !== 74 * 2) throw new Error("invalid data length")
+    return dataHex
+  }
+}
+
+module.exports = TeleportDaoPayment

package/src/transaction-builder/bitcoin-transaction-builder.js

@@ -0,0 +1,37 @@
+const BaseTransactionBuilder = require("./transaction-builder")
+const BitcoinInterface = require("../bitcoin-interface")
+
+class BitcoinTransactionBuilder extends BaseTransactionBuilder {
+  constructor(connectionInfo, networkName, network) {
+    super({
+      network,
+      testnet: networkName?.includes("_testnet"),
+      dustLimit: 1000,
+    })
+    this.btcInterface = new BitcoinInterface(connectionInfo, networkName)
+  }
+
+  async _getUtxo(userAddress) {
+    let utxos = await this.btcInterface.getAddressesUtxo([userAddress])
+    return utxos.map((tx) => ({
+      hash: tx.txId,
+      value: tx.value,
+      index: tx.index,
+    }))
+  }
+
+  async _getFeeRate(speed) {
+    return this.btcInterface.getFeeRate(speed)
+  }
+
+  async _getTransactionHex(transactionId) {
+    return this.btcInterface.provider.getRawTransaction(transactionId)
+  }
+
+  async sendTx(txHex) {
+    let txId = await this.btcInterface.provider.sendRawTransaction(txHex)
+    return txId
+  }
+}
+
+module.exports = BitcoinTransactionBuilder

package/src/transaction-builder/transaction-builder-common.js

@@ -0,0 +1,228 @@
+/* eslint-disable no-underscore-dangle */
+
+const bitcoin = require("bitcoinjs-lib")
+const coinselect = require("coinselect")
+const coinselectSplit = require("coinselect/split")
+const { createAddressObjectByPublicKey } = require("../bitcoin-utils")
+
+const TX_EMPTY_SIZE = 4 + 1 + 1 + 4
+const TX_INPUT_BASE = 32 + 4 + 1 + 4
+const TX_INPUT_P2PKH = 107
+const TX_INPUT_P2SH_P2PKH = 50
+const TX_INPUT_P2WPKH = 47
+const TX_OUTPUT_BASE = 8 + 1
+const TX_OUTPUT_P2PKH = 25
+
+const componentBytes = {
+  bytePerInput: {
+    p2pkh: TX_INPUT_BASE + TX_INPUT_P2PKH,
+    p2wpkh: TX_INPUT_BASE + TX_INPUT_P2WPKH,
+    p2shp2wpkh: TX_INPUT_BASE + TX_INPUT_P2SH_P2PKH,
+  },
+  baseTxBytes: TX_EMPTY_SIZE,
+  bytePerOutput: TX_OUTPUT_BASE + TX_OUTPUT_P2PKH,
+}
+
+class BaseBitcoinLikeTransaction {
+  // abstract
+  constructor({
+    network,
+    testnet,
+    feeMin = 0,
+    dustLimit,
+    maximumNumberOfOutputsInTransaction = 50,
+  }) {
+    this.testnet = testnet
+    this.network = network
+    this.maximumNumberOfOutputsInTransaction = maximumNumberOfOutputsInTransaction
+    this.feeMin = feeMin
+    this.dustLimit = dustLimit || 1 * 2 * componentBytes.bytePerInput.p2pkh
+  }
+
+  // eslint-disable-next-line no-unused-vars, class-methods-use-this
+  createAddressObject({ addressType, publicKey }) {
+    return createAddressObjectByPublicKey({ addressType, publicKey }, this.network)
+  }
+
+  validateAddress(address) {
+    try {
+      let isValid = false
+      let network = this.network
+      let isAddressSegwit = address.startsWith(network.bech32)
+      if (isAddressSegwit) {
+        bitcoin.address.fromBech32(address)
+        isValid = true
+      } else {
+        let base58Data = bitcoin.address.fromBase58Check(address)
+        isValid =
+          base58Data.version === Number(network.scriptHash) ||
+          base58Data.version === Number(network.pubKeyHash)
+      }
+      return isValid
+    } catch (error) {
+      return false
+    }
+  }
+
+  // eslint-disable-next-line no-unused-vars, class-methods-use-this
+  async _getUtxo(userAddress) {
+    // The child has implemented this method.
+    throw new Error("Do not call abstract method directly")
+    // return utxo
+  }
+
+  // eslint-disable-next-line no-unused-vars, class-methods-use-this
+  async _getTransactionHex(transactionId) {
+    // The child has implemented this method.
+    throw new Error("Do not call abstract method directly")
+    // return utxo
+  }
+
+  // eslint-disable-next-line no-unused-vars, class-methods-use-this
+  async convertBaseInputsToInputs(baseInputs) {
+    // The child has implemented this method.
+    throw new Error("Do not call abstract method directly")
+    // return utxo
+  }
+
+  // eslint-disable-next-line no-unused-vars, class-methods-use-this
+  async createUnsignedTransaction(baseInputs) {
+    // The child has implemented this method.
+    throw new Error("Do not call abstract method directly")
+    // return utxo
+  }
+
+  static helperHandleInputsAndOutputs({
+    targets,
+    extendedUtxo,
+    feeRate,
+    changeAddress,
+    fullAmount,
+  }) {
+    let { inputs, outputs, fee } = fullAmount
+      ? coinselectSplit(extendedUtxo, [{ address: targets[0].address }], Math.round(feeRate))
+      : coinselect(extendedUtxo, targets, Math.round(feeRate))
+
+    if (!inputs || !outputs) {
+      throw new Error("not enough balance")
+    }
+    let changeIndex = outputs.findIndex((x) => !x.address && !x.script && x.value > 0)
+    let change
+    if (changeIndex >= 0) {
+      change = {
+        address: changeAddress,
+        value: outputs[changeIndex].value,
+      }
+      outputs.splice(changeIndex, 1)
+    }
+
+    return {
+      inputs,
+      fee,
+      outputs,
+      change,
+    }
+  }
+
+  /**
+   *
+   * @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.privateKeyId
+   * @param {String?} signerInfo.derivationPath
+   * @returns
+   */
+  async getExtendedUtxo(signerInfo) {
+    let utxo = await this._getUtxo(signerInfo.address)
+    const extendedUtxo = utxo.map((input) => ({
+      ...input,
+      signerInfo,
+    }))
+    if (!extendedUtxo || extendedUtxo.length === 0) {
+      throw new Error("no utxo found")
+    }
+    return extendedUtxo
+  }
+
+  /**
+   *
+   * @param {Object[]} extendedUtxo
+   * @param {String} extendedUtxo[].hash
+   * @param {Number} extendedUtxo[].index
+   * @param {Number} extendedUtxo[].value
+   * @param {Object} extendedUtxo[].signerInfo
+   * @param {Object} extendedUtxo[].signerInfo.address
+   * @param {Object} extendedUtxo[].signerInfo.publicKey
+   * @param {String} extendedUtxo[].signerInfo.addressType
+   * @param {Number} extendedUtxo[].signerInfo.privateKeyId
+   */
+  async convertUtxoToInput({ extendedUtxo, targets, changeAddress, fullAmount = false, feeRate }) {
+    let {
+      inputs: filteredInputs,
+      outputs,
+      change,
+      fee,
+    } = BaseBitcoinLikeTransaction.helperHandleInputsAndOutputs({
+      targets,
+      extendedUtxo,
+      fullAmount,
+      feeRate,
+      changeAddress,
+    })
+
+    let inputs = await this.convertBaseInputsToInputs(filteredInputs)
+
+    return {
+      inputs,
+      outputs,
+      change,
+      fee,
+      feeRate,
+    }
+  }
+
+  async processUnsignedTransaction({
+    extendedUtxo,
+    targets = [],
+    changeAddress = undefined,
+    fullAmount = false,
+    feeRate,
+    selfTransaction = false,
+  }) {
+    if (!selfTransaction && targets.length === 0) throw new Error("no target")
+
+    const { inputs, outputs, change, fee } = await this.convertUtxoToInput({
+      extendedUtxo,
+      targets,
+      changeAddress,
+      fullAmount,
+      feeRate,
+    })
+    let unsignedTransaction = await this.createUnsignedTransaction({
+      inputs,
+      outputs,
+      change,
+      fee,
+      feeRate,
+    })
+
+    return unsignedTransaction
+  }
+
+  getOpReturnTarget(dataHex) {
+    if (!dataHex.length > 0) throw new Error("invalid data in hex")
+    const embed = bitcoin.payments.embed({
+      data: [Buffer.from(dataHex, "hex")],
+      network: this.network,
+    })
+    return {
+      script: embed.output,
+      value: 0,
+    }
+  }
+}
+
+module.exports = BaseBitcoinLikeTransaction

package/src/transaction-builder/transaction-builder.js

@@ -0,0 +1,135 @@
+const bitcoin = require("bitcoinjs-lib")
+const BaseBitcoinLikeTransactionBuilderCommon = require("./transaction-builder-common")
+
+class BaseBitcoinLikeTransaction extends BaseBitcoinLikeTransactionBuilderCommon {
+  async convertBaseInputsToInputs(baseInputs = []) {
+    let inputs = baseInputs
+    let transactionId = null
+    let transactionHex = null
+    for (let i in inputs) {
+      let { address, publicKey, addressType } = inputs[i].signerInfo
+      let addressObject = this.createAddressObject({
+        address,
+        publicKey: publicKey ? Buffer.from(publicKey, "hex") : null,
+        addressType,
+      })
+      if (addressType === "p2pkh") {
+        // add p2pkh data
+        if (transactionId === inputs[i].hash) {
+          inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+        } else {
+          transactionHex = await this._getTransactionHex(inputs[i].hash)
+          inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+          transactionId = inputs[i].hash
+        }
+      } else if (addressType === "p2wpkh") {
+        // add p2wpkh data
+        inputs[i].witnessUtxo = {
+          script: addressObject.output,
+          value: inputs[i].value,
+        }
+      } else if (addressType === "p2sh-p2wpkh") {
+        // add p2sh-p2wpkh data
+        inputs[i].witnessUtxo = {
+          script: addressObject.output,
+          value: inputs[i].value,
+        }
+        inputs[i].redeemScript = addressObject.redeem.output
+      }
+    }
+
+    return inputs
+  }
+
+  createUnsignedTransaction({
+    inputs,
+    outputs,
+    change,
+    fee, // not used  in this section - just returned
+    feeRate,
+  }) {
+    const { network } = this
+    const newPsbt = new bitcoin.Psbt({ network })
+    newPsbt.setMaximumFeeRate = feeRate + feeRate / 100
+    // add input
+    for (const input of inputs) {
+      let { addressType } = input.signerInfo
+      switch (addressType) {
+        case "p2pkh":
+          newPsbt.addInput({
+            hash: input.hash,
+            index: Number(input.index),
+            nonWitnessUtxo: input.nonWitnessUtxo,
+            sequence: 0xffffffff - 1,
+          })
+          break
+        case "p2wpkh":
+          newPsbt.addInput({
+            hash: input.hash,
+            index: Number(input.index),
+            witnessUtxo: input.witnessUtxo,
+            sequence: 0xffffffff - 1,
+          })
+          break
+        case "p2sh-p2wpkh":
+          newPsbt.addInput({
+            hash: input.hash,
+            index: Number(input.index),
+            witnessUtxo: input.witnessUtxo,
+            redeemScript: input.redeemScript,
+            sequence: 0xffffffff - 1,
+          })
+          break
+        default:
+          throw new Error("address type is incorrect")
+      }
+    }
+
+    // add outputs
+    for (const target of outputs) {
+      newPsbt.addOutput(target)
+    }
+
+    // add changeAddress
+    if (change && Object.keys(change).length !== 0) {
+      newPsbt.addOutput({
+        address: change.address,
+        value: Number(change.value),
+      })
+    }
+
+    // check created outputs with targets
+    for (let i in outputs) {
+      if (newPsbt.txOutputs[i].address !== outputs[i].address) {
+        throw new Error("error address")
+      }
+      if (newPsbt.txOutputs[i].value !== outputs[i].value) {
+        throw new Error("error value")
+      }
+    }
+    if (change && Object.keys(change).length !== 0) {
+      if (newPsbt.txOutputs[outputs.length].address !== change.address) {
+        throw new Error("error change address")
+      }
+      if (newPsbt.txOutputs[outputs.length].value !== change.value) {
+        throw new Error("error change value")
+      }
+    }
+
+    const unsignedPsbtBaseText = newPsbt.toBase64()
+    return {
+      unsignedTransaction: unsignedPsbtBaseText,
+      outputs,
+      inputs: inputs.map((tx) => ({
+        hash: tx.hash,
+        value: Number(tx.value),
+        index: tx.index,
+        signerInfo: tx.signerInfo,
+      })),
+      fee,
+      change,
+    }
+  }
+}
+
+module.exports = BaseBitcoinLikeTransaction

package/src/utils/networks.js

@@ -0,0 +1,31 @@
+const bitcoinLib = require("bitcoinjs-lib")
+
+const networks = {
+  bitcoin: bitcoinLib.networks.bitcoin,
+  bitcoin_testnet: bitcoinLib.networks.testnet,
+
+  litecoin: {
+    messagePrefix: "\x19Litecoin Signed Message:\n",
+    bech32: "ltc",
+    bip32: {
+      public: 0x0488b21e,
+      private: 0x0488ade4,
+    },
+    pubKeyHash: 0x30,
+    scriptHash: 0x32,
+    wif: 0xb0,
+  },
+  litecoin_testnet: {
+    messagePrefix: "\x18Litecoin Signed Message:\n",
+    bech32: "tltc",
+    bip32: {
+      public: 0x043587cf,
+      private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0x3a, // old 0xc4 -> 2  deprecated
+    wif: 0xef,
+  },
+}
+
+module.exports = networks