@teleportdao/bitcoin 1.8.9 → 1.9.0

package/src/type.ts

@@ -1,48 +1,48 @@
-export type Transaction = {
-  txId: string
-  version: number
-  locktime: number
-  blockNumber: number
-  blockHash: string
-  merkleProof?: {
-    intermediateNodes: string
-    transactionIndex: number
-  }
-  vout: {
-    address?: string
-    script: string
-    value: number
-  }[]
-  vin: {
-    txId: string
-    index: number
-    address?: string
-    script?: string
-    value?: number
-  }[]
-  address: string
-  addressScript: string
-}
-
-export type BitcoinConnectionInfo = {
-  api: {
-    token?: string
-    // provider: "BlockStream" | "MempoolSpace"
-    provider: any
-  }
-  rpc?: {
-    enabled?: boolean
-    url: string
-    headers?: {
-      [key: string]: string
-    }
-    auth?: {
-      username: string
-      password: string
-    }
-  }
-  utxo?: {
-    token?: string
-    provider: "BlockStream" | "NowNodes" | "MempoolSpace" | "Unisat"
-  }
-}
+export type Transaction = {
+  txId: string
+  version: number
+  locktime: number
+  blockNumber: number
+  blockHash: string
+  merkleProof?: {
+    intermediateNodes: string
+    transactionIndex: number
+  }
+  vout: {
+    address?: string
+    script: string
+    value: number
+  }[]
+  vin: {
+    txId: string
+    index: number
+    address?: string
+    script?: string
+    value?: number
+  }[]
+  address: string
+  addressScript: string
+}
+
+export type BitcoinConnectionInfo = {
+  api: {
+    token?: string
+    // provider: "BlockStream" | "MempoolSpace"
+    provider: any
+  }
+  rpc?: {
+    enabled?: boolean
+    url: string
+    headers?: {
+      [key: string]: string
+    }
+    auth?: {
+      username: string
+      password: string
+    }
+  }
+  utxo?: {
+    token?: string
+    provider: "BlockStream" | "NowNodes" | "MempoolSpace" | "Unisat"
+  }
+}

package/src/utils/networks.ts

@@ -1,33 +1,33 @@
-import * as bitcoinLib from "bitcoinjs-lib"
-
-const networks: {
-  [key: string]: bitcoinLib.Network
-} = {
-  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,
-  },
-}
-
-export default networks
+import * as bitcoinLib from "bitcoinjs-lib"
+
+const networks: {
+  [key: string]: bitcoinLib.Network
+} = {
+  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,
+  },
+}
+
+export default networks

package/src/utils/tools.ts

@@ -1,92 +1,92 @@
-import axios from "axios"
-
-function sleep(ms: number) {
-  // eslint-disable-next-line no-promise-executor-return
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-async function runWithRetries<T>(
-  action: () => Promise<T>,
-  config: {
-    maxTries?: number
-    retrySleep?: number
-  } = {
-    maxTries: 2,
-    retrySleep: 1000,
-  },
-): Promise<T> {
-  const maxTries = config.maxTries ?? 2
-  const retrySleep = config.retrySleep ?? 1000
-  const trace = new Error().stack?.split("\n").slice(5).join("\n")
-
-  let lastError: any
-  for (let count = 0; count < maxTries; count += 1) {
-    try {
-      return await action()
-    } catch (error: any) {
-      error.message += `\n${trace}`
-      console.log(`Attempt ${count + 1} failed: ${error.message}`)
-      lastError = error
-      if (count < maxTries - 1) {
-        await sleep(retrySleep)
-      }
-    }
-  }
-
-  throw lastError || new Error(`Function failed after ${maxTries} retries: ${lastError?.message}`)
-}
-
-function getRandomInteger(min: number, max: number) {
-  return Math.floor(Math.random() * (max - min)) + min
-}
-
-function getAxiosInstance({
-  baseUrl,
-  timeout = 10000,
-  headers = {},
-  auth,
-}: {
-  baseUrl: string
-  timeout?: number
-  headers?: { [key: string]: string }
-  auth?: {
-    username: string
-    password: string
-  }
-}) {
-  let host = baseUrl
-  let instance
-
-  instance = axios.create({
-    baseURL: host,
-    timeout,
-    auth,
-    headers: {
-      ...headers,
-    },
-  })
-
-  // Add a response interceptor
-  instance.interceptors.response.use(
-    (response) => response,
-    (error) => {
-      // todo : fix this part
-      if (error.response) {
-        const serviceError = new Error(
-          JSON.stringify({ data: error.response.data, message: error.message }),
-        )
-        return Promise.reject(serviceError)
-      }
-
-      if (error.request) {
-        const serviceError = new Error(error.message)
-        return Promise.reject(serviceError)
-      }
-      return Promise.reject(error)
-    },
-  )
-
-  return instance
-}
-
-export { sleep, runWithRetries, getRandomInteger, getAxiosInstance }
+import axios from "axios"
+
+function sleep(ms: number) {
+  // eslint-disable-next-line no-promise-executor-return
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+async function runWithRetries<T>(
+  action: () => Promise<T>,
+  config: {
+    maxTries?: number
+    retrySleep?: number
+  } = {
+    maxTries: 2,
+    retrySleep: 1000,
+  },
+): Promise<T> {
+  const maxTries = config.maxTries ?? 2
+  const retrySleep = config.retrySleep ?? 1000
+  const trace = new Error().stack?.split("\n").slice(5).join("\n")
+
+  let lastError: any
+  for (let count = 0; count < maxTries; count += 1) {
+    try {
+      return await action()
+    } catch (error: any) {
+      error.message += `\n${trace}`
+      console.log(`Attempt ${count + 1} failed: ${error.message}`)
+      lastError = error
+      if (count < maxTries - 1) {
+        await sleep(retrySleep)
+      }
+    }
+  }
+
+  throw lastError || new Error(`Function failed after ${maxTries} retries: ${lastError?.message}`)
+}
+
+function getRandomInteger(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min)) + min
+}
+
+function getAxiosInstance({
+  baseUrl,
+  timeout = 10000,
+  headers = {},
+  auth,
+}: {
+  baseUrl: string
+  timeout?: number
+  headers?: { [key: string]: string }
+  auth?: {
+    username: string
+    password: string
+  }
+}) {
+  let host = baseUrl
+  let instance
+
+  instance = axios.create({
+    baseURL: host,
+    timeout,
+    auth,
+    headers: {
+      ...headers,
+    },
+  })
+
+  // Add a response interceptor
+  instance.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      // todo : fix this part
+      if (error.response) {
+        const serviceError = new Error(
+          JSON.stringify({ data: error.response.data, message: error.message }),
+        )
+        return Promise.reject(serviceError)
+      }
+
+      if (error.request) {
+        const serviceError = new Error(error.message)
+        return Promise.reject(serviceError)
+      }
+      return Promise.reject(error)
+    },
+  )
+
+  return instance
+}
+
+export { sleep, runWithRetries, getRandomInteger, getAxiosInstance }

