@teleportdao/bitcoin 1.4.6 → 1.4.8

package/src/mempool-space.ts

@@ -0,0 +1,255 @@
+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

package/src/transaction-builder/transaction-builder.ts

@@ -19,7 +19,7 @@ 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,
+    "p2sh-p2wpkh": TX_INPUT_BASE + TX_INPUT_P2SH_P2PKH,
   },
   baseTxBytes: TX_EMPTY_SIZE,
   bytePerOutput: TX_OUTPUT_BASE + TX_OUTPUT_P2PKH,
@@ -230,29 +230,47 @@ class BaseBitcoinLikeTransaction {
     if (!inputs || !outputs) {
       throw new Error("not enough balance")
     }
+    // console.log(inputs, outputs, feeRate)
+    const inputsSizes = inputs.map(
+      (i) =>
+        componentBytes.bytePerInput[
+          i.signerInfo.addressType as keyof typeof componentBytes.bytePerInput
+        ],
+    )
+    const outputSizes = outputs.length * componentBytes.bytePerOutput
+
+    // console.log(inputsSizes, outputSizes)
+
+    const txSize =
+      componentBytes.baseTxBytes +
+      inputsSizes.reduce((a, c) => a + c, 0) +
+      outputSizes +
+      componentBytes.bytePerOutput
+
+    const txFee = txSize * feeRate
+    let diff = fee - txFee
+    // console.log({ txSize, txFee, diff, fee })
+
     let changeIndex = outputs.findIndex((x) => !x?.address && !x.script && (x.value || 0) > 0)
     let change: ChangeTarget | undefined
-    if (changeIndex >= 0) {
+    if (changeIndex >= 0 || diff > 600) {
+      if (changeIndex >= 0) {
+        diff = diff + componentBytes.bytePerOutput * feeRate
+      }
+
+      if (diff < 0) {
+        diff = 0
+      }
+
       if (!changeObject) throw new Error("change not exist")
-      if (changeObject.derivationPath && changeObject.masterFingerprint && changeObject.publicKey) {
-        change = {
-          address: changeObject.address,
-          value: outputs[changeIndex].value,
-          bip32Derivation: [
-            {
-              path: changeObject.derivationPath,
-              pubkey: Buffer.from(changeObject.publicKey, "hex"),
-              masterFingerprint: Buffer.from(changeObject.masterFingerprint, "hex"),
-            },
-          ],
-        }
-      } else {
-        change = {
-          address: changeObject.address,
-          value: outputs[changeIndex].value,
-        }
+      change = {
+        address: changeObject.address,
+        value: changeIndex >= 0 ? outputs[changeIndex].value + diff : diff,
+      }
+      fee = fee - diff
+      if (changeIndex >= 0) {
+        outputs.splice(changeIndex, 1)
       }
-      outputs.splice(changeIndex, 1)
     }
 
     return {