@omni-bridge/btc

import {
  // Builder
  createBtcBuilder,
  type BtcBuilder,
  
  // Fee calculation
  linearFeeCalculator,
  zcashFeeCalculator,
  calculateZcashFee,
  ZCASH_DUST_THRESHOLD,
  
  // Zcash utilities
  getZcashScript,
  
  // RPC utilities
  UtxoRpcClient,
  buildBitcoinMerkleProof,
  
  // Types
  type BtcBuilderConfig,
  type BtcWithdrawalPlan,
  type BtcDepositProof,
  type BtcMerkleProof,
  type UTXO,
  type NormalizedUTXO,
  type FeeCalculator,
  type LinearFeeParameters,
  type UtxoSelectionOptions,
  type UtxoSelectionResult,
  type UtxoPlanOverrides,
  type UtxoRpcConfig,
  type UtxoChainType,
} from "@omni-bridge/btc"

function createBtcBuilder(config: BtcBuilderConfig): BtcBuilder

import { createBtcBuilder } from "@omni-bridge/btc"

// Bitcoin mainnet
const btc = createBtcBuilder({
  network: "mainnet",
  chain: "btc",
})

// Zcash mainnet
const zec = createBtcBuilder({
  network: "mainnet",
  chain: "zcash",
})

// With custom RPC
const btcCustom = createBtcBuilder({
  network: "mainnet",
  chain: "btc",
  rpcUrl: "https://my-bitcoin-node.com",
  rpcHeaders: { Authorization: "Bearer token" },
})

buildWithdrawalPlan(
  utxos: UTXO[],
  amount: bigint,
  targetAddress: string,
  changeAddress: string,
  feeRate?: number,
  overrides?: UtxoPlanOverrides
): BtcWithdrawalPlan

const utxos = [
  { txid: "abc123...", vout: 0, balance: 50000n },
  { txid: "def456...", vout: 1, balance: 100000n },
]

const plan = btc.buildWithdrawalPlan(
  utxos,
  75000n,                    // 0.00075 BTC
  "bc1qrecipient...",        // recipient
  "bc1qchange...",           // change address
  15                         // 15 sat/vbyte
)

console.log("Inputs:", plan.inputs)      // ["abc123...:0", "def456...:1"]
console.log("Fee:", plan.fee)            // Calculated fee in satoshis
console.log("Outputs:", plan.outputs)    // [{ value, script_pubkey }, ...]

selectUtxos(
  utxos: NormalizedUTXO[],
  amount: bigint,
  options?: Partial<UtxoSelectionOptions>
): UtxoSelectionResult

const utxos = [
  { txid: "abc...", vout: 0, amount: 50000n },
  { txid: "def...", vout: 1, amount: 100000n },
]

const result = btc.selectUtxos(utxos, 75000n)

console.log("Selected inputs:", result.inputs.length)
console.log("Total input:", result.totalInput)
console.log("Fee:", result.fee)
console.log("Change:", result.change)
console.log("Output count:", result.outputs)

getDepositProof(txHash: string, vout: number): Promise<BtcDepositProof>

const proof = await btc.getDepositProof(
  "a1b2c3d4e5f6...",  // transaction hash
  0                    // output index
)

console.log("Block hash:", proof.tx_block_blockhash)
console.log("Merkle proof:", proof.merkle_proof)
console.log("Amount:", proof.amount)

getMerkleProof(txHash: string): Promise<BtcMerkleProof>

const merkle = await btc.getMerkleProof("a1b2c3d4e5f6...")

console.log("Block height:", merkle.block_height)
console.log("Position:", merkle.pos)
console.log("Proof path:", merkle.merkle)

addressToScriptPubkey(address: string): string

// Bitcoin P2WPKH
const btcScript = btc.addressToScriptPubkey("bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4")
// "0014751e76e8199196d454941c45d1b3a323f1433bd6"

