@teleportdao/bitcoin 1.4.8 → 1.5.0

package/src/bitcoin-utils.ts

@@ -1,15 +1,13 @@
-import * as bip39 from "bip39"
-import * as bip32 from "bip32"
 import networks from "./utils/networks"
 
-// import BIP32Factory from "bip32"
-// import ECPairFactory from "ecpair"
-// import * as ecc from "tiny-secp256k1"
+import * as bip39 from "bip39"
+import BIP32Factory from "bip32"
+import * as ecc from "@bitcoinerlab/secp256k1"
 import * as bitcoin from "bitcoinjs-lib"
+import * as bitcoinEcPair from "bitcoinjs-ecpair"
 
-// bitcoin.initEccLib(ecc)
-// const bip32 = BIP32Factory(ecc)
-const ECPair = bitcoin.ECPair
+const bip32 = BIP32Factory(ecc)
+const ECPair = bitcoinEcPair.ECPair
 
 let varUnit = require("varuint-bitcoin")
 const fastRoot = require("merkle-lib/fastRoot")
@@ -46,6 +44,44 @@ export function generateMnemonic() {
   return mnemonic
 }
 
+export function reverseBytes(hexInput: string) {
+  return Buffer.from(hexInput, "hex").reverse().toString("hex")
+}
+
+export function getPublicKeyHexByXpubAndIndex(
+  xpub: string,
+  index = 0,
+  isChange = false,
+  network = networks.bitcoin,
+) {
+  const node = bip32.fromBase58(xpub, network)
+  return node
+    .derive(isChange ? 1 : 0)
+    .derive(index)
+    .publicKey.toString("hex")
+}
+
+export function getPubKeyFromPrivateKeyWIF(
+  privateKeyWIF: string,
+  network = bitcoin.networks.bitcoin,
+) {
+  let key = ECPair.fromWIF(privateKeyWIF, network)
+  return key.publicKey
+}
+
+export function getPubKeyFromPrivateKeyHex(
+  privateKeyHex: string,
+  network = bitcoin.networks.bitcoin,
+) {
+  let key = ECPair.fromPrivateKey(Buffer.from(privateKeyHex, "hex"), { network })
+  return key.publicKey
+}
+
+export function getPrivateKeyHexFromWIF(privateKeyWIF: string, network = bitcoin.networks.bitcoin) {
+  let key = ECPair.fromWIF(privateKeyWIF, network)
+  return key.privateKey!.toString("hex")
+}
+
 export function parseRawTransaction(rawTransaction: string) {
   const size = {
     version: 4,
@@ -102,44 +138,6 @@ export function parseRawTransaction(rawTransaction: string) {
   return { version, flag, vin, vout, witness, locktime }
 }
 
-export function reverseBytes(hexInput: string) {
-  return Buffer.from(hexInput, "hex").reverse().toString("hex")
-}
-
-export function getPublicKeyHexByXpubAndIndex(
-  xpub: string,
-  index = 0,
-  isChange = false,
-  network = networks.bitcoin,
-) {
-  const node = bip32.fromBase58(xpub, network)
-  return node
-    .derive(isChange ? 1 : 0)
-    .derive(index)
-    .publicKey.toString("hex")
-}
-
-export function getPubKeyFromPrivateKeyWIF(
-  privateKeyWIF: string,
-  network = bitcoin.networks.bitcoin,
-) {
-  let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network)
-  return key.publicKey
-}
-
-export function getPubKeyFromPrivateKeyHex(
-  privateKeyHex: string,
-  network = bitcoin.networks.bitcoin,
-) {
-  let key = bitcoin.ECPair.fromPrivateKey(Buffer.from(privateKeyHex, "hex"), { network })
-  return key.publicKey
-}
-
-export function getPrivateKeyHexFromWIF(privateKeyWIF: string, network = bitcoin.networks.bitcoin) {
-  let key = bitcoin.ECPair.fromWIF(privateKeyWIF, network)
-  return key.privateKey!.toString("hex")
-}
-
 export function calculateMerkleProof(
   blockTransactions: string[],
   txId: string,
@@ -202,6 +200,7 @@ export function parseBlockHeader(headerHex: string) {
   }
 }
 
+// used in block parser functions ( newt 2 functions )
 export function convertBitcoinScriptToAddress(script: Buffer, network = bitcoin.networks.bitcoin) {
   try {
     return bitcoin.address.fromOutputScript(script, network)
@@ -414,11 +413,11 @@ function toXOnlyPublicKey(pubKey: Buffer) {
 
 export function getAddressType(address: string, network = bitcoin.networks.bitcoin) {
   if (address.startsWith(`${network.bech32}1p`)) {
-    // todo : check length - it could be p2wsh
+    // todo validate p2tr address
     return "p2tr"
   }
   if (address.startsWith(network.bech32)) {
-    // todo : check length - it could be p2wsh
+    bitcoin.address.fromBech32(address)
     return "p2wpkh"
   }
   let base58Data = bitcoin.address.fromBase58Check(address)
@@ -462,12 +461,12 @@ export function createAddressObjectByScript(
         network,
       })
       break
-    // case "p2tr":
-    //   addressObject = bitcoin.payments.p2tr({
-    //     output: script,
-    //     network,
-    //   })
-    //   break
+    case "p2tr":
+      addressObject = bitcoin.payments.p2tr({
+        output: script,
+        network,
+      })
+      break
     default:
       throw new Error("address type is incorrect")
   }
@@ -504,13 +503,13 @@ export function createAddressObjectByHash(
         network,
       })
       break
-    // case "p2tr":
-    //   // here hash is the public key of tweaked private key
-    //   addressObject = bitcoin.payments.p2tr({
-    //     pubkey: hash,
-    //     network,
-    //   })
-    // break
+    case "p2tr":
+      // here hash is the public key of tweaked private key (internal public key)
+      addressObject = bitcoin.payments.p2tr({
+        pubkey: hash,
+        network,
+      })
+      break
     default:
       throw new Error("address type is incorrect")
   }
@@ -544,12 +543,12 @@ export function createAddressObjectByPublicKey(
       })
       break
     case "p2tr":
