@bigmi/core 0.0.1

package/src/utils/getUTXOAddress.ts

@@ -0,0 +1,148 @@
+import { sha256 } from '@noble/hashes/sha256'
+import { type Decoded, bech32, bech32m } from 'bech32'
+import bs58 from 'bs58'
+
+export enum UTXONetwork {
+  Mainnet = 'mainnet',
+  Testnet = 'testnet',
+  Regtest = 'regtest',
+}
+
+export enum UTXOAddressType {
+  p2pkh = 'p2pkh',
+  p2sh = 'p2sh',
+  p2wpkh = 'p2wpkh',
+  p2wsh = 'p2wsh',
+  p2tr = 'p2tr',
+}
+
+export type UTXOAddress = {
+  bech32: boolean
+  network: UTXONetwork
+  address: string
+  type: UTXOAddressType
+}
+
+const addressTypes: {
+  [key: number]: { type: UTXOAddressType; network: UTXONetwork }
+} = {
+  0: {
+    type: UTXOAddressType.p2pkh,
+    network: UTXONetwork.Mainnet,
+  },
+  111: {
+    type: UTXOAddressType.p2pkh,
+    network: UTXONetwork.Testnet,
+  },
+  5: {
+    type: UTXOAddressType.p2sh,
+    network: UTXONetwork.Mainnet,
+  },
+  196: {
+    type: UTXOAddressType.p2sh,
+    network: UTXONetwork.Testnet,
+  },
+}
+
+const parseBech32 = (address: string): UTXOAddress => {
+  let decoded: Decoded
+
+  try {
+    if (
+      address.startsWith('bc1p') ||
+      address.startsWith('tb1p') ||
+      address.startsWith('bcrt1p')
+    ) {
+      decoded = bech32m.decode(address)
+    } else {
+      decoded = bech32.decode(address)
+    }
+  } catch (_error) {
+    throw new Error('Invalid address')
+  }
+
+  const mapPrefixToNetwork: { [key: string]: UTXONetwork } = {
+    bc: UTXONetwork.Mainnet,
+    tb: UTXONetwork.Testnet,
+    bcrt: UTXONetwork.Regtest,
+  }
+
+  const network: UTXONetwork = mapPrefixToNetwork[decoded.prefix]
+
+  if (network === undefined) {
+    throw new Error('Invalid address')
+  }
+
+  const witnessVersion = decoded.words[0]
+
+  if (witnessVersion < 0 || witnessVersion > 16) {
+    throw new Error('Invalid address')
+  }
+  const data = bech32.fromWords(decoded.words.slice(1))
+
+  let type: UTXOAddressType
+  if (data.length === 20) {
+    type = UTXOAddressType.p2wpkh
+  } else if (witnessVersion === 1) {
+    type = UTXOAddressType.p2tr
+  } else {
+    type = UTXOAddressType.p2wsh
+  }
+
+  return {
+    bech32: true,
+    network,
+    address,
+    type,
+  }
+}
+
+export const getUTXOAddress = (address: string): UTXOAddress => {
+  let decoded: Uint8Array
+  const prefix = address.substring(0, 2).toLowerCase()
+
+  if (prefix === 'bc' || prefix === 'tb') {
+    return parseBech32(address)
+  }
+
+  try {
+    decoded = bs58.decode(address)
+  } catch (_error) {
+    throw new Error('Invalid address')
+  }
+
+  const { length } = decoded
+
+  if (length !== 25) {
+    throw new Error('Invalid address')
+  }
+
+  const version = decoded[0]
+
+  const checksum = decoded.slice(length - 4, length)
+  const body = decoded.slice(0, length - 4)
+
+  const expectedChecksum = sha256(sha256(body)).slice(0, 4)
+
+  if (
+    checksum.some(
+      (value: number, index: number) => value !== expectedChecksum[index]
+    )
+  ) {
+    throw new Error('Invalid address')
+  }
+
+  const validVersions = Object.keys(addressTypes).map(Number)
+
+  if (!validVersions.includes(version)) {
+    throw new Error('Invalid address')
+  }
+
+  const addressType = addressTypes[version]
+
+  return {
+    ...addressType,
+    address,
+    bech32: false,
+  }
+}

package/src/utils/isUTXOAddress.ts

@@ -0,0 +1,18 @@
+import { type UTXONetwork, getUTXOAddress } from './getUTXOAddress.js'
+
+export const isUTXOAddress = (
+  address: string,
+  network?: UTXONetwork
+): boolean => {
+  try {
+    const utxoAddress = getUTXOAddress(address)
+
+    if (network) {
+      return network === utxoAddress.network
+    }
+
+    return true
+  } catch (_error) {
+    return false
+  }
+}

package/src/utils/modifyFee.ts

