@teleportdao/bitcoin 1.6.1 → 1.7.1

package/src/bitcoin-utils.ts

@@ -1,16 +1,18 @@
-import networks from "./utils/networks"
-
+/* eslint-disable @typescript-eslint/no-var-requires */
 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"
+import networks from "./utils/networks"
+import { Transaction } from "./type"
 
 const bip32 = BIP32Factory(ecc)
-const ECPair = bitcoinEcPair.ECPair
+const { ECPair } = bitcoinEcPair
 
 bitcoin.initEccLib(ecc)
-let varUnit = require("varuint-bitcoin")
+
+const varUnit = require("varuint-bitcoin")
 const fastRoot = require("merkle-lib/fastRoot")
 const merkle = require("merkle-lib")
 const merkleProof = require("merkle-lib/proof")
@@ -201,12 +203,66 @@ export function parseBlockHeader(headerHex: string) {
   }
 }
 
+export function getAddressType(address: string, network = bitcoin.networks.bitcoin) {
+  if (address.startsWith(`${network.bech32}1p`)) {
+    // todo validate p2tr address
+    return "p2tr"
+  }
+  if (address.startsWith(network.bech32)) {
+    bitcoin.address.fromBech32(address)
+    return "p2wpkh"
+  }
+  let base58Data = bitcoin.address.fromBase58Check(address)
+  if (base58Data.version === Number(network.scriptHash)) {
+    return "p2sh"
+  }
+  if (base58Data.version === Number(network.pubKeyHash)) {
+    return "p2pkh"
+  }
+
+  throw new Error("invalid address")
+}
+
+export function createAddressObjectByAddress(address: string, network = bitcoin.networks.bitcoin) {
+  let addressType = getAddressType(address, network)
+  let addressObject
+  switch (addressType) {
+    case "p2pkh":
+      addressObject = bitcoin.payments.p2pkh({
+        address,
+        network,
+      })
+      break
+    case "p2wpkh":
+      addressObject = bitcoin.payments.p2wpkh({
+        address,
+        network,
+      })
+      break
+    case "p2sh":
+      addressObject = bitcoin.payments.p2sh({
+        address,
+        network,
+      })
+      break
+    case "p2tr":
+      addressObject = bitcoin.payments.p2tr({
+        address,
+        network,
+      })
+      break
+    default:
+      throw new Error("address type is incorrect")
+  }
+  return { addressObject, addressType }
+}
+
 // used in block parser functions ( newt 2 functions )
 export function convertBitcoinScriptToAddress(script: Buffer, network = bitcoin.networks.bitcoin) {
   try {
     return bitcoin.address.fromOutputScript(script, network)
   } catch (error) {
-    return null
+    return undefined
   }
 }
 