// Zcash t-address
const zec = createBtcBuilder({ network: "mainnet", chain: "zcash" })
const zecScript = zec.addressToScriptPubkey("t1Rv4exT7bqhZqi2j7xz8bUHDMxwosrjADU")
// "76a914..."

broadcastTransaction(txHex: string): Promise<string>

const signedTxHex = "0200000001..."  // Your signed transaction

const txid = await btc.broadcastTransaction(signedTxHex)
console.log("Broadcast successful:", txid)

getTransactionBytes(txHash: string): Promise<Uint8Array>

const txBytes = await btc.getTransactionBytes("a1b2c3d4e5f6...")
console.log("Transaction size:", txBytes.length, "bytes")

getNetwork(): typeof btc.NETWORK | typeof btc.TEST_NETWORK

const network = btc.getNetwork()
// Use with @scure/btc-signer for address operations

function linearFeeCalculator(params: LinearFeeParameters): FeeCalculator

import { linearFeeCalculator } from "@omni-bridge/btc"

const calculator = linearFeeCalculator({
  base: 10,
  input: 68,
  output: 31,
  rate: 15,  // 15 sat/vbyte
})

// Calculate fee for 2 inputs, 2 outputs
const fee = calculator(2, 2)
// vbytes = 10 + 2*68 + 2*31 = 208
// fee = 208 * 15 = 3120 satoshis

function zcashFeeCalculator(): FeeCalculator

import { zcashFeeCalculator } from "@omni-bridge/btc"

const calculator = zcashFeeCalculator()
const fee = calculator(2, 2)  // 10000n zatoshis

function calculateZcashFee(inputs: number, outputs: number): bigint

import { calculateZcashFee } from "@omni-bridge/btc"

calculateZcashFee(1, 1)  // 10000n (grace minimum)
calculateZcashFee(2, 2)  // 10000n (grace minimum)
calculateZcashFee(3, 2)  // 15000n (3 * 5000)
calculateZcashFee(5, 2)  // 25000n (5 * 5000)

function getZcashScript(address: string): string

import { getZcashScript } from "@omni-bridge/btc"

// P2PKH address -> OP_DUP OP_HASH160 <hash> OP_EQUALVERIFY OP_CHECKSIG
const p2pkh = getZcashScript("t1Rv4exT7bqhZqi2j7xz8bUHDMxwosrjADU")
// "76a914...88ac"

// P2SH address -> OP_HASH160 <hash> OP_EQUAL
const p2sh = getZcashScript("t3...")
// "a914...87"

import { ZCASH_DUST_THRESHOLD } from "@omni-bridge/btc"

console.log(ZCASH_DUST_THRESHOLD)  // 5000n

new UtxoRpcClient(config: UtxoRpcConfig)

call<T>(method: string, params?: unknown[]): Promise<T>

getTransaction(txHash: string): Promise<RawTransactionResult>

getBlock(blockHash: string): Promise<BlockResult>

buildDepositProof(txHash: string, vout: number): Promise<BtcDepositProof>

buildMerkleProof(txHash: string): Promise<BtcMerkleProof>

import { UtxoRpcClient } from "@omni-bridge/btc"
import { ChainKind } from "@omni-bridge/core"

const rpc = new UtxoRpcClient({
  url: "https://bitcoin-rpc.publicnode.com",
  chain: ChainKind.Btc,
})

// Raw RPC call
const blockCount = await rpc.call<number>("getblockcount")

// Get deposit proof
const proof = await rpc.buildDepositProof("txhash...", 0)

function buildBitcoinMerkleProof(
  txids: string[],
  targetTxid: string
): { index: number; merkle: string[] }

import { buildBitcoinMerkleProof } from "@omni-bridge/btc"

const blockTxids = ["tx1...", "tx2...", "tx3...", "tx4..."]
const proof = buildBitcoinMerkleProof(blockTxids, "tx2...")

console.log("Index:", proof.index)      // 1
console.log("Proof path:", proof.merkle)

interface UTXO {
  /** Transaction ID */
  txid: string
  
  /** Output index in the transaction */
  vout: number
  
