On the Backend

import { defineChain, createClient, ChainId, ankr, mempool, http, fallback } from '@bigmi/core'

const testnet4 = defineChain({
  id: ChainId.Testnet4,
  name: 'Bitcoin Testnet4',
  nativeCurrency: { name: 'Bitcoin', symbol: 'BTC', decimals: 8 },
  rpcUrls: {
    default: {
      http: ['https://bitcoin-testnet-rpc.publicnode.com'],
    },
  },
  blockExplorers: {
    default: {
      name: 'Mempool',
      url: 'https://mempool.space/testnet4/',
    },
  },
  testnet: true
})


const testnet4Client = createClient({
  chain: testnet4,
  transport: fallback([
    ankr({apiKey: 'YOUR_ANKR_API_KEY'}),
    mempool({ baseUrl: 'https://mempool.space/testnet4/api' }),
    http()
  ]),
})

import { getBalance, getTransaction, getBlockCount } from '@bigmi/core'
import { client } from './client.ts'

// check address balance
const address = 'some_address'
const balance = await getBalance(client, { address })
console.log('Balance:', balance)

// get transaction
const txId = 'some_tx'
const tx = await getTransaction(client, { txId })
console.log('Transaction:', tx)

// get the latest block 
const blockCount = await getBlockCount(client)
console.log('Current block:', blockCount)

import { createClient, bitcoin, http, fallback, mempool } from '@bigmi/core'

export const client = createClient({
    chain: bitcoin,
    transport: fallback([
        mempool(),
        http()
    ])
})

import { sendBitcoin } from './sendBitcoin.ts'
import { client } from './client.ts'

const privateKey = Buffer.from('0xgf.....', 'hex')
const fromAddress = 'b1qc....'
const toAddress = 'b1qer..'
const amount = 10000 // in sats, equivalent to 0.0001 BTC

// send bitcoin to another address
const { txId, confirmed, fee } = await sendBitcoin(client, fromAddress, toAddress, amount, privateKey)
console.log({
  txId,
  confirmed,
  fee
})

import { createClient, bitcoin, http, fallback, mempool } from '@bigmi/core'

export const client = createClient({
    chain: bitcoin,
    transport: fallback([
        mempool(),
        http()
    ])
})

import * as bitcoin from 'bitcoinjs-lib';
import * as ecc from '@bitcoinerlab/secp256k1'
import { createClient, getBalance, getUTXOs, sendUTXOTransaction, waitForTransaction, estimateFee, type Client } from '@bigmi/core';



export async function sendBitcoin(
  client: Client,
  fromAddress: string,
  toAddress: string,
  amount: number,
  privateKey: Buffer
) {
  try {
    // Check balance
    const balance = await getBalance(client, { address: fromAddress });
    // Add a 1000 sats buffer for transaction fees
    if (balance < amount + 1000) {
      throw new Error('Insufficient balance');
    }
    
    // Get UTXOs
    const utxos = await getUTXOs(client, {
      address: fromAddress,
      // Add a 1000 sats buffer for transaction fees
      minValue: amount + 1000,
    });
    
    if (utxos.length === 0) {
      throw new Error('No UTXOs available');
    }
    
    //init ECC lib
    bitcoin.initEccLib(ecc)

    // Create transaction
    const psbt = new bitcoin.Psbt();
    
    let totalInput = 0;
    for (const utxo of utxos) {
      psbt.addInput({
        hash: utxo.txId,
        index: utxo.vout,
        witnessUtxo: {
          script: Buffer.from(utxo.scriptHex, 'hex'),
          value: utxo.value,
        },
      });
      totalInput += utxo.value;
    }
    
    // Add outputs
    psbt.addOutput({
      address: toAddress,
      value: amount,
    });
    
    // Calculate fee and change
    const fee = await estimateFee(client, utxos.length, 2);
    const change = totalInput - amount - fee;
    
    if (change < 0) {
      throw new Error('Insufficient funds for fee');
    }
    
    if (change > 546) { // Dust threshold
      psbt.addOutput({
        address: fromAddress,
        value: change,
      });
    }
    
    // Sign and finalize
    const keyPair = bitcoin.ECPair.fromPrivateKey(privateKey);
    psbt.signAllInputs(keyPair);
    psbt.finalizeAllInputs();
    
    // Get transaction hex
    const txHex = psbt.extractTransaction().toHex();
    
    // Broadcast with Bigmi
    const txId = await sendUTXOTransaction(client, { hex: txHex });
    
    // Wait for confirmation
    const confirmed = await waitForTransaction(client, {
      txId,
      txHex,
      senderAddress: fromAddress,
      confirmations: 1,
    });
    
    return {
      txId,
      fee,
      confirmed,
    };
    
  } catch (error) {
    console.error('Transaction failed:', error);
    throw error;
  }
}