@@ -250,7 +306,7 @@ export function extractTransactionsAndBlockInfoFromRawBlock(
   inputTxIds: {
     txId: string
     index: number
-    address?: string
+    address: string
     script?: string
     value?: number
   }[] = [],
@@ -274,32 +330,6 @@ export function extractTransactionsAndBlockInfoFromRawBlock(
 
   let blockTxIds = block.transactions!.map((tx) => tx.getId())
 
-  type Transaction = {
-    txId: string
-    version: number
-    locktime: number
-    blockNumber: number
-    blockHash: string
-    merkleProof: {
-      intermediateNodes: string
-      transactionIndex: number
-    }
-    vout: {
-      address: string | null
-      script: string
-      value: number
-    }[]
-    vin: {
-      txId: string
-      index: number
-      address?: string | null
-      script?: string | null
-      value?: number | null
-    }[]
-    address: string
-    addressScript: string
-  }
-
   let withdrawTxs: Transaction[] = []
   let depositTxs: Transaction[] = []
   block.transactions?.forEach((tx) => {
@@ -333,9 +363,9 @@ export function extractTransactionsAndBlockInfoFromRawBlock(
           return {
             txId: Buffer.from(vi.hash).reverse().toString("hex"),
             index: vi.index,
-            address: viInput?.address || null,
-            script: viInput?.script || null,
-            value: viInput?.value || null,
+            address: viInput?.address,
+            script: viInput?.script,
+            value: viInput?.value,
           }
         }),
         address: inputTxAddress,
@@ -359,7 +389,6 @@ export function extractTransactionsAndBlockInfoFromRawBlock(
     })
 
     if (isDeposit && addressIndex >= 0) {
-      // todo we can optimize this calculation (in following function, merkle tree calculate each times but we can do this once for block)
       let txMerkleProof = calculateMerkleProof(blockTxIds, txId, merkleRoot)
       depositTxs.push({
         txId: tx.getId(),
@@ -412,26 +441,6 @@ function toXOnlyPublicKey(pubKey: Buffer) {
   return pubKey.length === 32 ? pubKey : pubKey.slice(1, 33)
 }
 
-export function getAddressType(address: string, network = bitcoin.networks.bitcoin) {
-  if (address.startsWith(`${network.bech32}1p`)) {
-    // todo validate p2tr address
-    return "p2tr"
-  }
-  if (address.startsWith(network.bech32)) {
-    bitcoin.address.fromBech32(address)
-    return "p2wpkh"
-  }
-  let base58Data = bitcoin.address.fromBase58Check(address)
-  if (base58Data.version === Number(network.scriptHash)) {
-    return "p2sh"
-  }
-  if (base58Data.version === Number(network.pubKeyHash)) {
-    return "p2pkh"
-  }
-
-  throw new Error("invalid address")
-}
-
 export function createAddressObjectByScript(
   { addressType, script }: { addressType: string; script: Buffer },
   network: bitcoin.Network = bitcoin.networks.bitcoin,
@@ -556,40 +565,6 @@ export function createAddressObjectByPublicKey(
   return addressObject
 }
 
-export function createAddressObjectByAddress(address: string, network = bitcoin.networks.bitcoin) {
-  let addressType = getAddressType(address, network)
-  let addressObject
-  switch (addressType) {
-    case "p2pkh":
-      addressObject = bitcoin.payments.p2pkh({
-        address,
-        network,
-      })
-      break
-    case "p2wpkh":
-      addressObject = bitcoin.payments.p2wpkh({
-        address,
-        network,
-      })
-      break
-    case "p2sh":
-      addressObject = bitcoin.payments.p2sh({
-        address,
-        network,
-      })
-      break
-    case "p2tr":
-      addressObject = bitcoin.payments.p2tr({
-        address,
-        network,
-      })
-      break
-    default:
-      throw new Error("address type is incorrect")
-  }
-  return { addressObject, addressType }
-}
-
 export function publicKeyConvertor(publicKeyHex: string, compressed = true) {
   let pubkey = ECPair.fromPublicKey(Buffer.from(publicKeyHex, "hex"), {
     compressed,

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

@@ -1,23 +1,21 @@
-import TransactionBuilder, {
-  BitcoinConnectionInfo,
-} from "./transaction-builder/bitcoin-transaction-builder"
+import * as bip39 from "bip39"
+import { hdWalletPath } from "@teleportdao/configs"
+import { Network, Payment } from "bitcoinjs-lib"
+import BIP32Factory from "bip32"
+import ecc from "@bitcoinerlab/secp256k1"
+import { BitcoinTransactionBuilder } from "./transaction-builder"
+import type { BitcoinConnectionInfo } from "./type"
 
 import type { ExtendedUtxo, SignerInfo, Target } from "./transaction-builder/transaction-builder"
 import BitcoinSign from "./sign/sign-transaction"
 
-import * as bip39 from "bip39"
-import { hdWalletPath } from "@teleportdao/configs"
 import { getPubKeyFromPrivateKeyHex } from "./bitcoin-utils"
 import networks from "./utils/networks"
-import { Network, Payment, Psbt } from "bitcoinjs-lib"
 import { BitcoinInterface } from "./bitcoin-interface"
 
-import BIP32Factory from "bip32"
-import ecc from "@bitcoinerlab/secp256k1"
-
 const bip32 = BIP32Factory(ecc)
 
-class BitcoinBase {
+export class BitcoinBaseWallet {
   network: Network
   hdWalletPath: {
     p2pkh: string
@@ -28,7 +26,7 @@ class BitcoinBase {
     "p2sh-p2wsh": string
     p2tr: string
   }
-  transactionBuilder: TransactionBuilder
+  transactionBuilder: BitcoinTransactionBuilder
   btcInterface: BitcoinInterface
   signer: BitcoinSign
   currentAccount?: string
@@ -42,7 +40,6 @@ class BitcoinBase {
     networkName: string,
     connectionInfo: BitcoinConnectionInfo = {
       api: {
-        enabled: true,
         provider: "BlockStream",
       },
     },
@@ -50,7 +47,11 @@ class BitcoinBase {
     this.network = networks[networkName]
     this.hdWalletPath = hdWalletPath.bitcoin
 
-    this.transactionBuilder = new TransactionBuilder(connectionInfo, networkName, this.network)
+    this.transactionBuilder = new BitcoinTransactionBuilder(
+      connectionInfo,
+      networkName,
+      this.network,
+    )
     this.btcInterface = this.transactionBuilder.btcInterface
 
     this.signer = new BitcoinSign(this.network)
@@ -126,6 +127,8 @@ class BitcoinBase {
 
   // todo : not completed
   setMultiSigAccount(accountType = "p2sh") {
+    throw new Error("not supported yet")
+
     /* eslint-disable no-unreachable */
     // todo : not completed
     switch (accountType) {
@@ -150,10 +153,6 @@ class BitcoinBase {
     this.publicKey = publicKey
   }
 
-  setAccountPublicKey(publicKeyHex: string) {
-    this.publicKey = Buffer.from(publicKeyHex, "hex")
-  }
-
   setAccountPrivateKeyByMnemonic({
     mnemonic,
     mnemonicPassword = "",
@@ -182,6 +181,10 @@ class BitcoinBase {
     return this.setAccount(addressType)
   }
 
+  setAccountPublicKey(publicKeyHex: string) {
+    this.publicKey = Buffer.from(publicKeyHex, "hex")
+  }
+
   setAccount(accountType = "p2pkh") {
     if (!this.publicKey) {
       throw new Error("account not initialized")
@@ -197,6 +200,8 @@ class BitcoinBase {
     return addressObj.address
   }
 
+  //
+
   async getExtendedUtxo(input: SignerInfo) {
     return this.transactionBuilder.getExtendedUtxo(input)
   }
@@ -266,7 +271,7 @@ class BitcoinBase {
     changeAddress: string,
     staticFeeRate?: number,
   ) {
-    let transaction = await this.btcInterface.getTransaction(txId)
+    let transaction = await this.btcInterface.apiProvider.getTransaction(txId)
 
     let extendedUtxo = transaction.vin.map((vi) => ({
       signerInfo: signerInfos.find((s) => s.address === vi.address)!,
@@ -303,7 +308,7 @@ class BitcoinBase {
       targets,
       feeRate,
       changeAddress: changeIndex >= 0 ? transaction.vout[changeIndex].address : changeAddress,
+      selectType: "inOrder",
     })
   }
 }
-export { BitcoinBase }

package/src/helper/brc20-helper.ts

@@ -0,0 +1,181 @@
+import BigNumber from "bignumber.js"
+import { brc20 } from "@teleportdao/configs"
+
+export type WrapOpReturn = {
+  chainId: number
+  appId: number
+  brc20TokenId: number
+  recipientAddress: string
+  inputAmount: string
+  outputAmount?: string
+  outputToken?: string
+  thirdPartyId?: number
+}
+export type WrapOpReturnAndType = WrapOpReturn & {
+  requestType: "wrap" | "wrapAndExchange"
+}
+
+const brc20WrapRequests = brc20.requestAppId
+
+export function generateBrc2OpReturn({
+  chainId,
+  appId,
+  brc20TokenId,
+  inputAmount,
+  recipientAddress,
+  thirdPartyId = 0,
+  isExchange = false,
+  outputToken,
+  outputAmount,
+}: WrapOpReturn & {
+  isExchange?: boolean
+}) {
+  let data = ""
+  if (chainId.toString(16).length > 4) throw new Error("chainId should be less than 2 bytes")
+  data += chainId.toString(16).padStart(4, "0") // 2 bytes
+  data += appId.toString(16).padStart(2, "0") // 1 bytes
+  data += brc20TokenId.toString(16).padStart(4, "0") // 2 bytes
+  data += BigNumber(inputAmount).toString(16).padStart(26, "0") // 13 bytes
+  data += recipientAddress.replace("0x", "").toLowerCase().padStart(40, "0") // 20 bytes
+  data += BigNumber(thirdPartyId).toString(16).padStart(2, "0") // 1 bytes
+  if (isExchange) {
+    if (!outputAmount || !outputToken) {
+      throw new Error("outputAmount and outputToken are required for exchange")
+    }
+    data += outputToken.replace("0x", "").toLowerCase().padStart(40, "0") // 20 bytes
+    data += BigNumber(outputAmount).toString(16).padStart(26, "0") // 13 bytes
+  }
+  return data
+}
+
+export function parseBrc20OpReturn(data: string) {
+  let parsedData: any = {}
+  parsedData.chainId = Number(`0x${data.slice(0, 4)}`) // 2 bytes
+  parsedData.appId = Number(`0x${data.slice(4, 6)}`) // 1 bytes
+  parsedData.brc20TokenId = Number(`0x${data.slice(6, 10)}`) // 2 bytes
+  parsedData.inputAmount = new BigNumber(`0x${data.slice(10, 36)}`).toFixed(0) // 11 bytes
+  parsedData.recipientAddress = `0x${data.slice(36, 76)}` // 20 bytes
+  parsedData.thirdPartyId = `0x${data.slice(76, 78)}` // 20 bytes
+  if (data.length === 78) {
+    parsedData.requestType = "wrap"
+    return {
+      status: true,
+      data: parsedData as WrapOpReturnAndType,
+    }
+  }
+  parsedData.outputToken = `0x${data.slice(78, 118)}` // 20 bytes
+  parsedData.outputAmount = new BigNumber(`0x${data.slice(118, 144)}`).toFixed(0) // 20 bytes
+  if (data.length === 144) {
+    parsedData.requestType = "swapAndWrap"
+    return {
+      status: true,
+      data: parsedData as WrapOpReturnAndType,
+    }
+  }
+
+  return {
+    status: false,
+    message: `invalid OP_RETURN data for requestType: 'wrap or exchange'. invalid data length : ${data.length} - valid length : 144 , 78`,
+    code: "INVALID_OP_RETURN",
+  }
+}
+
+function parseBrc20RawRequest(opReturnData: string): {
+  status: boolean
+  data?: WrapOpReturnAndType
+  message?: string
+  code?: string
+} {
+  let data = opReturnData.slice(2, 4) === "4c" ? opReturnData.slice(6) : opReturnData.slice(4)
+  // eslint-disable-next-line no-unused-vars
+  let appIdHex = data.slice(4, 6) // 2 bytes
+  if (!appIdHex) {
+    return {
+      status: false,
+      message: `invalid OP_RETURN data : ${data}`,
+      code: "INVALID_APP_ID",
+    }
+  }
+
+  let appId = Number(`0x${appIdHex}`) // 2 bytes
+
+  //   get type base on appId
+  let requestType = Object.keys(brc20WrapRequests).find(
+    (key) =>
+      appId >= brc20WrapRequests[key as keyof typeof brc20WrapRequests].appIdRange[0] &&
+      appId <= brc20WrapRequests[key as keyof typeof brc20WrapRequests].appIdRange[1],
+  )
+
+  switch (requestType) {
+    case "wrap":
+    case "wrapAndExchange":
+      return parseBrc20OpReturn(data)
+    default:
+      return {
+        status: false,
+        message: `invalid appId : ${appId}`,
+        code: "INVALID_OP_RETURN",
+      }
+  }
+}
+
+export function checkAndParseBrc20Request(
+  vouts: {
+    address?: string
+    script: string
+    value: number
+  }[],
+  address: string,
+): {
+  status: boolean
+  data?: WrapOpReturnAndType
+  dataOutputIndex?: number
+  lockerFeeValue?: number
+  lockerFeeOutputIndex?: number
+  brc20OutputIndex?: number
+  brc20OutputValue?: number
+  message?: string
+  code?: string
+} {
+  let requestOutputIndex = vouts.findIndex((vout_) => vout_.script.startsWith("6a"))
+  if (requestOutputIndex >= 0) {
+    let opReturnData = vouts[requestOutputIndex]?.script
+    if (!opReturnData) {
+      return {
+        status: false,
+        message: "invalid OP_RETURN",
+        code: "INVALID_OP_RETURN",
+      }
+    }
+
+    let brc20Transfer = vouts[0]
+    if (brc20Transfer.address !== address || brc20Transfer.value < 546) {
+      return {
+        status: false,
+        message: "no brc20 transfer output",
+        code: "NO_BRC20_TRANSFER",
+      }
+    }
+
+    let dataResponse = parseBrc20RawRequest(opReturnData)
+    if (dataResponse.status) {
+      let lockerFeeOutputIndex = vouts.findIndex((vout_, i) => vout_.address === address && +i > 0)
+      let lockerFeeValue = lockerFeeOutputIndex >= 0 ? vouts[lockerFeeOutputIndex].value : 0
+      return {
+        status: true,
+        data: dataResponse.data!,
+        dataOutputIndex: requestOutputIndex,
+        lockerFeeValue,
+        lockerFeeOutputIndex,
+        brc20OutputIndex: 0,
+        brc20OutputValue: brc20Transfer.value,
+      }
+    }
+    return dataResponse
+  }
+  return {
+    status: false,
+    message: "transaction outputs should contain OP_RETURN",
+    code: "NO_OP_RETURN",
+  }
+}

package/src/helper/index.ts

@@ -0,0 +1,3 @@
+export * as brc20Helper from "./brc20-helper"
+export * as teleswapHelper from "./teleswap-helper"
+export * as ordinalHelper from "./ordinal-helper"

package/src/helper/ordinal-helper.ts

@@ -0,0 +1,118 @@
+import * as bitcoin from "bitcoinjs-lib"
+import * as ecc from "tiny-secp256k1"
+
+bitcoin.initEccLib(ecc)
+
+// eslint-disable-next-line consistent-return
+export function createAddressObjectByScriptNoType(
+  script: Buffer,
+  network: bitcoin.Network = bitcoin.networks.bitcoin,
+) {
+  let addressObject: bitcoin.payments.Payment
+
+  try {
+    addressObject = bitcoin.payments.p2pkh({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2pkh",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+
+  try {
+    addressObject = bitcoin.payments.p2wpkh({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2wpkh",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+
+  try {
+    addressObject = bitcoin.payments.p2sh({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2sh",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+
+  try {
+    addressObject = bitcoin.payments.p2wsh({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2wsh",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+
+  try {
+    addressObject = bitcoin.payments.p2tr({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2tr",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+}
+
+export function splitBuffer(buffer: Buffer, partLength: number) {
+  const parts: Buffer[] = []
+  for (let i = 0; i < buffer.length; i += partLength) {
+    const part = buffer.subarray(i, i + partLength)
+    parts.push(part)
+  }
+  return parts
+}
+
+export function getOrdinalScript(
+  file: { buffer: Buffer; type: string },
+  internalPublicKeyHex: string,
+) {
+  let bufferParts = splitBuffer(file.buffer, 520)
+  const splittedFileHex = bufferParts.map((part) => part.toString("hex")).join(" ")
+  const fileTypeHex = Buffer.from(file.type!, "utf8").toString("hex")
+  const ORDINAL_ORD_HEX = Buffer.from("ord", "utf8").toString("hex")
+  const script = `${internalPublicKeyHex} OP_CHECKSIG OP_FALSE OP_IF ${ORDINAL_ORD_HEX} 00000000000000000000 ${fileTypeHex} OP_0 ${splittedFileHex} OP_ENDIF`
+
+  // we add 00000000000000000000 so we can modify INCORRECT OPCODE
+  const leafScript = Buffer.from(
+    bitcoin.script.fromASM(script).toString("hex").replace("0a00000000000000000000", "0101"),
+    "hex",
+  )
+  return leafScript
+}
+
+export function toXOnly(pubKey: Buffer) {
+  return pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33)
+}