@@ -0,0 +1,78 @@
+import { Psbt, address } from 'bitcoinjs-lib'
+
+interface InputData {
+  hash: Uint8Array
+  index: number
+  nonWitnessUtxo?: Uint8Array
+  witnessUtxo?: {
+    script: Uint8Array
+    value: bigint
+  }
+  redeemScript?: Uint8Array
+  witnessScript?: Uint8Array
+}
+
+export function modifyFee(psbt: Psbt, newFee: bigint, accountAddress: string) {
+  const newPsbt = new Psbt()
+  const inputs = psbt.data.inputs
+  const outputs = psbt.txOutputs
+
+  // Add inputs to the new PSBT
+  for (let i = 0; i < inputs.length; i++) {
+    const input = inputs[i]
+    const inputData: InputData = {
+      hash: psbt.txInputs[i].hash,
+      index: psbt.txInputs[i].index,
+    }
+
+    // Include UTXO information
+    if (input.nonWitnessUtxo) {
+      inputData.nonWitnessUtxo = input.nonWitnessUtxo
+    } else if (input.witnessUtxo) {
+      inputData.witnessUtxo = input.witnessUtxo
+    }
+
+    // Include scripts if necessary
+    if (input.redeemScript) {
+      inputData.redeemScript = input.redeemScript
+    }
+    if (input.witnessScript) {
+      inputData.witnessScript = input.witnessScript
+    }
+
+    newPsbt.addInput(inputData)
+  }
+
+  const changeOutputScript = address.toOutputScript(accountAddress)
+
+  // Add outputs to the new PSBT
+  for (const output of outputs) {
+    const outputData = {
+      script: output.script,
+      value: output.value,
+    }
+
+    const scriptsAreEqual =
+      output.script.length === changeOutputScript.length &&
+      output.script.every((value, index) => value === changeOutputScript[index])
+
+    if (scriptsAreEqual) {
+      outputData.value = output.value - newFee
+      if (outputData.value < 0) {
+        throw new Error(
+          'Insufficient funds to adjust the fee by the specified amount.'
+        )
+      }
+    }
+
+    newPsbt.addOutput(outputData)
+  }
+
+  // Modify the input sequence number to enable RBF
+  newPsbt.txInputs.forEach((_, index) => {
+    // Set sequence number to less than 0xfffffffe, e.g., 0xfffffffd
+    newPsbt.setInputSequence(index, 0xfffffffd)
+  })
+
+  return newPsbt
+}

package/src/utils/observe.ts

@@ -0,0 +1,81 @@
+import type { MaybePromise } from 'viem'
+
+type Callback = ((...args: any[]) => any) | undefined
+type Callbacks = Record<string, Callback>
+
+/** @internal */
+export const listenersCache = /*#__PURE__*/ new Map<
+  string,
+  { id: number; fns: Callbacks }[]
+>()
+/** @internal */
+export const cleanupCache = /*#__PURE__*/ new Map<string, () => void>()
+
+type EmitFunction<callbacks extends Callbacks> = (
+  emit: callbacks
+) => MaybePromise<void | (() => void)>
+
+let callbackCount = 0
+
+/**
+ * @description Sets up an observer for a given function. If another function
+ * is set up under the same observer id, the function will only be called once
+ * for both instances of the observer.
+ */
+export function observe<callbacks extends Callbacks>(
+  observerId: string,
+  callbacks: callbacks,
+  fn: EmitFunction<callbacks>
+) {
+  const callbackId = ++callbackCount
+
+  const getListeners = () => listenersCache.get(observerId) || []
+
+  const unsubscribe = () => {
+    const listeners = getListeners()
+    listenersCache.set(
+      observerId,
+      listeners.filter((cb: any) => cb.id !== callbackId)
+    )
+  }
+
+  const unwatch = () => {
+    const cleanup = cleanupCache.get(observerId)
+    if (getListeners().length === 1 && cleanup) {
+      cleanup()
+    }
+    unsubscribe()
+  }
+
+  const listeners = getListeners()
+  listenersCache.set(observerId, [
+    ...listeners,
+    { id: callbackId, fns: callbacks },
+  ])
+
+  if (listeners && listeners.length > 0) {
+    return unwatch
+  }
+
+  const emit: callbacks = {} as callbacks
+  for (const key in callbacks) {
+    emit[key] = ((
+      ...args: Parameters<NonNullable<callbacks[keyof callbacks]>>
+    ) => {
+      const listeners = getListeners()
+      if (listeners.length === 0) {
+        return
+      }
+      for (const listener of listeners) {
+        listener.fns[key]?.(...args)
+      }
+    }) as callbacks[Extract<keyof callbacks, string>]
+  }
+
+  const cleanup = fn(emit)
+  if (typeof cleanup === 'function') {
+    cleanupCache.set(observerId, cleanup)
+  }
+
+  return unwatch
+}

package/src/utils/poll.ts

@@ -0,0 +1,48 @@
+import { sleep } from './sleep.js'
+
+type PollOptions<T> = {
+  // Whether or not to emit when the polling starts.
+  emitOnBegin?: boolean | undefined
+  // The initial wait time (in ms) before polling.
+  initialWaitTime?: ((data: T | undefined) => Promise<number>) | undefined
+  // The interval (in ms).
+  interval: number
+}
+
+/**
+ * @description Polls a function at a specified interval.
+ */
+export function poll<T>(
+  fn: ({ unpoll }: { unpoll: () => void }) => Promise<T | undefined>,
+  { emitOnBegin, initialWaitTime, interval }: PollOptions<T>
+) {
+  let active = true
+
+  const unwatch = () => {
+    active = false
+  }
+
+  const watch = async () => {
+    let data: T | undefined = undefined
+    if (emitOnBegin) {
+      data = await fn({ unpoll: unwatch })
+    }
+
+    const initialWait = (await initialWaitTime?.(data)) ?? interval
+    await sleep(initialWait)
+
+    const poll = async () => {
+      if (!active) {
+        return
+      }
+      await fn({ unpoll: unwatch })
+      await sleep(interval)
+      poll()
+    }
+
+    poll()
+  }
+  watch()
+
+  return unwatch
+}

package/src/utils/sleep.ts

@@ -0,0 +1,5 @@
+export function sleep(ms: number): Promise<null> {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(null), ms)
+  })
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "sourceMap": true,
+    "rootDir": "./src",
+    "moduleResolution": "Node"
+  },
+  "include": ["./src/**/*", "./src/**/*.json"]
+}