package/tsconfig.json

@@ -1,9 +1,9 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src" /* Specify the root folder within your source files. */,
-    "outDir": "dist" /* Specify an output folder for all emitted files. */
-  },
-  "include": ["src"],
-  "exclude": ["node_modules", "dist"]
-}
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src" /* Specify the root folder within your source files. */,
+    "outDir": "dist" /* Specify an output folder for all emitted files. */
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/webpack.config.js

@@ -1,16 +1,16 @@
-const path = require("path")
-// const webpack = require("webpack")
-
-module.exports = {
-  mode: "production",
-  entry: "./dist/index.js",
-  output: {
-    filename: "bundle.js",
-    path: path.resolve(__dirname, "dist"),
-    libraryTarget: "umd", // Module type
-    globalObject: "this", // Fix for universal module definition
-  },
-  performance: {
-    hints: false,
-  },
-}
+const path = require("path")
+// const webpack = require("webpack")
+
+module.exports = {
+  mode: "production",
+  entry: "./dist/index.js",
+  output: {
+    filename: "bundle.js",
+    path: path.resolve(__dirname, "dist"),
+    libraryTarget: "umd", // Module type
+    globalObject: "this", // Fix for universal module definition
+  },
+  performance: {
+    hints: false,
+  },
+}

package/.tmp/ordinal-helper.ts

@@ -1,133 +0,0 @@
-import * as bitcoin from "bitcoinjs-lib"
-import ecc from "@bitcoinerlab/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 script = `${internalPublicKeyHex} OP_CHECKSIG OP_FALSE OP_IF ${ORDINAL_ORD_HEX} 00000000000000000000 ${fileTypeHex} OP_0 ${splittedFileHex} OP_ENDIF`
-
-  // ? bitcoinjs-lib converts "OP_PUSH 1" to "0x51" instead of "0x0101" as required by the ordinal protocol
-  // ? so we push 00000000000000000000 instead of 1 and then replace 0a00000000000000000000 with 0101
-  let leafScript = bitcoin.script.compile([
-    Buffer.from(internalPublicKeyHex, "hex"),
-    bitcoin.opcodes.OP_CHECKSIG,
-    bitcoin.opcodes.OP_FALSE,
-    bitcoin.opcodes.OP_IF,
-    Buffer.from("ord", "utf8"),
-    // instead of 1 we push 00000000000000000000
-    Buffer.from("00000000000000000000", "hex"),
-    //
-    Buffer.from(file.type!, "utf8"),
-    bitcoin.opcodes.OP_0,
-    ...bufferParts,
-    bitcoin.opcodes.OP_ENDIF,
-  ])
-
-  leafScript = Buffer.from(
-    leafScript.toString("hex").replace("0a00000000000000000000", "0101"),
-    "hex",
-  )
-
-  return leafScript
-}
-
-export function toXOnly(pubKey: Buffer) {
-  return pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33)
-}

package/.tmp/ordinal.ts

@@ -1,25 +0,0 @@
-import { OrdinalWallet } from "../"
-import getAndDecryptAccount from "@teleportdao/teleswap-nodes/src/config/account"
-
-require("dotenv").config()
-
-import blockchainConfig from "@teleportdao/teleswap-nodes/src/config/blockchain.config"
-;(async () => {
-  const account = await getAndDecryptAccount()
-
-  let btc = new OrdinalWallet("bitcoin", "", blockchainConfig.sourceNetwork.connection)
-  btc.setAccountPrivateKeyByMnemonic({
-    mnemonic: account.mnemonic,
-    index: 2,
-    addressType: "p2wpkh",
-  })
-  const x = btc.transactionBuilder.createOrdinalAddress(
-    {
-      buffer: Buffer.from("Hello World", "utf8"),
-      type: "text/plain",
-    },
-    btc.publicKey!,
-  )
-
-  console.log(x)
-})()