  /** Balance in satoshis/zatoshis (flexible input types) */
  balance: bigint | number | string
  
  /** Raw transaction bytes (optional, for signing) */
  tx_bytes?: Uint8Array | number[]
  
  /** HD derivation path (optional, for hardware wallets) */
  path?: string
}

interface NormalizedUTXO {
  /** Transaction ID */
  txid: string
  
  /** Output index */
  vout: number
  
  /** Amount in satoshis/zatoshis */
  amount: bigint
  
  /** HD derivation path */
  path?: string
  
  /** Raw transaction bytes */
  rawTx?: Uint8Array
}

interface BtcWithdrawalPlan {
  /** Input references in "txid:vout" format */
  inputs: string[]
  
  /** Outputs with value and scriptPubkey */
  outputs: Array<{
    /** Value in satoshis/zatoshis */
    value: number
    
    /** Hex-encoded scriptPubkey */
    script_pubkey: string
  }>
  
  /** Calculated transaction fee */
  fee: bigint
}

interface BtcDepositProof {
  /** Merkle proof hashes */
  merkle_proof: string[]
  
  /** Block hash containing the transaction */
  tx_block_blockhash: string
  
  /** Raw transaction bytes */
  tx_bytes: number[]
  
  /** Transaction index in the block */
  tx_index: number
  
  /** Output amount in satoshis/zatoshis */
  amount: bigint
}

interface BtcMerkleProof {
  /** Block height */
  block_height: number
  
  /** Merkle proof path (hex-encoded hashes) */
  merkle: string[]
  
  /** Transaction position in block */
  pos: number
}

type FeeCalculator = (inputCount: number, outputCount: number) => bigint

interface LinearFeeParameters {
  /** Base transaction size in vbytes */
  base: number
  
  /** Size per input in vbytes */
  input: number
  
  /** Size per output in vbytes */
  output: number
  
  /** Fee rate in sat/vbyte */
  rate: number
}

interface UtxoSelectionOptions {
  /** Fee calculator function */
  feeCalculator: FeeCalculator
  
  /** Minimum output value (dust threshold) */
  dustThreshold: bigint
  
  /** Minimum change output value */
  minChange?: bigint
  
  /** Maximum number of inputs */
  maxInputs?: number
  
  /** Sorting strategy for UTXOs */
  sort?: "largest-first" | "smallest-first"
}

interface UtxoSelectionResult {
  /** Selected UTXOs */
  inputs: NormalizedUTXO[]
  
  /** Sum of all input values */
  totalInput: bigint
  
  /** Calculated transaction fee */
  fee: bigint
  
  /** Change amount (0 if no change output) */
  change: bigint
  
  /** Number of outputs (1 or 2) */
  outputs: number
}

type UtxoPlanOverrides = Partial<Omit<UtxoSelectionOptions, "feeCalculator">>

interface BtcBuilderConfig {
  /** Network: "mainnet" or "testnet" */
  network: "mainnet" | "testnet"
  
  /** Chain type: "btc" or "zcash" */
  chain?: "btc" | "zcash"
  
  /** Custom Blockstream API URL */
  apiUrl?: string
  
  /** Custom RPC URL */
  rpcUrl?: string
  
  /** RPC authentication headers */
  rpcHeaders?: Record<string, string>
}

interface UtxoRpcConfig {
  /** JSON-RPC endpoint URL */
  url: string
  
  /** Optional HTTP headers */
  headers?: Record<string, string>
  
  /** Chain type for RPC variations */
  chain: UtxoChainType
}

type UtxoChainType = ChainKind.Btc | ChainKind.Zcash

{
  feeCalculator: linearFeeCalculator({ base: 10, input: 68, output: 31, rate: 1 }),
  dustThreshold: 546n,
  minChange: 1000n,
  sort: "largest-first",
}

{
  feeCalculator: zcashFeeCalculator(),
  dustThreshold: 5000n,
  minChange: 5000n,
  sort: "largest-first",
}