-    // // this public key is public key of main private key
-    // addressObject = bitcoin.payments.p2tr({
-    //   internalPubkey: toXOnlyPublicKey(publicKey),
-    //   network,
-    // })
-    // break
+      // this public key is public key of main private key
+      addressObject = bitcoin.payments.p2tr({
+        internalPubkey: toXOnlyPublicKey(publicKey),
+        network,
+      })
+      break
     default:
       throw new Error("address type is incorrect")
   }
@@ -578,12 +577,12 @@ export function createAddressObjectByAddress(address: string, network = bitcoin.
         network,
       })
       break
-    // case "p2tr":
-    //   addressObject = bitcoin.payments.p2tr({
-    //     address,
-    //     network,
-    //   })
-    //   break
+    case "p2tr":
+      addressObject = bitcoin.payments.p2tr({
+        address,
+        network,
+      })
+      break
     default:
       throw new Error("address type is incorrect")
   }

package/src/helper/teleport-request-helper.js

@@ -86,9 +86,11 @@ function parseRawRequest(opReturnData) {
   let appId = Number(`0x${appIdHex}`) // 2 bytes
 
   //   get type base on appId
-  let requestType = teleportRequestsType.find(
-    (rs) => appId >= rs.appIdRange[0] && appId <= rs.appIdRange[1],
-  )?.type
+  let requestType = Object.keys(teleportRequestsType).find(
+    (key) =>
+      appId >= teleportRequestsType[key].appIdRange[0] &&
+      appId <= teleportRequestsType[key].appIdRange[1],
+  )
 
   switch (requestType) {
     case "transfer":

package/src/sign/sign-transaction.ts

@@ -1,16 +1,44 @@
-import { Psbt, crypto, Network, ECPair } from "bitcoinjs-lib"
-// import ECPairFactory from "ecpair"
-// import * as ecc from "tiny-secp256k1"
-import { ExtendedUnsignedTransaction } from "../transaction-builder/transaction-builder"
-// import * as bitcoin from "bitcoinjs-lib"
+import { Psbt, crypto, Network } from "bitcoinjs-lib"
+// import BIP32Factory from "bip32"
+import ecc from "@bitcoinerlab/secp256k1"
+import * as bitcoinEcPair from "bitcoinjs-ecpair"
+const ECPair = bitcoinEcPair.ECPair
 
-// bitcoin.initEccLib(ecc)
-// // const bip32 = BIP32Factory(ecc)
-// const ECPair = ECPairFactory(ecc)
+function tapTweakHash(pubKey: Buffer, h?: Buffer) {
+  return crypto.taggedHash("TapTweak", Buffer.concat(h ? [pubKey, h] : [pubKey]))
+}
+
+function tweakSigner(
+  privateKey: Buffer,
+  opts = {} as {
+    [key: string]: Buffer
+  },
+  network: Network,
+) {
+  let newPrv = privateKey
+  let keyPair = ECPair.fromPrivateKey(privateKey, {
+    network: network,
+    compressed: true,
+  })
+
+  if (!keyPair.privateKey) throw new Error("private key not exist")
+
+  if (keyPair.publicKey.toString("hex").startsWith("03")) {
+    newPrv = ecc.privateNegate(keyPair.privateKey) as Buffer
+  }
+
+  const tweakedPrivateKey = ecc.privateAdd(
+    newPrv,
+    tapTweakHash(Buffer.from(keyPair.publicKey.toString("hex").slice(2), "hex"), opts?.tweakHash),
+  )
+  if (!tweakedPrivateKey) {
+    throw new Error("Invalid tweaked private key!")
+  }
 
-// function tapTweakHash(pubKey: Buffer, h?: Buffer) {
-//   return crypto.taggedHash('TapTweak', Buffer.concat(h ? [pubKey, h] : [pubKey]))
-// }
+  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+    network: network,
+  })
+}
 
 class BitcoinLikeSignTransaction {
   network: Network
@@ -18,38 +46,6 @@ class BitcoinLikeSignTransaction {
     this.network = network
   }
 
-  // tweakSigner(
-  //   privateKey: Buffer,
-  //   opts = {} as {
-  //     [key: string]: Buffer
-  //   },
-  // ) {
-  //   let newPrv = privateKey
-  //   let keyPair = ECPair.fromPrivateKey(privateKey, {
-  //     network: this.network,
-  //     compressed: true,
-  //   })
-
-  //   if (!keyPair.privateKey) throw new Error("private key not exist")
-
-  //   if (keyPair.publicKey.toString("hex").startsWith("03")) {
-  //     newPrv = ecc.privateNegate(keyPair.privateKey) as Buffer
-  //   }
-
-  //   const tweakedPrivateKey = ecc.privateAdd(
-  //     newPrv,
-  //     tapTweakHash(Buffer.from(keyPair.publicKey.toString("hex").slice(2), "hex"), opts?.tweakHash),
-  //   )
-  //   if (!tweakedPrivateKey) {
-  //     throw new Error("Invalid tweaked private key!")
-  //   }
-
-  //   return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
-  //     network: this.network,
-  //   })
-  // }
-
-  // todo : change to psbt
   async signPsbt(
     unsignedPsbt: {
       unsignedTransaction: string
@@ -68,7 +64,13 @@ class BitcoinLikeSignTransaction {
     let numberOfInputs = psbt.inputCount
 
     for (let i = 0; i < numberOfInputs; i += 1) {
-      await psbt.signInputAsync(i, keyPair)
+      let type = psbt.getInputType(i)
+      if (type === "nonstandard") {
+        let a = tweakSigner(privateKey, undefined, this.network)
+        await psbt.signInputAsync(i, a)
+      } else {
+        await psbt.signInputAsync(i, keyPair)
+      }
     }
 
     // psbt.signAllInputs(keyPair)
@@ -82,13 +84,12 @@ class BitcoinLikeSignTransaction {
     )
     const psbt =
       finals.length === 1 ? finals[0] : new Psbt({ network: this.network }).combine(...finals)
+
     psbt.finalizeAllInputs()
 
-    // psbt.finalizeAllInputs()
-    // const tx = psbt.extractTransaction()
-    // const rawTx = tx.toBuffer()
-    // const hex = rawTx.toString("hex")
     let finalizeTx = psbt.extractTransaction()
+    // const rawTx = finalizeTx.toBuffer()
+    // const hex = rawTx.toString("hex")
     return finalizeTx.toHex()
   }
 }

package/src/teleport-dao-payments.ts

@@ -18,6 +18,7 @@ export type TransferRequest = {
   deadline?: number // 4 bytes
   isFixedToken?: boolean // 1 byte
   feeSpeed?: "normal" | "fast" | "slow"
+  staticFeeRate?: number
 }
 export class TeleportDaoPayment extends BitcoinBase {
   // payment
@@ -62,6 +63,7 @@ export class TeleportDaoPayment extends BitcoinBase {
     deadline, // 4 bytes
     isFixedToken = false, // 1 byte
     feeSpeed = "normal",
+    staticFeeRate,
   }: TransferRequest) {
     if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
       throw new Error("account not initialized")
@@ -89,6 +91,7 @@ export class TeleportDaoPayment extends BitcoinBase {
       deadline,
       isFixedToken,
       feeSpeed,
+      staticFeeRate,
     })
     let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
     let txId = await this.sendSignedPsbt(signedPsbt)
@@ -154,10 +157,11 @@ export class TeleportDaoPayment extends BitcoinBase {
     deadline = 0, // 4 bytes
     isFixedToken = false, // 1 byte
     feeSpeed = "normal",
+    staticFeeRate,
   }: TransferRequest & {
     extendedUtxo: ExtendedUtxo[]
   }) {
-    let feeRate = await this.transactionBuilder._getFeeRate(feeSpeed)
+    let feeRate = staticFeeRate || (await this.transactionBuilder._getFeeRate(feeSpeed))
     let targets = await this.getBitcoinToEthTargetOutputs({
       lockerAddress,
       amount,
@@ -196,6 +200,7 @@ export class TeleportDaoPayment extends BitcoinBase {
     isBorrow = false,
     tokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
     borrowAmount = 0, // 28 bytes
+    staticFeeRate,
   }: {
     lockerAddress: string
     amount: number
@@ -203,6 +208,7 @@ export class TeleportDaoPayment extends BitcoinBase {
     appId: number
     recipientAddress: string // 20 bytes
     percentageFee: number // 2 bytes in satoshi
+    staticFeeRate: number
     mode?: 0 | 1 | boolean // 1 byte
     isBorrow?: boolean
     tokenAddress?: string // 20 bytes
@@ -239,7 +245,7 @@ export class TeleportDaoPayment extends BitcoinBase {
         opTarget,
       ],
       changeAddress: this.currentAccount,
-      feeRate: 1,
+      feeRate: staticFeeRate,
       fullAmount: false,
     })
     let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)

package/src/mempool-space.ts

@@ -1,255 +0,0 @@
-import { AxiosInstance } from "axios"
-import { getAxiosInstance } from "./utils/tools"
-
-class BlockStream {
-  api: AxiosInstance
-  constructor(
-    testnet = false,
-    // not used yet
-    _config?: {
-      token?: string
-    },
-  ) {
-    const baseUrl = testnet
-      ? "https://mempool.space/testnet/api/v1"
-      : "https://mempool.space/api/v1"
-    this.api = getAxiosInstance({
-      baseUrl,
-    } as any)
-  }
-
-  async getOutspend(txId: string, index: number) {
-    let response = await this.api.get(`/tx/${txId}/outspend/${index}`)
-    return response.data
-  }
-  async getOutspends(txId: string) {
-    let response = await this.api.get(`/tx/${txId}/outspends`)
-    return response.data
-  }
-
-  async getLatestBlockNumber() {
-    const result = await this.api.get(`/blocks/tip/height`)
-    return result.data
-  }
-
-  async getBlockHash(blockNumber: number) {
-    const result = await this.api.get(`/block-height/${blockNumber}`)
-    return result.data
-  }
-
-  async getBlockHeaderHex(blockNumber: number) {
-    const hash = await this.getBlockHash(blockNumber)
-    const result = await this.api.get(`/block/${hash}/header`)
-    return result.data
-  }
-
-  // --------------
-
-  async getConfirmedTransactions(userAddress: string, lastReceivedTxId = "") {
-    const result = await this.api.get(`/address/${userAddress}/txs/chain/${lastReceivedTxId}`)
-    return result.data
-  }
-
-  async getMempoolTransactions(userAddress: string) {
-    const result = await this.api.get(`/address/${userAddress}/txs/mempool`)
-    return result.data
-  }
-
-  async getTransaction(txId: string) {
-    const result = await this.api.get(`/tx/${txId}`)
-    let tx = result.data
-    return {
-      txId: tx.txid,
-      version: tx.version,
-      locktime: tx.locktime,
-      blockTime: tx.status.block_time,
-      blockNumber: tx.status.block_height || null,
-      blockHash: tx.status.block_hash || null,
-      vout: tx.vout.map((vo: any) => ({
-        address: vo.scriptpubkey_address || null,
-        script: vo.scriptpubkey,
-        value: vo.value,
-      })),
-      vin: tx.vin.map((vi: any) => ({
-        txId: vi.txid,
-        index: vi.vout,
-        address: vi.prevout.scriptpubkey_address || null,
-        script: vi.prevout.scriptpubkey,
-        value: vi.prevout.value,
-      })),
-    }
-  }
-
-  async getRawTransaction(txId: string) {
-    const result = await this.api.get(`/tx/${txId}/hex`)
-    return result.data
-  }
-
-  async getTransactionHistory(userAddress: string, blockNumber = 0, lastSeenTxId = undefined) {
-    let maximumTxsLength = 15
-    // get transactions from lastSeenTxId to the end
-    let fetchTxs = true
-    let allResults = []
-    let lastReceivedTxId = ""
-    while (fetchTxs) {
-      let result = await this.getConfirmedTransactions(userAddress, lastReceivedTxId)
-      let lastSeenTxIdIndex = result.findIndex((tx: any) => tx.txid === lastSeenTxId)
-      result = result.filter((_value: any) => +_value.status.block_height > blockNumber)
-      result =
-        lastSeenTxIdIndex < 0
-          ? result
-          : result.filter((_value: any, index: number) => index < lastSeenTxIdIndex)
-      allResults.push(...result)
-      lastReceivedTxId = result[result.length - 1]?.txid
-      fetchTxs = result.length === maximumTxsLength && lastSeenTxIdIndex < 0 && result.length !== 0
-    }
-
-    return allResults.map((tx) => ({
-      address: userAddress,
-      txId: tx.txid,
-      version: tx.version,
-      locktime: tx.locktime,
-      blockNumber: tx.status.block_height || null,
-      blockHash: tx.status.block_hash || null,
-      blockTime: tx.status.block_time || null,
-      vout: tx.vout.map((vo: any) => ({
-        address: vo.scriptpubkey_address || null,
-        script: vo.scriptpubkey,
-        value: vo.value,
-      })),
-      vin: tx.vin.map((vi: any) => ({
-        txId: vi.txid,
-        index: vi.vout,
-        address: vi.prevout.scriptpubkey_address || null,
-        script: vi.prevout.scriptpubkey,
-        value: vi.prevout.value,
-      })),
-    }))
-  }
-
-  async getMempoolTransactionHistory(userAddress: string) {
-    let result = await this.getMempoolTransactions(userAddress)
-    return result.map((tx: any) => ({
-      address: userAddress,
-      txId: tx.txid,
-      version: tx.version,
-      locktime: tx.locktime,
-      vout: tx.vout.map((vo: any) => ({
-        address: vo.scriptpubkey_address || null,
-        script: vo.scriptpubkey,
-        value: vo.value,
-      })),
-      vin: tx.vin.map((vi: any) => ({
-        txId: vi.txid,
-        index: vi.vout,
-        address: vi.prevout.scriptpubkey_address || null,
-        script: vi.prevout.scriptpubkey,
-        value: vi.prevout.value,
-      })),
-    }))
-  }
-
-  async getMempoolTransactionHistoryForMultipleAddresses(addresses: string[], blockNumber = 0) {
-    const allPromises = []
-    for (let address of addresses) {
-      let promise = await this.getMempoolTransactionHistory(address)
-      allPromises.push(promise)
-    }
-    let result = await Promise.all(allPromises)
-    return result
-  }
-
-  async getTransactionHistoryForMultipleAddresses(userAddresses: string[], blockNumber = 0) {
-    const allPromises = []
-    for (let address of userAddresses) {
-      let promise = await this.getTransactionHistory(address, blockNumber)
-      allPromises.push(promise)
-    }
-    let result = await Promise.all(allPromises)
-    return result
-  }
-
-  async getUtxos(userAddress: string): Promise<
-    {
-      address: string
-      txId: string
-      index: number
-      value: number
-      blockNumber?: number
-    }[]
-  > {
-    const result = await this.api.get(`/address/${userAddress}/utxo`)
-    return result.data.map((tx: any) => ({
-      address: userAddress,
-      txId: tx.txid,
-      index: tx.vout,
-      value: tx.value,
-      blockNumber: tx.status?.block_height || undefined,
-    }))
-  }
-
-  async getBalance(address: string) {
-    let utxos = await this.getUtxos(address)
-    return utxos.reduce((a: any, tx: any) => a + Number(tx.value), 0)
-  }
-
-  async getBlockTransactionIds(blockHash: string) {
-    let result = await this.api.get(`/block/${blockHash}/txids`)
-    return result.data
-  }
-
-  async getFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
-    let result = await this.api.get(`/fee-estimates`)
-    let fees = {
-      slow: +result.data[10],
-      normal: +result.data[6],
-      fast: +result.data[3],
-    }
-    return fees[speed] || fees.normal
-  }
-  async getRecommendedFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
-    let result = await this.api.get(`/fees/recommended`)
-
-    let fees = {
-      slow: +result.data.economyFee,
-      normal: +result.data.halfHourFee,
-      fast: +result.data.fastestFee,
-    }
-    return fees[speed] || fees.normal
-  }
-
-  async sendRawTransaction(rawTransaction: string) {
-    const result = await this.api.post(`/tx`, rawTransaction)
-    return result.data
-  }
-
-  // not used
-
-  async getMerkleProof(txId: string) {
-    let result = (await this.api.get(`/tx/${txId}/merkle-proof`)).data
-    let intermediateNodes = result.merkle.reduce(
-      (a: any, merkle: any) => a + Buffer.from(merkle, "hex").reverse().toString("hex"),
-      "0x",
-    )
-    let transactionIndex = result.pos
-    return {
-      intermediateNodes,
-      transactionIndex,
-    }
-  }
-
-  async getLatestBlock() {
-    const result = await this.api.get(`/blocks`)
-    // 10 newest blocks
-    const blocks = result.data
-    return blocks[0]
-  }
-
-  async getBlock(blockNumber: number) {
-    const blockHash = await this.getBlockHash(blockNumber)
-    const result = await this.api.get(`/block/${blockHash}`)
-    return result.data
-  }
-}
-
-export default BlockStream