Forem: Swatantra goswami

CISD plot

Swatantra goswami — Fri, 17 Apr 2026 13:22:22 +0000

!pip install ccxt plotly pandas -q

# ============================================================
# Cell 2 — Fetch OHLCV Data (OKX + IST to match TradingView)
# ============================================================
import ccxt
import pandas as pd

exchange = ccxt.okx()
ohlcv = exchange.fetch_ohlcv("ENJ/USDT", timeframe="15m", limit=200)

df = pd.DataFrame(ohlcv, columns=["timestamp", "open", "high", "low", "close", "volume"])
df["timestamp"] = pd.to_datetime(df["timestamp"], unit="ms")

# ✅ Convert UTC → IST to match TradingView (India)
df["timestamp"] = df["timestamp"].dt.tz_localize("UTC").dt.tz_convert("Asia/Kolkata")

df.set_index("timestamp", inplace=True)

print(df.tail(5))

# ============================================================
# Cell 3 — CISD Detection
# ============================================================
import numpy as np

def detect_swing_points(df, left=5, right=5):
    df["swing_high"] = False
    df["swing_low"]  = False

    for i in range(left, len(df) - right):
        window_high = df["high"].iloc[i - left: i + right + 1]
        window_low  = df["low"].iloc[i - left: i + right + 1]

        if df["high"].iloc[i] == window_high.max():
            df.at[df.index[i], "swing_high"] = True

        if df["low"].iloc[i] == window_low.min():
            df.at[df.index[i], "swing_low"] = True

    return df


def detect_cisd(df):
    """
    Bullish CISD → bias was bearish + close breaks ABOVE last swing high
    Bearish CISD → bias was bullish + close breaks BELOW last swing low
    """
    df = detect_swing_points(df)

    df["cisd_bullish"] = False
    df["cisd_bearish"] = False
    df["cisd_level"]   = np.nan

    bias = None
    swing_highs = []
    swing_lows  = []
    last_swing_high_price = None
    last_swing_low_price  = None

    for i in range(len(df)):
        row = df.iloc[i]

        if row["swing_high"]:
            if swing_highs:
                bias = "bullish" if row["high"] > swing_highs[-1] else "bearish"
            swing_highs.append(row["high"])
            last_swing_high_price = row["high"]

        if row["swing_low"]:
            if swing_lows:
                bias = "bearish" if row["low"] < swing_lows[-1] else "bullish"
            swing_lows.append(row["low"])
            last_swing_low_price = row["low"]

        # Bullish CISD
        if (bias == "bearish"
                and last_swing_high_price is not None
                and row["close"] > last_swing_high_price):
            df.at[df.index[i], "cisd_bullish"] = True
            df.at[df.index[i], "cisd_level"]   = last_swing_high_price
            bias = "bullish"

        # Bearish CISD
        elif (bias == "bullish"
                and last_swing_low_price is not None
                and row["close"] < last_swing_low_price):
            df.at[df.index[i], "cisd_bearish"] = True
            df.at[df.index[i], "cisd_level"]   = last_swing_low_price
            bias = "bearish"

    return df


df = detect_cisd(df)

bullish_cisd = df[df["cisd_bullish"]]
bearish_cisd = df[df["cisd_bearish"]]

print(f"✅ Bullish CISDs : {len(bullish_cisd)}")
print(f"🔻 Bearish CISDs : {len(bearish_cisd)}")

signals = df[df["cisd_bullish"] | df["cisd_bearish"]][
    ["open","high","low","close","cisd_bullish","cisd_bearish","cisd_level"]
]
print("\nRecent CISD Signals:")
print(signals.tail(5))

# ============================================================
# Cell 4 — Chart Visualization
# ============================================================
import plotly.graph_objects as go

fig = go.Figure()

# Candlestick
fig.add_trace(go.Candlestick(
    x=df.index,
    open=df["open"],
    high=df["high"],
    low=df["low"],
    close=df["close"],
    name="ENJ/USDT",
    increasing_line_color="#26a69a",
    decreasing_line_color="#ef5350"
))

# Swing Highs
swing_h = df[df["swing_high"]]
fig.add_trace(go.Scatter(
    x=swing_h.index,
    y=swing_h["high"] * 1.001,
    mode="markers",
    marker=dict(symbol="triangle-down", size=8, color="orange"),
    name="Swing High"
))

# Swing Lows
swing_l = df[df["swing_low"]]
fig.add_trace(go.Scatter(
    x=swing_l.index,
    y=swing_l["low"] * 0.999,
    mode="markers",
    marker=dict(symbol="triangle-up", size=8, color="cyan"),
    name="Swing Low"
))

# Bullish CISD
fig.add_trace(go.Scatter(
    x=bullish_cisd.index,
    y=bullish_cisd["low"] * 0.998,
    mode="markers+text",
    marker=dict(symbol="star", size=14, color="lime"),
    text=["CISD↑"] * len(bullish_cisd),
    textposition="bottom center",
    textfont=dict(color="lime", size=10),
    name="Bullish CISD"
))

# Bearish CISD
fig.add_trace(go.Scatter(
    x=bearish_cisd.index,
    y=bearish_cisd["high"] * 1.002,
    mode="markers+text",
    marker=dict(symbol="star", size=14, color="red"),
    text=["CISD↓"] * len(bearish_cisd),
    textposition="top center",
    textfont=dict(color="red", size=10),
    name="Bearish CISD"
))

# CISD level dotted lines
for idx, row in df[df["cisd_bullish"] | df["cisd_bearish"]].iterrows():
    color = "lime" if row["cisd_bullish"] else "red"
    fig.add_hline(
        y=row["cisd_level"],
        line_dash="dot",
        line_color=color,
        line_width=1,
        opacity=0.4
    )

fig.update_layout(
    title="ENJ/USDT 15m — CISD Detection (IST | Matches TradingView)",
    xaxis_title="Time (IST +5:30)",
    yaxis_title="Price (USDT)",
    template="plotly_dark",
    xaxis_rangeslider_visible=False,
    height=700,
    legend=dict(orientation="h", yanchor="bottom", y=1.02)
)

fig.show()

# ============================================================
# Cell 4 — Chart with CISD + Session Highlights (IST)
# ============================================================
import plotly.graph_objects as go
import pandas as pd

fig = go.Figure()

# --- Candlestick ---
fig.add_trace(go.Candlestick(
    x=df.index,
    open=df["open"],
    high=df["high"],
    low=df["low"],
    close=df["close"],
    name="BTC/USDT",
    increasing_line_color="#26a69a",
    decreasing_line_color="#ef5350"
))

# --- Swing Highs ---
swing_h = df[df["swing_high"]]
fig.add_trace(go.Scatter(
    x=swing_h.index,
    y=swing_h["high"] * 1.001,
    mode="markers",
    marker=dict(symbol="triangle-down", size=8, color="orange"),
    name="Swing High"
))

# --- Swing Lows ---
swing_l = df[df["swing_low"]]
fig.add_trace(go.Scatter(
    x=swing_l.index,
    y=swing_l["low"] * 0.999,
    mode="markers",
    marker=dict(symbol="triangle-up", size=8, color="cyan"),
    name="Swing Low"
))

# --- Bullish CISD ---
fig.add_trace(go.Scatter(
    x=bullish_cisd.index,
    y=bullish_cisd["low"] * 0.998,
    mode="markers+text",
    marker=dict(symbol="star", size=14, color="lime"),
    text=["CISD↑"] * len(bullish_cisd),
    textposition="bottom center",
    textfont=dict(color="lime", size=10),
    name="Bullish CISD"
))

# --- Bearish CISD ---
fig.add_trace(go.Scatter(
    x=bearish_cisd.index,
    y=bearish_cisd["high"] * 1.002,
    mode="markers+text",
    marker=dict(symbol="star", size=14, color="red"),
    text=["CISD↓"] * len(bearish_cisd),
    textposition="top center",
    textfont=dict(color="red", size=10),
    name="Bearish CISD"
))

# --- CISD level dotted lines ---
for idx, row in df[df["cisd_bullish"] | df["cisd_bearish"]].iterrows():
    color = "lime" if row["cisd_bullish"] else "red"
    fig.add_hline(
        y=row["cisd_level"],
        line_dash="dot",
        line_color=color,
        line_width=1,
        opacity=0.4
    )

# ============================================================
# --- Session Highlighting (IST timings) ---
# ============================================================
sessions = {
    "Asia"    : {"start": "05:30", "end": "09:15", "color": "rgba(0, 100, 255, 0.10)"},
    "London"  : {"start": "11:30", "end": "14:15", "color": "rgba(255, 50, 50, 0.10)"},
    "New York": {"start": "19:00", "end": "20:00", "color": "rgba(0, 200, 100, 0.10)"},
}

# Get unique dates in the dataframe
unique_dates = df.index.normalize().unique()

for date in unique_dates:
    date_str = str(date.date())

    for session_name, session in sessions.items():
        start_dt = pd.Timestamp(f"{date_str} {session['start']}", tz="Asia/Kolkata")
        end_dt   = pd.Timestamp(f"{date_str} {session['end']}",   tz="Asia/Kolkata")

        # Only draw if session overlaps with our data range
        if start_dt > df.index[-1] or end_dt < df.index[0]:
            continue

        fig.add_vrect(
            x0=start_dt,
            x1=end_dt,
            fillcolor=session["color"],
            line_width=0,
            annotation_text=session_name,
            annotation_position="top left",
            annotation_font=dict(size=9, color="white"),
            layer="below"
        )

# ============================================================
# Layout
# ============================================================
fig.update_layout(
    title="ENJ/USDT 15m — CISD + Sessions (IST)",
    xaxis_title="Time (IST +5:30)",
    yaxis_title="Price (USDT)",
    template="plotly_dark",
    xaxis_rangeslider_visible=False,
    height=750,
    legend=dict(orientation="h", yanchor="bottom", y=1.02),
    shapes=[],
)

fig.show()

Spark Protocol Staking

Swatantra goswami — Wed, 15 Apr 2026 09:19:35 +0000

import { usdtTokenABI, usdtContractAddress, usdcTokenABI, aavePoolABI, usdcContractAddress, } from "../constant/constants"
import { SPARK_PROVIDER, POOL_ADDRESSES_PROVIDER_ABI } from "../constant/spark"

const RPC_URL = 'https://mainnet.infura.io/v3/b762a9db129e4b2ba94ca57f5e046f97'

const { ethers, JsonRpcProvider, formatUnits, parseUnits } = require('ethers');

const SPARK_VAULT_BY_TOKEN = {
    "0xdAC17F958D2ee523a2206206994597C13D831ec7": "0xe2e7a17dFf93280dec073C995595155283e3C372", // USDT → spUSDT
    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "0x28b3a8fb53b741a8fd78c0fb9a6b2393d896a43d", // USDC → spUSDC
};
export const useSpark = () => {
    const provider = new JsonRpcProvider(RPC_URL);
    let privateKey = "8220310fb6bf04bf68324337e2fa5c3811b8d2dbbee74018ba56e075d7b75b8d"
    const signer = new ethers.Wallet(privateKey, provider);
    const usdtInstance = new ethers.Contract(usdtContractAddress, usdtTokenABI, signer);
    const usdcInstance = new ethers.Contract(usdcContractAddress, usdcTokenABI, signer);

    async function getBalance() {
        try {
            const userAddress = await signer.getAddress();
            console.log("userAddress:", userAddress)
            const balance = await usdtInstance.balanceOf(userAddress);
            const formattedBalance = formatUnits(balance, 6);

            console.log("USDT balance:", formattedBalance);

            return formattedBalance;

        } catch (error) {
            console.error("Error fetching USDT balance:", error);
            return null;
        }
    }

    async function stake({ amount, tokenAddress = "0xdAC17F958D2ee523a2206206994597C13D831ec7" }) {
        try {
            const user = await signer.getAddress();

            const vaultAddress = SPARK_VAULT_BY_TOKEN[tokenAddress];
            if (!vaultAddress) throw new Error(`No Spark vault for token: ${tokenAddress}`);

            // const tokenInstance = new ethers.Contract(tokenAddress, usdtTokenABI, signer);
            const vault = new ethers.Contract(
                vaultAddress,
                [
                    "function deposit(uint256 assets, address receiver) returns (uint256 shares)"
                ],
                signer
            );

            const decimals = tokenAddress === usdtContractAddress ? 6 : 6; // both USDT & USDC are 6
            const amountInWei = parseUnits(amount.toString(), decimals);

            // Check & reset allowance (USDT requires reset to 0 before new approval)
            const allowance = await usdtInstance.allowance(user, vaultAddress);
            if (allowance > 0n) {
                console.log("Resetting allowance to 0...");
                const resetTx = await usdtInstance.approve(vaultAddress, 0n);
                await resetTx.wait();
            }

            console.log("Approving...");
            const approveTx = await usdtInstance.approve(vaultAddress, amountInWei);
            await approveTx.wait();

            console.log("Depositing into Spark savings vault...");
            const tx = await vault.deposit(amountInWei, user);
            const receipt = await tx.wait();

            console.log("Stake successful:", receipt.transactionHash);
            return true;

        } catch (error) {
            console.error("REAL ERROR:", error);
            return false;
        }
    }

    async function unStake({ amount, tokenAddress = "0xdAC17F958D2ee523a2206206994597C13D831ec7" }) {
        try {
            const user = await signer.getAddress();

            const vaultAddress = SPARK_VAULT_BY_TOKEN[tokenAddress];
            const vault = new ethers.Contract(
                vaultAddress,
                [
                    "function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)",
                    "function balanceOf(address) view returns (uint256)"
                ],
                signer
            );

            // Redeem all shares
            const shares = await vault.balanceOf(user);

            const tx = await vault.redeem(shares, user, user);
            const receipt = await tx.wait();

            console.log("Unstake successful:", receipt.transactionHash);
            return true;

        } catch (error) {
            console.error("Withdraw failed:", error);
            return false;
        }
    }

    async function getATokenBalance(tokenAddress = "0xdAC17F958D2ee523a2206206994597C13D831ec7") {
        try {
            const user = await signer.getAddress();

            const vaultAddress = SPARK_VAULT_BY_TOKEN[tokenAddress];
            if (!vaultAddress) throw new Error(`No Spark vault for token: ${tokenAddress}`);

            const vault = new ethers.Contract(
                vaultAddress,
                [
                    "function assetsOf(address owner) view returns (uint256)",
                    "function balanceOf(address owner) view returns (uint256)"
                ],
                provider
            );

            const [assetsInWei, sharesInWei] = await Promise.all([
                vault.assetsOf(user),
                vault.balanceOf(user),
            ]);

            const assets = formatUnits(assetsInWei, 6); // both USDT & USDC are 6 decimals
            const shares = formatUnits(sharesInWei, 18); // vault shares are 18 decimals

            console.log(`Staked balance: ${assets} (${shares} sp${tokenAddress === usdtContractAddress ? "USDT" : "USDC"} shares)`);

            return assets; // underlying token amount (what to show user)

        } catch (error) {
            console.error("Error fetching spToken balance:", error);
            return null;
        }
    }

    async function getSupplyAPY(tokenAddress = "0xdAC17F958D2ee523a2206206994597C13D831ec7") {
        try {
            const vaultAddress = SPARK_VAULT_BY_TOKEN[tokenAddress];
            if (!vaultAddress) throw new Error(`No Spark vault found for token: ${tokenAddress}`);

            const vault = new ethers.Contract(
                vaultAddress,
                ["function vsr() view returns (uint256)"],
                provider
            );

            const vsr = await vault.vsr();

            const RAY = 1e27;
            const SECONDS_PER_YEAR = 31536000;

            const vsrFloat = Number(vsr) / RAY;
            const supplyAPY = (Math.pow(vsrFloat, SECONDS_PER_YEAR) - 1) * 100;

            const result = supplyAPY.toFixed(2);
            console.log(`Spark Supply APY for ${tokenAddress}:`, result + "%");

            return result;

        } catch (error) {
            console.error("APY error:", error);
            return null;
        }
    }

    async function getRewards(tokenAddress = "0xdAC17F958D2ee523a2206206994597C13D831ec7") {
        try {
            const user = await signer.getAddress();

            const vaultAddress = SPARK_VAULT_BY_TOKEN[tokenAddress];
            if (!vaultAddress) throw new Error(`No Spark vault for token: ${tokenAddress}`);

            const vault = new ethers.Contract(
                vaultAddress,
                [
                    "function assetsOf(address owner) view returns (uint256)",
                    "event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares)",
                    "event Withdraw(address indexed caller, address indexed receiver, address indexed owner, uint256 assets, uint256 shares)"
                ],
                provider
            );

            const [depositEvents, withdrawEvents, currentAssetsInWei] = await Promise.all([
                vault.queryFilter(vault.filters.Deposit(null, user)),
                vault.queryFilter(vault.filters.Withdraw(null, null, user)),
                vault.assetsOf(user),
            ]);

            const totalDeposited = depositEvents.reduce((sum, e) => sum + e.args.assets, 0n);
            const totalWithdrawn = withdrawEvents.reduce((sum, e) => sum + e.args.assets, 0n);
            const principal = totalDeposited - totalWithdrawn;

            const rewardsInWei = currentAssetsInWei - principal;

            return {
                token: tokenAddress, // USDT or USDC — yield is paid in the same underlying asset
                amount: formatUnits(rewardsInWei > 0n ? rewardsInWei : 0n, 6)
            };

        } catch (error) {
            console.error("Error fetching rewards:", error);
            return null;
        }
    }

    async function claimRewards(tokenAddress = "0xdAC17F958D2ee523a2206206994597C13D831ec7") {
        try {
            const user = await signer.getAddress();

            const vaultAddress = SPARK_VAULT_BY_TOKEN[tokenAddress];
            if (!vaultAddress) throw new Error(`No Spark vault for token: ${tokenAddress}`);

            const vault = new ethers.Contract(
                vaultAddress,
                [
                    "function assetsOf(address owner) view returns (uint256)",
                    "function convertToShares(uint256 assets) view returns (uint256)",
                    "function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)",
                    "event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares)",
                    "event Withdraw(address indexed caller, address indexed receiver, address indexed owner, uint256 assets, uint256 shares)"
                ],
                signer
            );

            const [depositEvents, withdrawEvents, currentAssetsInWei] = await Promise.all([
                vault.queryFilter(vault.filters.Deposit(null, user)),
                vault.queryFilter(vault.filters.Withdraw(null, null, user)),
                vault.assetsOf(user),
            ]);

            const totalDeposited = depositEvents.reduce((sum, e) => sum + e.args.assets, 0n);
            const totalWithdrawn = withdrawEvents.reduce((sum, e) => sum + e.args.assets, 0n);
            const principal = totalDeposited - totalWithdrawn;
            const rewardsInWei = currentAssetsInWei - principal;

            if (rewardsInWei <= 0n) {
                console.log("No rewards to claim");
                return true;
            }

            // Convert reward assets → shares first, then redeem exact shares
            // redeem() rounds DOWN (safe), withdraw() rounds UP (causes insufficient-balance)
            const rewardShares = await vault.convertToShares(rewardsInWei);

            if (rewardShares <= 0n) {
                console.log("Reward shares too small to claim");
                return true;
            }

            console.log("Claiming rewards:", formatUnits(rewardsInWei, 6));
            const tx = await vault.redeem(rewardShares, user, user);
            const receipt = await tx.wait();

            console.log("Rewards claimed:", receipt.transactionHash);
            return true;

        } catch (error) {
            console.error("Error claiming rewards:", error);
            return false;
        }
    }



    return {
        stake,
        unStake,
        getBalance,
        getATokenBalance,
        getSupplyAPY,
        getRewards,
        claimRewards
    }
}

Compound finance Staking

Swatantra goswami — Thu, 09 Apr 2026 12:39:09 +0000

import {ethers, parseUnits} from 'ethers';
import erc20 from '../../abis/erc20.json';
import cometContractABI from '../../abis/comet_compound_abi.json';
// token contract address → Compound V3 Comet contract address
export const TOKEN_TO_COMET_ADDRESS = {
  '0xdAC17F958D2ee523a2206206994597C13D831ec7':
    '0x3Afdc9BCA9213A35503b077a6072F3D0d5AB0840', // USDT
  '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48':
    '0xc3d688B66703497DAA19211EEdff47f25384cdc3', // USDC
};
export const cometRewardAddress = '0x1B0e765F6224C21223AeA2af16c1C46E38885a40';
const getCometAddress = contractAddress =>
  TOKEN_TO_COMET_ADDRESS[
    Object.keys(TOKEN_TO_COMET_ADDRESS).find(
      key => key.toLowerCase() === contractAddress?.toLowerCase(),
    )
  ];

export const compoundProvider = {
  icon: 'https://img.bgstatic.com/multiLang/coinPriceLogo/1x1/compound.jpg',
  name: 'Compound',
  apy: '0% APY',
  stakedAmount: '0',
  stakedAmountRaw: null,
  poolContractAddress: 'aavePoolContractAddress',
  poolABI: cometContractABI,
  dataProviderContractAddress: '',
  dataProviderABI: 'aaveDataProviderABI',
  createStaking: async (
    {from, amount, privateKey, contractAddress, decimals, evmProvider},
    provider,
  ) => {
    try {
      const cometAddress = getCometAddress(contractAddress);
      const wallet = new ethers.Wallet(privateKey);
      const walletSigner = wallet.connect(evmProvider);
      const tokenContract = new ethers.Contract(
        contractAddress,
        erc20,
        walletSigner,
      );
      const amountInWei = parseUnits(amount.toString(), decimals);
      const comet = new ethers.Contract(
        cometAddress,
        cometContractABI,
        walletSigner,
      );
      const baseToken = await comet.baseToken();
      if (contractAddress.toLowerCase() !== baseToken.toLowerCase()) {
        throw new Error(
          '❌ This Comet only supports its base asset (e.g., USDC)',
        );
      }
      const balance = await tokenContract.balanceOf(from);

      console.log('Wallet Balance:', ethers.formatUnits(balance, 6));
      if (balance < amountInWei) {
        throw new Error('❌ Insufficient token balance');
      }

      // USDT requires resetting allowance to 0 before setting a new value
      const currentAllowance = await tokenContract.allowance(
        from,
        cometAddress,
      );
      if (currentAllowance > 0n) {
        const resetTx = await tokenContract.approve(cometAddress, 0n);
        await resetTx.wait();
      }
      const approveTx = await tokenContract.approve(cometAddress, amountInWei);
      await approveTx.wait();
      // � Step 4: Supply (THIS = staking)
      const tx = await comet.supply(contractAddress, amountInWei);
      await tx.wait();

      console.log('✅ Successfully supplied to Compound V3');

      return tx.hash;
    } catch (error) {
      console.log(error);
      throw error;
    }
  },
  unStaking: async (
    {from, amount, privateKey, contractAddress, evmProvider},
    provider,
  ) => {
    try {
      const cometAddress = getCometAddress(contractAddress);
      const wallet = new ethers.Wallet(privateKey);
      const walletSigner = wallet.connect(evmProvider);
      const comet = new ethers.Contract(
        cometAddress,
        cometContractABI,
        walletSigner,
      );
      //  const amountInWei = ethers.parseUnits(amount.toString(), 6);
      // � Parse amount (USDC = 6 decimals)
      const baseToken = await comet.baseToken();
      console.log('baseToken:', baseToken);

      if (contractAddress.toLowerCase() !== baseToken.toLowerCase()) {
        throw new Error(
          ' This Comet only supports its base asset (e.g., USDC)',
        );
      }
      const suppliedBalance = await comet.balanceOf(from);

      console.log('Supplied Balance:', ethers.formatUnits(suppliedBalance, 6));

      // if (suppliedBalance < amountInWei) {
      //   throw new Error(' Not enough supplied balance');
      // }

      // � Step 3: Withdraw (unstake)
      const tx = await comet.withdraw(
        contractAddress,
        ethers.MaxUint256, // � withdraw ALL
      );
      await tx.wait();

      console.log('✅ Withdraw successful');

      return tx.hash;
    } catch (error) {
      console.log(error);
      throw error;
    }
  },
  getStakingBalance: async (
    {evmProvider, address, contractAddress},
    provider,
  ) => {
    try {
      debugger;
      const cometAddress = getCometAddress(contractAddress);
      const comet = new ethers.Contract(
        cometAddress,
        cometContractABI,
        provider,
      );

      const balance = await comet.balanceOf(address);
      const formatted = ethers.formatUnits(balance, 6);
      return {
        stakingBalance: formatted || '0',
        energyBalance: '0',
        bandwidthBalance: '0',
      };
    } catch (error) {
      console.error('[aaveProvider getStakingBalance] error:', error?.message);
      throw error;
    }
  },
  getEstimateFeeForStaking: async ({
    amount,
    privateKey,
    contractAddress,
    decimals,
    evmProvider,
  }) => {
    try {
      const cometAddress = getCometAddress(contractAddress);
      const wallet = new ethers.Wallet(privateKey);
      const walletSigner = wallet.connect(evmProvider);
      const tokenContract = new ethers.Contract(
        contractAddress,
        erc20,
        walletSigner,
      );
      const amountInWei = parseUnits(amount.toString(), decimals);
      const comet = new ethers.Contract(
        cometAddress,
        cometContractABI,
        walletSigner,
      );
      let estimateGas;
      try {
        // Works when allowance is already set
        estimateGas = await comet.supply.estimateGas(
          contractAddress,
          amountInWei,
        );
      } catch {
        // Allowance not yet set — estimate approve gas + known Compound V3 supply cost
        const approveGas = await tokenContract.approve.estimateGas(
          cometAddress,
          amountInWei,
        );
        // Compound V3 supply consistently costs ~150k-200k gas
        estimateGas = approveGas + 250000n;
      }
      return {estimateGas};
    } catch (e) {
      console.error('Error in compoundProvider getEstimateFeeForStaking', e);
      throw e;
    }
  },
  getEstimateFeeForDeactivateStaking: async ({
    privateKey,
    contractAddress,
    evmProvider,
  }) => {
    try {
      const cometAddress = getCometAddress(contractAddress);
      const wallet = new ethers.Wallet(privateKey);
      const walletSigner = wallet.connect(evmProvider);
      const comet = new ethers.Contract(
        cometAddress,
        cometContractABI,
        walletSigner,
      );
      const estimateGas = await comet.withdraw.estimateGas(
        contractAddress,
        ethers.MaxUint256,
      );
      return {estimateGas};
    } catch (e) {
      console.error(
        'Error in compoundProvider getEstimateFeeForDeactivateStaking',
        e,
      );
      throw e;
    }
  },
  fetchData: async ({
    evmProvider,
    contractAddress,
    walletAddress,
    tokenDecimals,
  }) => {
    try {
      const cometAddress = getCometAddress(contractAddress);
      const comet = new ethers.Contract(
        cometAddress,
        cometContractABI,
        evmProvider,
      );
      const utilization = await comet.getUtilization();
      const supplyRatePerSecond = await comet.getSupplyRate(utilization);
      const secondsPerYear = 365 * 24 * 60 * 60;
      const apy = (
        (parseFloat(supplyRatePerSecond.toString()) / 1e18) *
        secondsPerYear *
        100
      ).toFixed(2);

      let stakedAmount = null;
      let stakedAmountRaw = null;
      if (walletAddress) {
        const balance = await comet.balanceOf(walletAddress);
        stakedAmountRaw = balance.toString();
        stakedAmount = ethers.formatUnits(balance, tokenDecimals);
      }

      return {apy, stakedAmount, stakedAmountRaw};
    } catch (e) {
      console.warn('[compoundProvider] fetchData error:', e);
      return null;
    }
  },
  getRewards: async ({from, evmProvider, contractAddress}) => {
    try {
      const cometAddress = getCometAddress(contractAddress);
      const rewardsContract = new ethers.Contract(
        cometRewardAddress,
        cometContractABI,
        evmProvider,
      );
      const result = await rewardsContract.getRewardOwed(cometAddress, from);
      const rewardToken = result[0];
      const rewardAmount = result[1];
      return {
        token: rewardToken,
        amount: ethers.formatUnits(rewardAmount, 18), // COMP = 18 decimals
      };
    } catch (error) {}
  },
  claimRewards: async ({from, contractAddress, privateKey, evmProvider}) => {
    try {
      const cometAddress = getCometAddress(contractAddress);
      const wallet = new ethers.Wallet(privateKey);
      const walletSigner = wallet.connect(evmProvider);
      const rewardsContract = new ethers.Contract(
        cometRewardAddress,
        cometContractABI,
        walletSigner,
      );
      const tx = await rewardsContract.claim(
        cometAddress,
        from,
        true, // accrue first
      );

      await tx.wait();
      return tx.hash;
    } catch (error) {
      console.log(error);
      throw error;
    }
  },
};

AAVE Staking

Swatantra goswami — Thu, 09 Apr 2026 12:38:24 +0000

import {ethers, formatUnits, parseUnits} from 'ethers';
import erc20 from '../../abis/erc20.json';
import aavePoolABI from '../../abis/aave_pool.json';
import aaveDataProviderABI from '../../abis/aave_data_provider.json';

export const aavePoolContractAddress =
  '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2';
export const aaveDataProviderContractAddress =
  '0x7B4EB56E7CD4b454BA8ff71E4518426369a138a3';

const aaveFetchData = async ({
  evmProvider,
  contractAddress,
  walletAddress,
  tokenDecimals,
  poolContractAddress,
  poolABI,
  dataProviderContractAddress,
  dataProviderABI,
}) => {
  const pool = new ethers.Contract(poolContractAddress, poolABI, evmProvider);
  const reserveData = await pool.getReserveData(contractAddress);
  const liquidityRate = reserveData[2];
  const apy = (parseFloat(formatUnits(liquidityRate, 27)) * 100).toFixed(2);

  let stakedAmount = null;
  let stakedAmountRaw = null;
  if (walletAddress && dataProviderContractAddress && dataProviderABI) {
    const dataProvider = new ethers.Contract(
      dataProviderContractAddress,
      dataProviderABI,
      evmProvider,
    );
    const [aTokenAddress] = await dataProvider.getReserveTokensAddresses(
      contractAddress,
    );
    const aToken = new ethers.Contract(aTokenAddress, erc20, evmProvider);
    const balance = await aToken.balanceOf(walletAddress);
    stakedAmount = formatUnits(balance, tokenDecimals);
    stakedAmountRaw = balance.toString();
  }

  return {apy, stakedAmount, stakedAmountRaw};
};

export const aaveProvider = {
  icon: 'https://cdn-icons-png.flaticon.com/512/17978/17978942.png',
  name: 'Aave',
  apy: '0% APY',
  stakedAmount: '0',
  stakedAmountRaw: null,
  poolContractAddress: aavePoolContractAddress,
  poolABI: aavePoolABI,
  dataProviderContractAddress: aaveDataProviderContractAddress,
  dataProviderABI: aaveDataProviderABI,
  createStaking: async (
    {from, amount, privateKey, contractAddress, decimals, evmProvider},
    provider,
  ) => {
    const wallet = new ethers.Wallet(privateKey);
    const walletSigner = wallet.connect(evmProvider);
    const tokenContract = new ethers.Contract(
      contractAddress,
      erc20,
      walletSigner,
    );
    const amountInWei = parseUnits(amount.toString(), decimals);

    const balance = await tokenContract.balanceOf(from);
    if (balance < amountInWei) {
      throw new Error('Insufficient balance');
    }

    const allowance = await tokenContract.allowance(
      from,
      aavePoolContractAddress,
    );
    if (allowance < amountInWei) {
      const approveTx = await tokenContract.approve(
        aavePoolContractAddress,
        amountInWei,
      );
      await approveTx.wait();
    }

    const pool = new ethers.Contract(
      aavePoolContractAddress,
      aavePoolABI,
      walletSigner,
    );
    const gasLimit = await pool.supply.estimateGas(
      contractAddress,
      amountInWei,
      from,
      0,
    );

    await pool.supply.staticCall(contractAddress, amountInWei, from, 0, {
      gasLimit,
    });

    const tx = await pool.supply(contractAddress, amountInWei, from, 0, {
      gasLimit,
    });
    await tx.wait();

    return tx.hash;
  },
  getEstimateFeeForStaking: async (
    {from, amount, privateKey, contractAddress, decimals, evmProvider},
    provider,
  ) => {
    const wallet = new ethers.Wallet(privateKey);
    const walletSigner = wallet.connect(evmProvider);
    const tokenContract = new ethers.Contract(
      contractAddress,
      erc20,
      walletSigner,
    );
    const amountInWei = parseUnits(amount.toString(), decimals);
    const pool = new ethers.Contract(
      aavePoolContractAddress,
      aavePoolABI,
      walletSigner,
    );
    let estimateGas;
    try {
      // Works when allowance is already set
      estimateGas = await pool.supply.estimateGas(
        contractAddress,
        amountInWei,
        from,
        0,
      );
    } catch {
      // Allowance not yet set — estimate approve gas + known Aave v3 supply cost
      const approveGas = await tokenContract.approve.estimateGas(
        aavePoolContractAddress,
        amountInWei,
      );
      // Aave v3 supply consistently costs 220k-280k gas for USDT/USDC
      estimateGas = approveGas + 300000n;
    }
    return {estimateGas};
  },
  unStaking: async (
    {from, amount, privateKey, contractAddress, evmProvider},
    provider,
  ) => {
    try {
      const wallet = new ethers.Wallet(privateKey);
      const walletSigner = wallet.connect(evmProvider);
      const pool = new ethers.Contract(
        aavePoolContractAddress,
        aavePoolABI,
        walletSigner,
      );

      const gasLimit = await pool.withdraw.estimateGas(
        contractAddress,
        ethers.MaxUint256,
        from,
      );

      await pool.withdraw.staticCall(contractAddress, ethers.MaxUint256, from);

      const tx = await pool.withdraw(contractAddress, ethers.MaxUint256, from, {
        gasLimit,
      });
      await tx.wait();

      return tx.hash;
    } catch (error) {
      console.log(error);
      throw error;
    }
  },
  getStakingBalance: async (
    {evmProvider, address, contractAddress},
    provider,
  ) => {
    try {
      const dataProvider = new ethers.Contract(
        provider.dataProviderContractAddress,
        provider.dataProviderABI,
        evmProvider,
      );
      const [aTokenAddress] = await dataProvider.getReserveTokensAddresses(
        contractAddress,
      );
      const aToken = new ethers.Contract(aTokenAddress, erc20, evmProvider);
      const balance = await aToken.balanceOf(address);
      return {
        stakingBalance: balance.toString() || '0',
        energyBalance: '0',
        bandwidthBalance: '0',
      };
    } catch (error) {
      console.error('[aaveProvider getStakingBalance] error:', error?.message);
      throw error;
    }
  },
  getEstimateFeeForDeactivateStaking: async ({
    from,
    privateKey,
    contractAddress,
    evmProvider,
  }) => {
    try {
      const wallet = new ethers.Wallet(privateKey);
      const walletSigner = wallet.connect(evmProvider);
      const pool = new ethers.Contract(
        aavePoolContractAddress,
        aavePoolABI,
        walletSigner,
      );
      const estimateGas = await pool.withdraw.estimateGas(
        contractAddress,
        ethers.MaxUint256,
        from,
      );
      return {estimateGas};
    } catch (e) {
      console.error('Error in EVMChain getEstimateFeeForDeactivateStaking', e);
      throw e;
    }
  },
  fetchData: async (
    {evmProvider, contractAddress, walletAddress, tokenDecimals},
    provider,
  ) =>
    aaveFetchData({
      evmProvider,
      contractAddress,
      walletAddress,
      tokenDecimals,
      poolContractAddress: provider.poolContractAddress,
      poolABI: provider.poolABI,
      dataProviderContractAddress: provider.dataProviderContractAddress,
      dataProviderABI: provider.dataProviderABI,
    }),
};

XMTP decentralize chatting

Swatantra goswami — Mon, 23 Feb 2026 10:22:32 +0000

import {
  Client,
  PublicIdentity,
  ReplyCodec,
  ConsentRecord,
} from '@xmtp/react-native-sdk';
import {IS_SANDBOX} from 'dok-wallet-blockchain-networks/config/config';
import {ContentTypeCustomReplyCodec} from './xmtpContentReplyType';
import crypto from 'react-native-quick-crypto';
import SensitiveInfo from 'react-native-sensitive-info';
import {Buffer} from 'buffer';
import RNFS from 'react-native-fs';

const XMTP_DB_KEY_STORAGE = 'xmtp_db_encryption_key';
const KEYCHAIN_SERVICE = 'com.dokwallet.xmtp';
const XMTP_ENV = IS_SANDBOX ? 'dev' : 'production';

const getOrCreateDbEncryptionKey = async () => {
  try {
    const stored = await SensitiveInfo.getItem(XMTP_DB_KEY_STORAGE, {
      keychainService: KEYCHAIN_SERVICE,
    });
    if (stored) {
      return Buffer.from(stored, 'hex');
    }
  } catch (e) {
    console.warn('XMTP: failed to read encryption key from storage', e);
  }
  const key = crypto.randomBytes(32);
  try {
    await SensitiveInfo.setItem(XMTP_DB_KEY_STORAGE, key.toString('hex'), {
      keychainService: KEYCHAIN_SERVICE,
    });
  } catch (e) {
    console.warn('XMTP: failed to persist encryption key', e);
  }
  return key;
};

const clearXmtpDatabase = async () => {
  try {
    const items = await RNFS.readDir(RNFS.DocumentDirectoryPath);
    await Promise.all(
      items
        .filter(
          f =>
            f.name.endsWith('.db3') ||
            f.name.endsWith('.db3-shm') ||
            f.name.endsWith('.db3-wal'),
        )
        .map(f => RNFS.unlink(f.path)),
    );
  } catch (e) {
    console.warn('XMTP: failed to delete database files', e);
  }
  try {
    await SensitiveInfo.deleteItem(XMTP_DB_KEY_STORAGE, {
      keychainService: KEYCHAIN_SERVICE,
    });
  } catch (e) {
    console.warn('XMTP: failed to delete stored key', e);
  }
};

export const XMTP = {
  client: null,

  initializeClient: async ({wallet, address}) => {
    try {
      const signer = {
        getIdentifier: async () =>
          new PublicIdentity(wallet.address, 'ETHEREUM'),
        getChainId: () => undefined,
        getBlockNumber: () => undefined,
        signerType: () => 'EOA',
        signMessage: async message => {
          const sig = await wallet.signMessage(message);
          return {signature: Buffer.from(sig.replace('0x', ''), 'hex')};
        },
      };
      if (XMTP.client?.publicIdentity?.identifier !== address?.toLowerCase()) {
        const createClient = async () => {
          const dbEncryptionKey = await getOrCreateDbEncryptionKey();
          return Client.create(signer, {
            env: XMTP_ENV,
            dbEncryptionKey,
            codecs: [new ReplyCodec(), new ContentTypeCustomReplyCodec()],
          });
        };
        try {
          XMTP.client = await createClient();
        } catch (storageError) {
          if (
            storageError?.message?.includes('PRAGMA key') ||
            storageError?.message?.includes('Storage error')
          ) {
            console.warn(
              'XMTP: stale database detected, clearing and retrying',
            );
            await clearXmtpDatabase();
            XMTP.client = await createClient();
          } else {
            throw storageError;
          }
        }
      }
      return XMTP.client;
    } catch (error) {
      console.log('XMTP initializeClient error:', error);
      return null;
    }
  },

  getClient: () => XMTP.client,

  getConversations: async () => {
    try {
      if (!XMTP.client) {
        console.warn('XMTP: Please initialize client first');
        return [];
      }
      await XMTP.client.conversations.sync();
      const conversations = await XMTP.client.conversations.list(
        {lastMessage: true, consentState: true},
        undefined,
        ['allowed', 'unknown'],
      );
      return XMTP.formatConversation(conversations);
    } catch (error) {
      console.log('XMTP getConversations error:', error);
      return [];
    }
  },

  // Static call — no initialized client needed
  checkAccountExists: async ({address}) => {
    try {
      const result = await Client.canMessage(XMTP_ENV, [
        new PublicIdentity(address, 'ETHEREUM'),
      ]);
      return result[address.toLowerCase()] ?? false;
    } catch (error) {
      console.log('XMTP checkAccountExists error:', error);
      return false;
    }
  },

  getMessages: async ({topic, limit = 20, before = null, after = null}) => {
    try {
      if (!XMTP.client) {
        console.warn('XMTP: Please initialize client first');
        return [];
      }
      const conversation =
        await XMTP.client.conversations.findConversationByTopic(topic);
      if (!conversation) {
        return [];
      }
      const messages = await conversation.messages({
        limit,
        ...(before && {beforeNs: before}),
        ...(after && {afterNs: after}),
      });
      return XMTP.formatMessage(messages);
    } catch (error) {
      console.log('XMTP getMessages error:', error);
      return [];
    }
  },

  newConversation: async ({address}) => {
    try {
      if (!XMTP.client) {
        console.warn('XMTP: Please initialize client first');
        return null;
      }
      return await XMTP.client.conversations.findOrCreateDmWithIdentity(
        new PublicIdentity(address, 'ETHEREUM'),
      );
    } catch (error) {
      console.log('XMTP newConversation error:', error);
      return null;
    }
  },

  getConversation: async ({topic}) => {
    try {
      if (!XMTP.client) {
        console.warn('XMTP: Please initialize client first');
        return null;
      }
      let conv = await XMTP.client.conversations.findConversationByTopic(topic);
      if (!conv) {
        // Conversation not in local DB yet — sync from network and retry once
        await XMTP.client.conversations.sync();
        conv = await XMTP.client.conversations.findConversationByTopic(topic);
      }
      return conv ?? null;
    } catch (error) {
      console.log('XMTP getConversation error:', error);
      return null;
    }
  },

  blockConversation: async ({peerAddress}) => {
    try {
      if (!XMTP.client) {
        console.warn('XMTP: Please initialize client first');
        return;
      }
      const inboxId = await XMTP.client.findInboxIdFromIdentity(
        new PublicIdentity(peerAddress, 'ETHEREUM'),
      );
      if (!inboxId) {
        return;
      }
      await XMTP.client.preferences.setConsentState(
        new ConsentRecord(inboxId, 'inbox_id', 'denied'),
      );
    } catch (error) {
      console.log('XMTP blockConversation error:', error);
    }
  },

  unBlockConversation: async ({peerAddress}) => {
    try {
      if (!XMTP.client) {
        console.warn('XMTP: Please initialize client first');
        return;
      }
      const inboxId = await XMTP.client.findInboxIdFromIdentity(
        new PublicIdentity(peerAddress, 'ETHEREUM'),
      );
      if (!inboxId) {
        return;
      }
      await XMTP.client.preferences.setConsentState(
        new ConsentRecord(inboxId, 'inbox_id', 'allowed'),
      );
    } catch (error) {
      console.log('XMTP unBlockConversation error:', error);
    }
  },

  unSubscribeStream: () => {
    if (!XMTP.client) {
      return;
    }
    XMTP.client.conversations.cancelStreamAllMessages();
    XMTP.client.conversations.cancelStream();
  },

  sendMessage: async ({topic, message}) => {
    try {
      if (!XMTP.client) {
        console.warn('XMTP: Please initialize client first');
        return null;
      }
      const conversation =
        await XMTP.client.conversations.findConversationByTopic(topic);
      if (!conversation) {
        return null;
      }
      return await conversation.send(message);
    } catch (error) {
      console.log('XMTP sendMessage error:', error);
      return null;
    }
  },

  formatMessage: messages => {
    const tempMessages = Array.isArray(messages) ? messages : [];
    const finalMessages = [];
    for (const msg of tempMessages) {
      // sentNs is nanoseconds in v5 — convert to ms for Date
      const createdAt = new Date(msg.sentNs / 1_000_000).toISOString();
      const user = {_id: msg.senderInboxId};
      if (msg.contentTypeId === 'xmtp.org/text:1.0') {
        finalMessages.push({
          _id: msg.id,
          text: msg.content(),
          createdAt,
          user,
        });
      } else if (msg.contentTypeId === 'xmtp.org/reply:1.0') {
        const reply = msg.content();
        finalMessages.push({
          _id: msg.id,
          text: reply?.content?.text ?? '',
          reference: reply?.reference,
          createdAt,
          user,
        });
      } else if (msg.contentTypeId === 'com.dok.wallet/customReply:1.1') {
        const customReply = msg.content();
        finalMessages.push({
          _id: msg.id,
          text: customReply?.message ?? '',
          reference: customReply?.repliedMessageId,
          repliedMessage: customReply?.repliedMessage,
          repliedUserId: customReply?.senderAddress,
          createdAt,
          user,
        });
      }
    }
    return finalMessages;
  },

  formatConversation: async conversations => {
    const tempConversations = Array.isArray(conversations) ? conversations : [];
    return Promise.all(
      tempConversations.map(async conv => {
        const peerInboxId = conv.peerInboxId
          ? await conv.peerInboxId()
          : undefined;
        let peerAddress;
        if (peerInboxId && XMTP.client) {
          try {
            const inboxStates = await XMTP.client.inboxStates(true, [
              peerInboxId,
            ]);
            peerAddress = inboxStates?.[0]?.identities?.[0]?.identifier;
          } catch (e) {
            console.warn('XMTP: failed to resolve peer address', e);
          }
        }

        return {
          topic: conv.topic,
          peerInboxId,
          peerAddress,
          createdAt: new Date(conv.createdAt).toISOString(),
          version: conv.version,
          clientAddress: XMTP.client?.publicIdentity?.identifier,
          consentState: conv.state,
        };
      }),
    );
  },
};

Important React Native Commands

Swatantra goswami — Tue, 27 Jan 2026 05:29:11 +0000

List of Simulators

xcrun xctrace list devices

Open Simulator from terminal

xcrun simctl boot "iPhone 15 Pro Max"

Important React Native Commands

Swatantra goswami — Tue, 27 Jan 2026 05:29:11 +0000

List of Simulators

xcrun xctrace list devices

Open Simulator from terminal

xcrun simctl boot "iPhone 15 Pro Max"

BREEZ SDK NODELESS INTEGRATION in WEB

Swatantra goswami — Mon, 26 Jan 2026 11:30:47 +0000

import init, {
    defaultConfig,
    SdkBuilder,
} from "@breeztech/breez-sdk-spark/web";
import { config, IS_SANDBOX } from 'dok-wallet-blockchain-networks/config/config';

class JsLogger {
    log = (logEntry) => {
        console.log(
            `[${new Date().toISOString()} ${logEntry.level}]: ${logEntry.line}`
        );
    };
}

class JsEventListener {
    constructor(callback) {
        this.callback = callback;
    }

    onEvent = event => {
        if (this.callback) {
            this.callback(event);
        }
    };
}


function decimalStringToBigInt(value, decimals) {
    if (!/^\d+(\.\d+)?$/.test(value)) {
        throw new Error('Invalid decimal string');
    }

    const [intPart, fracPart = ''] = value.split('.');
    const paddedFrac = (fracPart + '0'.repeat(decimals)).slice(0, decimals);

    return BigInt(intPart + paddedFrac);
}

let sdkInstance = null;
let connectingPromise = null;
let prepareSendResponse;
const sdkMap = new Map();

const commonConnectSdk = async mnemonic => {
    try {

        // Initialise the WebAssembly module
        await init();
        // "mainnet" | "regtest";
        const network = IS_SANDBOX ? "regtest" : "mainnet";
        console.log("network:", network)
        // Connect using the config
        let config = defaultConfig(network);
        config.apiKey = process.env.BREEZ_API_KEY;

        let sdkBuilder = SdkBuilder.new(config, {
            type: "mnemonic",
            mnemonic: mnemonic,
        });

        sdkBuilder = await sdkBuilder.withDefaultStorage("./.data");

        sdkInstance = await sdkBuilder.build();

        // await sdkInstance.addEventListener(eventListener);
        sdkMap.set(mnemonic, sdkInstance);
        console.log('✅ Breez SDK connected');
        return sdkInstance;
    } catch (err) {
        console.error('❌ Connection error:', err);
        sdkInstance = null;
        connectingPromise = null;
        throw err;
    }
};

async function connectToSdk(phrase) {
    let mnemonic = phrase;
    console.log("sdkMap:", sdkMap)
    if (sdkInstance) {
        if (sdkMap.has(mnemonic)) {
            console.log('♻️ Reusing SDK');
            return sdkMap.get(mnemonic);
        } else {
            // Initialize sdkInstance for the new mnemonic
            if (!mnemonic) return sdkInstance;
            connectingPromise = commonConnectSdk(mnemonic);
            return connectingPromise;
        }
    }

    if (connectingPromise) {
        return connectingPromise;
    }

    connectingPromise = commonConnectSdk(mnemonic);

    return connectingPromise;
}

async function prepareAndSendPayment(phrase, paymentRequest, amount) {
    try {
        const sdk = await connectToSdk(phrase);
        if (!sdk || !paymentRequest) {
            Alert.alert('Error', 'SDK not connected or no payment request');
            return;
        }
        const prepareResponse = await sdk.prepareSendPayment({
            paymentRequest,
            amount: decimalStringToBigInt(amount, 8),
        });
        console.log("prepareResponse:", prepareResponse)
        prepareSendResponse = prepareResponse;
        if (prepareResponse.paymentMethod.type ===  "bitcoinAddress") {
            const lightningFee =
                prepareResponse.paymentMethod.lightningFeeSats;
            const sparkFee =
                prepareResponse.paymentMethod.sparkTransferFeeSats;

            return {
                lightningFee: lightningFee,
                sparkFee: sparkFee,
            };
        }
        if (prepareResponse.paymentMethod?.type === "sparkAddress") {
            const feeSats = prepareResponse.paymentMethod.fee;
            return {
                lightningFee: feeSats,
                sparkFee: '',
            };
        }
        return {};
    } catch (err) {
        console.error('Error preparing payment:', err);
        Alert.alert('Prepare Error', err.message);
    }
}

function satoshiToBtc(sats) {
    if (sats === null || sats === undefined) return 0;

    // Handle BigInt or number or string safely
    const satsNumber = typeof sats === 'bigint' ? Number(sats) : Number(sats);

    return satsNumber / 100_000_000;
}

export const getLightningBalance = async (phrase) => {
    const sdk = await connectToSdk(phrase)
    try {
        const sdk = await connectToSdk(phrase);
        const obj1 = Object.fromEntries(sdkMap);
        const info = await sdk.getInfo({});
        return info.balanceSats;
    } catch (error) {
        console.log(error);
    }
}

export const isLightningAddressValid = async (address, phrase) => {
    try {
        const sdk = await connectToSdk(phrase);
        if (!sdk) {
            Alert.alert('Error', 'SDK not connected or no payment request');
            return;
        }
        const input = await sdk.parse(address);
        if (input.type ===  "bitcoinAddress") {
            return false;
        } else if (input.type === "bolt11Invoice") {
            return true;
        } else if (input.type === "sparkAddress") {
            return true;
        }
        return false;
    } catch (error) {
        console.log(error)
        return false;
    }
}

export const generateLightningInvoiceViaBolt11 = async (phrase) => {
    try {
        const sdk = await connectToSdk(phrase);
        if (!sdk) {
            Alert.alert('Error', 'SDK not connected');
            return;
        }
        const response = await sdk.receivePayment({
            paymentMethod: { type: "bolt11Invoice", description: "Dokwallet Invoice" },

        });
        return {
            address: response.paymentRequest,
            receiveFeeSats: response.fee,
        };
    } catch (error) {
        console.error('Error generating invoice:', error);
        Alert.alert('Invoice Error', error.message);
    }
}

export const generateLightningSparkAddress = async (phrase) => {
    try {
        const sdk = await connectToSdk(phrase);
        console.log("sdk:", sdk)
        if (!sdk) {
            console.error('Error', 'SDK not connected');
            return;
        }
        const response = await sdk.receivePayment({
            paymentMethod: { type: 'sparkAddress' },
        });
        console.log("response:", response)
        return {
            address: response.paymentRequest,
            receiveFeeSats: response.fee,
        };
    } catch (error) {
        console.error('Error generating invoice:', error);
    }
}

export const generateLightningInvoiceViaBitcoinAddress = async (phrase) => {
    try {
        const sdk = await connectToSdk(phrase);
        if (!sdk) {
            Alert.alert('Error', 'SDK not connected');
            return;
        }
        const response = await sdk.receivePayment({
            paymentMethod: { type: "bitcoinAddress" },
        });

        return {
            address: response.paymentRequest,
            receiveFeeSats: response.fee,
        };
    } catch (err) {
        console.error('Error generating invoice:', err);
        Alert.alert('Invoice Error', err.message);
    }
}
// sparkrt1pgss833snj2n4plhav04s58zxhc2ury29dhcpe4tehcx80rgc5kypfr9xzrhgn
export const prepareLightning = async (phrase, toAddress, amount) => {
    try {
        const { lightningFee } = await prepareAndSendPayment(phrase, toAddress, amount);
        const fee = satoshiToBtc(lightningFee);
        console.log('fee:', fee);
        return {
            fee: fee,
            estimateGas: 0,
            feesOptions: [],
        };
    } catch (error) {
        console.error('Error in bitcoin gas fee', error);
        throw error;
    }
}

export const sendLightning = async (phrase) => {
    try {
        const sdk = await connectToSdk(phrase);
        if (!sdk || !prepareSendResponse) {
           console.log('Error', 'SDK not connected or no payment request');
            return;
        }

        // Send the token payment
        const sendResponse = await sdk.sendPayment({
            prepareResponse: prepareSendResponse,
            options: undefined,
            idempotencyKey: undefined,
        });
        console.log("sendResponse:", sendResponse)
        const payment = sendResponse.payment;
        return payment.id;
    } catch (error) {
        console.error('Error in bitcoin gas fee', error);
        throw error;
    }
}

export const waitForLightningConfirmation = async (phrase) => {
    const sdk = await connectToSdk(phrase);

    if (!sdk) {
       console.log('Error', 'SDK not connected');
        return;
    }

    return new Promise(async (resolve, reject) => {
        let listenerId = null;
        let timeoutId = null;
        let resolved = false;

        try {
            const eventListener = new JsEventListener(async event => {
                console.log('event:', event);

                if (resolved) return;

               if (event.type === 'PaymentSucceeded' || event.type === 'synced') {
                    resolved = true;

                    // � cleanup
                    if (listenerId !== null) {
                        sdk.removeEventListener(listenerId);
                    }
                    if (timeoutId) {
                        clearTimeout(timeoutId);
                    }

                    resolve(true);
                }
            });

            listenerId = await sdk.addEventListener(eventListener);
            console.log('Event listener registered:', listenerId);

            // ⏱️ 90 seconds timeout
            timeoutId = setTimeout(() => {
                if (resolved) return;

                resolved = true;

                console.log('⏱️ Payment confirmation timeout (90s)');

                // � cleanup
                if (listenerId !== null) {
                    sdk.removeEventListener(listenerId);
                }

                resolve('pending');
            }, 90_000); // 90 seconds
        } catch (error) {
            console.error('Error in waitForConfirmation:', error);

            // � cleanup
            if (listenerId !== null) {
                sdk.removeEventListener(listenerId);
            }
            if (timeoutId) {
                clearTimeout(timeoutId);
            }

            reject(error);
        }
    });
}

export const getLightningTransactions = async (phrase) => {
    try {
        const sdk = await connectToSdk(phrase);
        if (!sdk) return;

        const response = await sdk.listPayments({
            offset: undefined,
            limit: 20,
        });
        const transactions = response.payments;
        console.log('transactions:', transactions);
        if (Array.isArray(transactions)) {
            return transactions.map(item => {
                const txHash = item?.details.inner?.paymentHash || item?.id || 'N/A';
                return {
                    amount: item.amount,
                    link: txHash?.substring(0, 13) + '...',
                    url: `${config.BITCOIN_LIGHTNING_URL}/tx/${txHash}`,
                    status: item?.status !== "completed" ? 'Pending' : 'SUCCESS',
                    date: Number(item?.timestamp) * 1000,
                    from: item?.details.inner?.preimage,
                    to: item?.details.inner?.destinationPubKey,
                    totalCourse: '0$',
                    paymentType: item.paymentType,
                };
            });
        }
        return [];
    } catch (error) {
        console.error(
            `error getting transactions for bitcoin lightning ${error}`,
        );
        return [];
    }
}

Bitcoin lightning network

Swatantra goswami — Tue, 06 Jan 2026 10:41:10 +0000

We will use https://breez.technology/sdk/ SDK for lightning network
here is the documentation of that https://sdk-doc-spark.breez.technology/guide/install.html

NOTE Conversion rate

🔹 1 BTC = 100,000,000 satoshis // 10 cr ( 1 cr has 7 zeros)
🔹 10,000 satoshis = 0.0001 BTC
🔹 USD value = 0.0001 × current BTC price in USD

import {
  SafeAreaView,
  Text,
  TouchableOpacity,
  View,
  TextInput,
  ScrollView,
  StyleSheet,
  Alert,
} from 'react-native';
import {
  connect,
  defaultConfig,
  Network,
  Seed,
  ReceivePaymentMethod,
  SendPaymentMethod,
} from '@breeztech/breez-sdk-spark-react-native';
import {useState, useEffect} from 'react';
import { DocumentDirectoryPath } from 'react-native-fs';

// Event Listener Class
class JsEventListener {
  constructor(callback) {
    this.callback = callback;
  }

  onEvent = event => {
    console.log(`Received event: ${JSON.stringify(event)}`);
    if (this.callback) {
      this.callback(event);
    }
  };
}

export default function BreezSpark() {
   const [sdk, setSdk] = useState(null);
  const [balance, setBalance] = useState(null);
  const [events, setEvents] = useState([]);
  const [listenerId, setListenerId] = useState(null);
  const [payments, setPayments] = useState([]);

  // For receiving payments
  const [invoiceDescription, setInvoiceDescription] = useState('');
  const [invoiceAmount, setInvoiceAmount] = useState('');
  const [generatedInvoice, setGeneratedInvoice] = useState('');
  const [receiveFeeSats, setReceiveFeeSats] = useState(null);

  // For sending payments
  const [paymentRequest, setPaymentRequest] = useState('');
  const [sendAmount, setSendAmount] = useState('');
  const [preparedPayment, setPreparedPayment] = useState(null);

  async function connectToSdk() {
    try {
      const mnemonic = ''; // 9901 sats
      // const mnemonic = ''; //    10001
      let config = defaultConfig(Network.Regtest);
      config.apiKey = '';

      const baseDir = DocumentDirectoryPath.replace('file://', '');
      const workingDir = `${baseDir}breezSdkSpark`;

    //   const directoryPath = await getOrCreateDirectory('testing', workingDir);

      console.log('API Key configured:', !!config.apiKey);

      const seed = new Seed.Mnemonic({mnemonic});
      const connectedSdk = await connect({
        config,
        seed,
        storageDir: workingDir,
      });

      setSdk(connectedSdk);
      console.log('✅ Connected successfully!');

      // Start listening to events
      setupEventListener(connectedSdk);

      // Get initial balance
      await fetchBalance(connectedSdk);

      // Load payment history
      await fetchPayments(connectedSdk);
    } catch (err) {
      console.error('❌ Connection error:', err);
      Alert.alert('Connection Error', err.message);
    }
  }

  function setupEventListener(sdkInstance) {
    const eventListener = new JsEventListener(event => {
      setEvents(prev =>
        [{event, timestamp: new Date().toISOString()}, ...prev].slice(0, 10),
      );

      // Refresh balance on payment events
      if (
        event.type === 'paymentSucceeded' ||
        event.type === 'paymentReceived'
      ) {
        fetchBalance(sdkInstance);
        fetchPayments(sdkInstance);
      }
    });

    const id = sdkInstance.addEventListener(eventListener);
    setListenerId(id);
    console.log('Event listener registered:', id);
  }

  async function fetchBalance(sdkInstance = sdk) {
    if (!sdkInstance) return;

    try {
      const info = await sdkInstance.getInfo({});
      setBalance(info.balanceSats);
      console.log('Balance:', info.balanceSats);
    } catch (err) {
      console.error('Error fetching balance:', err);
      Alert.alert('Balance Error', err.message);
    }
  }

  async function fetchPayments(sdkInstance = sdk) {
    if (!sdkInstance) return;

    try {
      const response = await sdkInstance.listPayments({
        offset: undefined,
        limit: 20,
      });
      console.log("response=>",response)
      setPayments(response.payments);
      console.log('Payments loaded:', response.payments.length);
    } catch (err) {
      console.error('Error fetching payments:', err);
    }
  }

  async function generateInvoice() {
    if (!sdk) {
      Alert.alert('Error', 'SDK not connected');
      return;
    }

    try {
      const amountSats = invoiceAmount ? BigInt(invoiceAmount) : undefined;

      // NOTE vai invoice
      const response = await sdk.receivePayment({
        paymentMethod: new ReceivePaymentMethod.Bolt11Invoice({
          description: invoiceDescription || 'Payment',
          amountSats,
        }),
      });
      console.log("response=>", response)
      // NOTE vai btc address ub regtest
      // const response = await sdk.receivePayment({
      //   paymentMethod: new ReceivePaymentMethod.BitcoinAddress()
      // })

      console.log(`Payment Request: ${paymentRequest}`)
      setGeneratedInvoice(response.paymentRequest);
      setReceiveFeeSats(response.fee);
      console.log('Invoice generated:', response.paymentRequest);
      console.log('Receive fees:', response.fee);

      Alert.alert('Invoice Generated', 'Check the invoice field below');
    } catch (err) {
      console.error('Error generating invoice:', err);
      Alert.alert('Invoice Error', err.message);
    }
  }

  async function preparePayment() {
    if (!sdk || !paymentRequest) {
      Alert.alert('Error', 'SDK not connected or no payment request');
      return;
    }

    try {
      const amountSats = sendAmount ? BigInt(sendAmount) : undefined;

      const prepareResponse = await sdk.prepareSendPayment({
        paymentRequest,
        amountSats,
      });

      setPreparedPayment(prepareResponse);

      if (
        prepareResponse.paymentMethod instanceof SendPaymentMethod.Bolt11Invoice
      ) {
        const lightningFee =
          prepareResponse.paymentMethod.inner.lightningFeeSats;
        const sparkFee =
          prepareResponse.paymentMethod.inner.sparkTransferFeeSats;

        Alert.alert(
          'Payment Prepared',
          `Lightning Fees: ${lightningFee} sats\nSpark Fees: ${
            sparkFee || 'N/A'
          } sats`,
          [
            {text: 'Cancel', style: 'cancel'},
            {text: 'Send Payment', onPress: () => sendPayment(prepareResponse)},
          ],
        );
      }
    } catch (err) {
      console.error('Error preparing payment:', err);
      Alert.alert('Prepare Error', err.message);
    }
  }

  async function sendPayment(prepareResponse) {
    if (!sdk) return;

    try {
      const response = await sdk.sendPayment({
        prepareResponse,
      });

      console.log('Payment sent:', response);
      Alert.alert('Success', 'Payment sent successfully!');

      // Clear form and refresh
      setPaymentRequest('');
      setSendAmount('');
      setPreparedPayment(null);
      await fetchBalance();
      await fetchPayments();
    } catch (err) {
      console.error('Error sending payment:', err);
      Alert.alert('Send Error', err.message);
    }
  }

  useEffect(() => {
    return () => {
      if (sdk && listenerId) {
        sdk.removeEventListener(listenerId);
      }
    };
  }, [sdk, listenerId]);

  console.log("receiveFeeSats=>", receiveFeeSats)
  return (
    <SafeAreaView style={styles.container}>
      <ScrollView style={styles.scrollView}>
        {/* Connection Section */}
        <View style={styles.section}>
          <TouchableOpacity
            onPress={connectToSdk}
            style={[styles.button, sdk && styles.buttonConnected]}
            disabled={!!sdk}>
            <Text style={styles.buttonText}>
              {sdk ? '✅ Connected' : 'Connect to Breez SDK'}
            </Text>
          </TouchableOpacity>

          {balance !== null && (
            <View style={styles.balanceContainer}>
              <Text style={styles.balanceLabel}>Balance:</Text>
              <Text style={styles.balanceAmount}>
                {balance.toString()} sats
              </Text>
              <TouchableOpacity
                onPress={() => fetchBalance()}
                style={styles.refreshButton}>
                <Text>🔄 Refresh</Text>
              </TouchableOpacity>
            </View>
          )}
        </View>

        {/* Receive Payment Section */}
        {sdk && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>Receive Payment</Text>
            <TextInput
              style={styles.input}
              placeholder="Invoice description"
              placeholderTextColor="#9CA3AF" 
              value={invoiceDescription}
              onChangeText={setInvoiceDescription}
            />
            <TextInput
              style={styles.input}
              placeholder="Amount (sats) - optional"
              placeholderTextColor="#9CA3AF" 
              value={invoiceAmount}
              onChangeText={setInvoiceAmount}
              keyboardType="number-pad"
            />
            <TouchableOpacity onPress={generateInvoice} style={styles.button}>
              <Text style={styles.buttonText}>Generate Invoice</Text>
            </TouchableOpacity>

            {generatedInvoice && (
              <View style={styles.invoiceContainer}>
                <Text style={styles.label}>Invoice:</Text>
                <Text style={styles.invoice} selectable>
                  {generatedInvoice}
                </Text>
                {/* {receiveFeeSats !== null && (
                  <Text style={styles.feeText}>
                    Fee: {receiveFeeSats.toString()} sats
                  </Text>
                )} */}
              </View>
            )}
          </View>
        )}

        {/* Send Payment Section */}
        {sdk && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>Send Payment</Text>
            <TextInput
              style={[styles.input, styles.textArea]}
              placeholder="Paste Lightning invoice (bolt11)"
              placeholderTextColor="#9CA3AF" 
              value={paymentRequest}
              onChangeText={setPaymentRequest}
              multiline
            />
            <TextInput
              style={styles.input}
              placeholder="Amount (sats) - optional"
              placeholderTextColor="#9CA3AF" // gray, change as needed
              value={sendAmount}
              onChangeText={setSendAmount}
              keyboardType="number-pad"

            />
            <TouchableOpacity onPress={preparePayment} style={styles.button}>
              <Text style={styles.buttonText}>Prepare & Send Payment</Text>
            </TouchableOpacity>
          </View>
        )}

        {/* Events Section */}
        {events.length > 0 && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>
              Recent Events ({events.length})
            </Text>
            {events.map((item, idx) => (
              <View key={idx} style={styles.eventItem}>
                <Text style={styles.eventTime}>{item.timestamp}</Text>
                <Text style={styles.eventText}>
                  {JSON.stringify(item.event, null, 2)}
                </Text>
              </View>
            ))}
          </View>
        )}

        {/* Payments History */}
        {payments.length > 0 && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>
              Payment History ({payments.length})
            </Text>
            {payments.slice(0, 5).map((payment, idx) => (
              <View key={idx} style={styles.paymentItem}>
                <Text style={styles.paymentAmount}>
                  {payment.amountSats?.toString() || 'N/A'} sats
                </Text>
                <Text style={styles.paymentStatus}>{payment.status}</Text>
              </View>
            ))}
          </View>
        )}
      </ScrollView>
    </SafeAreaView>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#f5f5f5',
  },
  scrollView: {
    flex: 1,
    padding: 16,
  },
  section: {
    backgroundColor: 'white',
    borderRadius: 12,
    padding: 16,
    marginBottom: 16,
    shadowColor: '#000',
    shadowOffset: {width: 0, height: 2},
    shadowOpacity: 0.1,
    shadowRadius: 4,
    elevation: 3,
  },
  sectionTitle: {
    fontSize: 18,
    fontWeight: 'bold',
    marginBottom: 12,
    color: '#333',
  },
  button: {
    backgroundColor: '#007AFF',
    padding: 16,
    borderRadius: 8,
    alignItems: 'center',
  },
  buttonConnected: {
    backgroundColor: '#34C759',
  },
  buttonText: {
    color: 'white',
    fontSize: 16,
    fontWeight: '600',
  },
  balanceContainer: {
    marginTop: 16,
    padding: 16,
    backgroundColor: '#f8f8f8',
    borderRadius: 8,
    flexDirection: 'row',
    alignItems: 'center',
    justifyContent: 'space-between',
  },
  balanceLabel: {
    fontSize: 16,
    color: '#666',
  },
  balanceAmount: {
    fontSize: 20,
    fontWeight: 'bold',
    color: '#007AFF',
    flex: 1,
    marginLeft: 8,
  },
  refreshButton: {
    padding: 8,
  },
  input: {
    borderWidth: 1,
    borderColor: '#ddd',
    borderRadius: 8,
    padding: 12,
    marginBottom: 12,
    fontSize: 16,
  },
  textArea: {
    height: 80,
    textAlignVertical: 'top',
  },
  invoiceContainer: {
    marginTop: 12,
    padding: 12,
    backgroundColor: '#f8f8f8',
    borderRadius: 8,
  },
  label: {
    fontSize: 14,
    fontWeight: '600',
    marginBottom: 8,
    color: '#666',
  },
  invoice: {
    fontSize: 12,
    color: '#333',
    fontFamily: 'monospace',
  },
  feeText: {
    marginTop: 8,
    fontSize: 14,
    color: '#666',
  },
  eventItem: {
    padding: 12,
    backgroundColor: '#f8f8f8',
    borderRadius: 8,
    marginBottom: 8,
  },
  eventTime: {
    fontSize: 12,
    color: '#666',
    marginBottom: 4,
  },
  eventText: {
    fontSize: 12,
    fontFamily: 'monospace',
    color: '#333',
  },
  paymentItem: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    padding: 12,
    backgroundColor: '#f8f8f8',
    borderRadius: 8,
    marginBottom: 8,
  },
  paymentAmount: {
    fontSize: 16,
    fontWeight: '600',
    color: '#333',
  },
  paymentStatus: {
    fontSize: 14,
    color: '#666',
  },
});

Use Two Screen

import {
  SafeAreaView,
  Text,
  TouchableOpacity,
  View,
  TextInput,
  ScrollView,
  StyleSheet,
  Alert,
} from 'react-native';
import {
  connect,
  defaultConfig,
  Network,
  Seed,
  ReceivePaymentMethod,
  SendPaymentMethod,
} from '@breeztech/breez-sdk-spark-react-native';
import React, {useState, useEffect} from 'react';
import {DocumentDirectoryPath} from 'react-native-fs';

import {SceneMap, TabBar, TabView} from 'react-native-tab-view';
import {SCREEN_WIDTH} from '@gorhom/bottom-sheet';

const ROUTES = [
  {key: 'add_coins', title: 'Coins '},
  {key: 'add_coins_group', title: 'Coins Group '},
];

// Event Listener Class
class JsEventListener {
  constructor(callback) {
    this.callback = callback;
  }

  onEvent = event => {
    console.log(`Received event: ${JSON.stringify(event)}`);
    if (this.callback) {
      this.callback(event);
    }
  };
}

const RenderTabBar = props => {
  const {styles} = props;

  // Create options for each route
  const tabOptions = ROUTES.reduce((acc, route) => {
    acc[route.key] = {
      label: ({focused}) => (
        <Text style={[styles.tabLabel, focused && styles.tabLabelFocused]}>
          {route.title}
        </Text>
      ),
    };
    return acc;
  }, {});

  return (
    <TabBar
      {...props}
      indicatorStyle={styles.indicator}
      style={styles.tabBar}
      options={tabOptions}
    />
  );
};

function BreezSpark1() {
  const [sdk, setSdk] = useState(null);
  const [balance, setBalance] = useState(null);
  const [events, setEvents] = useState([]);
  const [listenerId, setListenerId] = useState(null);
  const [payments, setPayments] = useState([]);

  // For receiving payments
  const [invoiceDescription, setInvoiceDescription] = useState('');
  const [invoiceAmount, setInvoiceAmount] = useState('');
  const [generatedInvoice, setGeneratedInvoice] = useState('');
  const [receiveFeeSats, setReceiveFeeSats] = useState(null);

  // For sending payments
  const [paymentRequest, setPaymentRequest] = useState('');
  const [sendAmount, setSendAmount] = useState('');
  const [preparedPayment, setPreparedPayment] = useState(null);

  async function connectToSdk() {
    try {
      const mnemonic = ''; // 9901 sats
      // const mnemonic = ''; //    10001
      let config = defaultConfig(Network.Regtest);
      config.apiKey = '';

      const baseDir = DocumentDirectoryPath.replace('file://', '');
      const workingDir = `${baseDir}breezSdkSpark`;

      //   const directoryPath = await getOrCreateDirectory('testing', workingDir);

      console.log('API Key configured:', !!config.apiKey);

      const seed = new Seed.Mnemonic({mnemonic});
      const connectedSdk = await connect({
        config,
        seed,
        storageDir: workingDir,
      });

      setSdk(connectedSdk);
      console.log('✅ Connected successfully!');

      // Start listening to events
      setupEventListener(connectedSdk);

      // Get initial balance
      await fetchBalance(connectedSdk);

      // Load payment history
      await fetchPayments(connectedSdk);
    } catch (err) {
      console.error('❌ Connection error:', err);
      Alert.alert('Connection Error', err.message);
    }
  }

  function setupEventListener(sdkInstance) {
    const eventListener = new JsEventListener(event => {
      setEvents(prev =>
        [{event, timestamp: new Date().toISOString()}, ...prev].slice(0, 10),
      );

      // Refresh balance on payment events
      if (
        event.type === 'paymentSucceeded' ||
        event.type === 'paymentReceived'
      ) {
        fetchBalance(sdkInstance);
        fetchPayments(sdkInstance);
      }
    });

    const id = sdkInstance.addEventListener(eventListener);
    setListenerId(id);
    console.log('Event listener registered:', id);
  }

  async function fetchBalance(sdkInstance = sdk) {
    if (!sdkInstance) return;

    try {
      const info = await sdkInstance.getInfo({});
      setBalance(info.balanceSats);
      console.log('Balance:', info.balanceSats);
    } catch (err) {
      console.error('Error fetching balance:', err);
      Alert.alert('Balance Error', err.message);
    }
  }

  async function fetchPayments(sdkInstance = sdk) {
    if (!sdkInstance) return;

    try {
      const response = await sdkInstance.listPayments({
        offset: undefined,
        limit: 20,
      });
      console.log('response=>', response);
      setPayments(response.payments);
      console.log('Payments loaded:', response.payments.length);
    } catch (err) {
      console.error('Error fetching payments:', err);
    }
  }

  async function generateInvoice() {
    if (!sdk) {
      Alert.alert('Error', 'SDK not connected');
      return;
    }

    try {
      const amountSats = invoiceAmount ? BigInt(invoiceAmount) : undefined;

      // NOTE vai invoice
      const response = await sdk.receivePayment({
        paymentMethod: new ReceivePaymentMethod.Bolt11Invoice({
          description: invoiceDescription || 'Payment',
          amountSats,
        }),
      });
      console.log('response=>', response);
      // NOTE vai btc address ub regtest
      // const response = await sdk.receivePayment({
      //   paymentMethod: new ReceivePaymentMethod.BitcoinAddress()
      // })

      console.log(`Payment Request: ${paymentRequest}`);
      setGeneratedInvoice(response.paymentRequest);
      setReceiveFeeSats(response.fee);
      console.log('Invoice generated:', response.paymentRequest);
      console.log('Receive fees:', response.fee);

      Alert.alert('Invoice Generated', 'Check the invoice field below');
    } catch (err) {
      console.error('Error generating invoice:', err);
      Alert.alert('Invoice Error', err.message);
    }
  }

  async function preparePayment() {
    if (!sdk || !paymentRequest) {
      Alert.alert('Error', 'SDK not connected or no payment request');
      return;
    }

    try {
      const amountSats = sendAmount ? BigInt(sendAmount) : undefined;
      console.log('paymentRequest: ', paymentRequest);
      console.log('amountSats: ', amountSats);
      const prepareResponse = await sdk.prepareSendPayment({
        paymentRequest,
        amountSats,
      });

      setPreparedPayment(prepareResponse);
      console.log('prepareResponse=>', prepareResponse);
      if (
        prepareResponse.paymentMethod instanceof SendPaymentMethod.Bolt11Invoice
      ) {
        const lightningFee =
          prepareResponse.paymentMethod.inner.lightningFeeSats;
        const sparkFee =
          prepareResponse.paymentMethod.inner.sparkTransferFeeSats;
        console.log('lightningFee=:', lightningFee);
        console.log('sparkFee=:', sparkFee);
        Alert.alert(
          'Payment Prepared',
          `Lightning Fees: ${lightningFee} sats\nSpark Fees: ${
            sparkFee || 'N/A'
          } sats`,
          [
            {text: 'Cancel', style: 'cancel'},
            {text: 'Send Payment', onPress: () => sendPayment(prepareResponse)},
          ],
        );
      }
    } catch (err) {
      console.error('Error preparing payment:', err);
      Alert.alert('Prepare Error', err.message);
    }
  }

  async function sendPayment(prepareResponse) {
    if (!sdk) return;

    try {
      const response = await sdk.sendPayment({
        prepareResponse,
      });

      console.log('Payment sent:', response);
      Alert.alert('Success', 'Payment sent successfully!');

      // Clear form and refresh
      setPaymentRequest('');
      setSendAmount('');
      setPreparedPayment(null);
      await fetchBalance();
      await fetchPayments();
    } catch (err) {
      console.error('Error sending payment:', err);
      Alert.alert('Send Error', err.message);
    }
  }

  useEffect(() => {
    return () => {
      if (sdk && listenerId) {
        sdk.removeEventListener(listenerId);
      }
    };
  }, [sdk, listenerId]);

  console.log('receiveFeeSats=>', receiveFeeSats);
  return (
    <SafeAreaView style={styles.container}>
      <ScrollView style={styles.scrollView}>
        {/* Connection Section */}
        <View style={styles.section}>
          <TouchableOpacity
            onPress={connectToSdk}
            style={[styles.button, sdk && styles.buttonConnected]}
            disabled={!!sdk}>
            <Text style={styles.buttonText}>
              {sdk ? '✅ Connected' : 'Connect to Breez SDK with mnemonic'}
              {'\n'}
              {'\n'}
              {
                'mix budget despair always cancel actress inspire curtain large grape thing snack'
              }
            </Text>
          </TouchableOpacity>

          {balance !== null && (
            <View style={styles.balanceContainer}>
              <Text style={styles.balanceLabel}>Balance:</Text>
              <Text style={styles.balanceAmount}>
                {balance.toString()} sats
              </Text>
              <TouchableOpacity
                onPress={() => fetchBalance()}
                style={styles.refreshButton}>
                <Text>🔄 Refresh</Text>
              </TouchableOpacity>
            </View>
          )}
        </View>

        {/* Receive Payment Section */}
        {sdk && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>Receive Payment</Text>
            <TextInput
              style={styles.input}
              placeholder="Invoice description"
              placeholderTextColor="#9CA3AF"
              value={invoiceDescription}
              onChangeText={setInvoiceDescription}
            />
            <TextInput
              style={styles.input}
              placeholder="Amount (sats) - optional"
              placeholderTextColor="#9CA3AF"
              value={invoiceAmount}
              onChangeText={setInvoiceAmount}
              keyboardType="number-pad"
            />
            <TouchableOpacity onPress={generateInvoice} style={styles.button}>
              <Text style={styles.buttonText}>Generate Invoice</Text>
            </TouchableOpacity>

            {generatedInvoice && (
              <View style={styles.invoiceContainer}>
                <Text style={styles.label}>Invoice:</Text>
                <Text style={styles.invoice} selectable>
                  {generatedInvoice}
                </Text>
                {/* {receiveFeeSats !== null && (
                  <Text style={styles.feeText}>
                    Fee: {receiveFeeSats.toString()} sats
                  </Text>
                )} */}
              </View>
            )}
          </View>
        )}

        {/* Send Payment Section */}
        {sdk && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>Send Payment</Text>
            <TextInput
              style={[styles.input, styles.textArea]}
              placeholder="Paste Lightning invoice (bolt11)"
              placeholderTextColor="#9CA3AF"
              value={paymentRequest}
              onChangeText={setPaymentRequest}
              multiline
            />
            <TextInput
              style={styles.input}
              placeholder="Amount (sats) - optional"
              placeholderTextColor="#9CA3AF" // gray, change as needed
              value={sendAmount}
              onChangeText={setSendAmount}
              keyboardType="number-pad"
            />
            <TouchableOpacity onPress={preparePayment} style={styles.button}>
              <Text style={styles.buttonText}>Prepare & Send Payment</Text>
            </TouchableOpacity>
          </View>
        )}

        {/* Events Section */}
        {events.length > 0 && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>
              Recent Events ({events.length})
            </Text>
            {events.map((item, idx) => (
              <View key={idx} style={styles.eventItem}>
                <Text style={styles.eventTime}>{item.timestamp}</Text>
                <Text style={styles.eventText}>
                  {JSON.stringify(item.event, null, 2)}
                </Text>
              </View>
            ))}
          </View>
        )}

        {/* Payments History */}
        {payments.length > 0 && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>
              Payment History ({payments.length})
            </Text>
            {payments.slice(0, 5).map((payment, idx) => (
              <View key={idx} style={styles.paymentItem}>
                <Text style={styles.paymentAmount}>
                  {payment.amountSats?.toString() || 'N/A'} sats
                </Text>
                <Text style={styles.paymentStatus}>{payment.status}</Text>
              </View>
            ))}
          </View>
        )}
      </ScrollView>
    </SafeAreaView>
  );
}
function BreezSpark2() {
  const [sdk, setSdk] = useState(null);
  const [balance, setBalance] = useState(null);
  const [events, setEvents] = useState([]);
  const [listenerId, setListenerId] = useState(null);
  const [payments, setPayments] = useState([]);

  // For receiving payments
  const [invoiceDescription, setInvoiceDescription] = useState('');
  const [invoiceAmount, setInvoiceAmount] = useState('');
  const [generatedInvoice, setGeneratedInvoice] = useState('');
  const [receiveFeeSats, setReceiveFeeSats] = useState(null);

  // For sending payments
  const [paymentRequest, setPaymentRequest] = useState('');
  const [sendAmount, setSendAmount] = useState('');
  const [preparedPayment, setPreparedPayment] = useState(null);

  async function connectToSdk() {
    try {
      const mnemonic =''; // 9901 sats
      // const mnemonic = ''; //    10001
      let config = defaultConfig(Network.Regtest);
      config.apiKey ='';

      const baseDir = DocumentDirectoryPath.replace('file://', '');
      const workingDir = `${baseDir}breezSdkSpark`;

      //   const directoryPath = await getOrCreateDirectory('testing', workingDir);

      console.log('API Key configured:', !!config.apiKey);

      const seed = new Seed.Mnemonic({mnemonic});
      const connectedSdk = await connect({
        config,
        seed,
        storageDir: workingDir,
      });

      setSdk(connectedSdk);
      console.log('✅ Connected successfully!');

      // Start listening to events
      setupEventListener(connectedSdk);

      // Get initial balance
      await fetchBalance(connectedSdk);

      // Load payment history
      await fetchPayments(connectedSdk);
    } catch (err) {
      console.error('❌ Connection error:', err);
      Alert.alert('Connection Error', err.message);
    }
  }

  function setupEventListener(sdkInstance) {
    const eventListener = new JsEventListener(event => {
      setEvents(prev =>
        [{event, timestamp: new Date().toISOString()}, ...prev].slice(0, 10),
      );

      // Refresh balance on payment events
      if (
        event.type === 'paymentSucceeded' ||
        event.type === 'paymentReceived'
      ) {
        fetchBalance(sdkInstance);
        fetchPayments(sdkInstance);
      }
    });

    const id = sdkInstance.addEventListener(eventListener);
    setListenerId(id);
    console.log('Event listener registered:', id);
  }

  async function fetchBalance(sdkInstance = sdk) {
    if (!sdkInstance) return;

    try {
      const info = await sdkInstance.getInfo({});
      setBalance(info.balanceSats);
      console.log('Balance:', info.balanceSats);
    } catch (err) {
      console.error('Error fetching balance:', err);
      Alert.alert('Balance Error', err.message);
    }
  }

  async function fetchPayments(sdkInstance = sdk) {
    if (!sdkInstance) return;

    try {
      const response = await sdkInstance.listPayments({
        offset: undefined,
        limit: 20,
      });
      console.log('response=>', response);
      setPayments(response.payments);
      console.log('Payments loaded:', response.payments.length);
    } catch (err) {
      console.error('Error fetching payments:', err);
    }
  }

  async function generateInvoice() {
    if (!sdk) {
      Alert.alert('Error', 'SDK not connected');
      return;
    }

    try {
      const amountSats = invoiceAmount ? BigInt(invoiceAmount) : undefined;

      // NOTE vai invoice
      const response = await sdk.receivePayment({
        paymentMethod: new ReceivePaymentMethod.Bolt11Invoice({
          description: invoiceDescription || 'Payment',
          amountSats,
        }),
      });
      console.log('response=>', response);
      // NOTE vai btc address ub regtest
      // const response = await sdk.receivePayment({
      //   paymentMethod: new ReceivePaymentMethod.BitcoinAddress()
      // })

      console.log(`Payment Request: ${paymentRequest}`);
      setGeneratedInvoice(response.paymentRequest);
      setReceiveFeeSats(response.fee);
      console.log('Invoice generated:', response.paymentRequest);
      console.log('Receive fees:', response.fee);

      Alert.alert('Invoice Generated', 'Check the invoice field below');
    } catch (err) {
      console.error('Error generating invoice:', err);
      Alert.alert('Invoice Error', err.message);
    }
  }

  async function preparePayment() {
    if (!sdk || !paymentRequest) {
      Alert.alert('Error', 'SDK not connected or no payment request');
      return;
    }

    try {
      const amountSats = sendAmount ? BigInt(sendAmount) : undefined;
      console.log('paymentRequest: ', paymentRequest);
      console.log('amountSats: ', amountSats);
      const prepareResponse = await sdk.prepareSendPayment({
        paymentRequest,
        amountSats,
      });

      setPreparedPayment(prepareResponse);

      if (
        prepareResponse.paymentMethod instanceof SendPaymentMethod.Bolt11Invoice
      ) {
        const lightningFee =
          prepareResponse.paymentMethod.inner.lightningFeeSats;
        const sparkFee =
          prepareResponse.paymentMethod.inner.sparkTransferFeeSats;
        console.log('lightningFee=:', lightningFee);
        console.log('sparkFee=:', sparkFee);
        // Alert.alert(
        //   'Payment Prepared',
        //   `Lightning Fees: ${lightningFee} sats\nSpark Fees: ${
        //     sparkFee || 'N/A'
        //   } sats`,
        //   [
        //     {text: 'Cancel', style: 'cancel'},
        //     {text: 'Send Payment', onPress: () => sendPayment(prepareResponse)},
        //   ],
        // );
      }
    } catch (err) {
      console.error('Error preparing payment:', err);
      Alert.alert('Prepare Error', err.message);
    }
  }

  async function sendPayment(prepareResponse) {
    if (!sdk) return;

    try {
      const response = await sdk.sendPayment({
        prepareResponse,
      });

      console.log('Payment sent:', response);
      Alert.alert('Success', 'Payment sent successfully!');

      // Clear form and refresh
      setPaymentRequest('');
      setSendAmount('');
      setPreparedPayment(null);
      await fetchBalance();
      await fetchPayments();
    } catch (err) {
      console.error('Error sending payment:', err);
      Alert.alert('Send Error', err.message);
    }
  }

  useEffect(() => {
    return () => {
      if (sdk && listenerId) {
        sdk.removeEventListener(listenerId);
      }
    };
  }, [sdk, listenerId]);

  console.log('receiveFeeSats=>', receiveFeeSats);
  return (
    <SafeAreaView style={styles.container}>
      <ScrollView style={styles.scrollView}>
        {/* Connection Section */}
        <View style={styles.section}>
          <TouchableOpacity
            onPress={connectToSdk}
            style={[styles.button, sdk && styles.buttonConnected]}
            disabled={!!sdk}>
            <Text style={styles.buttonText}>
              {sdk ? '✅ Connected' : 'Connect to Breez SDK'}
              {'\n'}
              {
                'soon provide struggle fitness dream emotion test cook wrestle price extra vapor'
              }
            </Text>
          </TouchableOpacity>

          {balance !== null && (
            <View style={styles.balanceContainer}>
              <Text style={styles.balanceLabel}>Balance:</Text>
              <Text style={styles.balanceAmount}>
                {balance.toString()} sats
              </Text>
              <TouchableOpacity
                onPress={() => fetchBalance()}
                style={styles.refreshButton}>
                <Text>🔄 Refresh</Text>
              </TouchableOpacity>
            </View>
          )}
        </View>

        {/* Receive Payment Section */}
        {sdk && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>Receive Payment</Text>
            <TextInput
              style={styles.input}
              placeholder="Invoice description"
              placeholderTextColor="#9CA3AF"
              value={invoiceDescription}
              onChangeText={setInvoiceDescription}
            />
            <TextInput
              style={styles.input}
              placeholder="Amount (sats) - optional"
              placeholderTextColor="#9CA3AF"
              value={invoiceAmount}
              onChangeText={setInvoiceAmount}
              keyboardType="number-pad"
            />
            <TouchableOpacity onPress={generateInvoice} style={styles.button}>
              <Text style={styles.buttonText}>Generate Invoice</Text>
            </TouchableOpacity>

            {generatedInvoice && (
              <View style={styles.invoiceContainer}>
                <Text style={styles.label}>Invoice:</Text>
                <Text style={styles.invoice} selectable>
                  {generatedInvoice}
                </Text>
                {/* {receiveFeeSats !== null && (
                  <Text style={styles.feeText}>
                    Fee: {receiveFeeSats.toString()} sats
                  </Text>
                )} */}
              </View>
            )}
          </View>
        )}

        {/* Send Payment Section */}
        {sdk && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>Send Payment</Text>
            <TextInput
              style={[styles.input, styles.textArea]}
              placeholder="Paste Lightning invoice (bolt11)"
              placeholderTextColor="#9CA3AF"
              value={paymentRequest}
              onChangeText={setPaymentRequest}
              multiline
            />
            <TextInput
              style={styles.input}
              placeholder="Amount (sats) - optional"
              placeholderTextColor="#9CA3AF" // gray, change as needed
              value={sendAmount}
              onChangeText={setSendAmount}
              keyboardType="number-pad"
            />
            <TouchableOpacity onPress={preparePayment} style={styles.button}>
              <Text style={styles.buttonText}>Prepare & Send Payment</Text>
            </TouchableOpacity>
          </View>
        )}

        {/* Events Section */}
        {events.length > 0 && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>
              Recent Events ({events.length})
            </Text>
            {events.map((item, idx) => (
              <View key={idx} style={styles.eventItem}>
                <Text style={styles.eventTime}>{item.timestamp}</Text>
                <Text style={styles.eventText}>
                  {JSON.stringify(item.event, null, 2)}
                </Text>
              </View>
            ))}
          </View>
        )}

        {/* Payments History */}
        {payments.length > 0 && (
          <View style={styles.section}>
            <Text style={styles.sectionTitle}>
              Payment History ({payments.length})
            </Text>
            {payments.slice(0, 5).map((payment, idx) => (
              <View key={idx} style={styles.paymentItem}>
                <Text style={styles.paymentAmount}>
                  {payment.amountSats?.toString() || 'N/A'} sats
                </Text>
                <Text style={styles.paymentStatus}>{payment.status}</Text>
              </View>
            ))}
          </View>
        )}
      </ScrollView>
    </SafeAreaView>
  );
}
const renderScene = SceneMap({
  add_coins: BreezSpark1,
  add_coins_group: BreezSpark2,
});

export default function BreezSpark() {
  const [routes] = React.useState(ROUTES);
  const [index, setIndex] = React.useState(0);
  return (
    <View style={{flex: 1, marginTop: 50}}>
      <TabView
        navigationState={{index, routes}}
        renderScene={renderScene}
        onIndexChange={setIndex}
        initialLayout={{width: SCREEN_WIDTH}}
        renderTabBar={props => <RenderTabBar {...props} styles={styles} />}
        lazy={true}
      />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#f5f5f5',
  },
  scrollView: {
    flex: 1,
    padding: 16,
  },
  section: {
    backgroundColor: 'white',
    borderRadius: 12,
    padding: 16,
    marginBottom: 16,
    shadowColor: '#000',
    shadowOffset: {width: 0, height: 2},
    shadowOpacity: 0.1,
    shadowRadius: 4,
    elevation: 3,
  },
  sectionTitle: {
    fontSize: 18,
    fontWeight: 'bold',
    marginBottom: 12,
    color: '#333',
  },
  button: {
    backgroundColor: '#007AFF',
    padding: 16,
    borderRadius: 8,
    alignItems: 'center',
  },
  buttonConnected: {
    backgroundColor: '#34C759',
  },
  buttonText: {
    color: 'white',
    fontSize: 16,
    fontWeight: '600',
  },
  balanceContainer: {
    marginTop: 16,
    padding: 16,
    backgroundColor: '#f8f8f8',
    borderRadius: 8,
    flexDirection: 'row',
    alignItems: 'center',
    justifyContent: 'space-between',
  },
  balanceLabel: {
    fontSize: 16,
    color: '#666',
  },
  balanceAmount: {
    fontSize: 20,
    fontWeight: 'bold',
    color: '#007AFF',
    flex: 1,
    marginLeft: 8,
  },
  refreshButton: {
    padding: 8,
  },
  input: {
    borderWidth: 1,
    borderColor: '#ddd',
    borderRadius: 8,
    padding: 12,
    marginBottom: 12,
    fontSize: 16,
  },
  textArea: {
    height: 80,
    textAlignVertical: 'top',
  },
  invoiceContainer: {
    marginTop: 12,
    padding: 12,
    backgroundColor: '#f8f8f8',
    borderRadius: 8,
  },
  label: {
    fontSize: 14,
    fontWeight: '600',
    marginBottom: 8,
    color: '#666',
  },
  invoice: {
    fontSize: 12,
    color: '#333',
    fontFamily: 'monospace',
  },
  feeText: {
    marginTop: 8,
    fontSize: 14,
    color: '#666',
  },
  eventItem: {
    padding: 12,
    backgroundColor: '#f8f8f8',
    borderRadius: 8,
    marginBottom: 8,
  },
  eventTime: {
    fontSize: 12,
    color: '#666',
    marginBottom: 4,
  },
  eventText: {
    fontSize: 12,
    fontFamily: 'monospace',
    color: '#333',
  },
  paymentItem: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    padding: 12,
    backgroundColor: '#f8f8f8',
    borderRadius: 8,
    marginBottom: 8,
  },
  paymentAmount: {
    fontSize: 16,
    fontWeight: '600',
    color: '#333',
  },
  paymentStatus: {
    fontSize: 14,
    color: '#666',
  },
});

BTC lightning with transaction confirmation


import {Alert} from 'react-native';
import {
  connect,
  defaultConfig,
  Network,
  Seed,
  ReceivePaymentMethod,
  SendPaymentMethod,
  SendPaymentMethod_Tags,
} from '@breeztech/breez-sdk-spark-react-native';
import {config, IS_SANDBOX} from 'dok-wallet-blockchain-networks/config/config';

import {DocumentDirectoryPath} from 'react-native-fs';
import BigNumber from 'bignumber.js';
import {rejects} from 'assert';
class JsEventListener {
  constructor(callback) {
    this.callback = callback;
  }

  onEvent = event => {
    // console.log(`Received event: ${JSON.stringify(event)}`);
    if (this.callback) {
      this.callback(event);
    }
  };
}

let sdkInstance = null;
let connectingPromise = null;
let prepareSendResponse;
let receiverFees;
export const BitcoinLightningChain = ({mnemonic}) => {
  async function connectToSdk() {
    // ✅ Already connected
    if (sdkInstance) {
      return sdkInstance;
    }

    // ✅ Connection already in progress
    if (connectingPromise) {
      return connectingPromise;
    }

    connectingPromise = (async () => {
      try {
        let config = defaultConfig(Network.Regtest);
        config.apiKey = process.env.BREEZ_API_KEY;

        const baseDir = DocumentDirectoryPath.replace('file://', '');
        const workingDir = `${baseDir}breezSdkSpark`;

        const seed = new Seed.Mnemonic({mnemonic});

        console.log('🔌 Connecting to Breez SDK...');
        sdkInstance = await connect({
          config,
          seed,
          storageDir: workingDir,
        });

        console.log('✅ Breez SDK connected');
        return sdkInstance;
      } catch (err) {
        console.error('❌ Connection error:', err);
        sdkInstance = null;
        connectingPromise = null;
        throw err;
      }
    })();

    return connectingPromise;
  }

  async function getBalance() {
    const sdk = await connectToSdk();

    const info = await sdk.getInfo({});
    console.log('Balance:', info.balanceSats);
    return info.balanceSats;
  }

  async function isValidAddress({address}) {
    return true;
  }
  // NOTE: fetch payments
  async function fetchPayments() {
    const sdk = await connectToSdk();
    if (!sdk) return;

    try {
      const response = await sdk.listPayments({
        offset: undefined,
        limit: 20,
      });
      console.log('Payments loaded:', response.payments.length);
      return {
        paymentDetails: response.payments,
      };
    } catch (err) {
      console.error('Error fetching payments:', err);
      Alert.alert('payment fetch Error', err.message);
    }
  }

  // NOTE: generate invoice
  async function generateInvoiceViaBolt11() {
    const sdk = await connectToSdk();
    if (!sdk) {
      Alert.alert('Error', 'SDK not connected');
      return;
    }
    // if (invoiceGenerated) return;
    // invoiceGenerated = true;

    try {
      // const amountSats = invoiceAmount ? BigInt(invoiceAmount) : undefined;

      const response = await sdk.receivePayment({
        paymentMethod: new ReceivePaymentMethod.Bolt11Invoice({
          // description: invoiceDescription || 'Payment',
          description: 'Payment',
          // amountSats,
        }),
      });

      // console.log('Invoice generated:', response.paymentRequest);
      // console.log('Receive fees:', response.fee);
      // Alert.alert('Invoice Generated', 'Check the invoice field below');
      return {
        address: response.paymentRequest,
        receiveFeeSats: response.fee,
      };
    } catch (err) {
      console.error('Error generating invoice:', err);
      Alert.alert('Invoice Error', err.message);
    }
  }

  // NOTE: generate invoice via bitcoin address
  async function generateInvoiceViaBitcoinAddress() {
    const sdk = await connectToSdk();
    if (!sdk) {
      Alert.alert('Error', 'SDK not connected');
      return;
    }

    try {
      // const amountSats = invoiceAmount ? BigInt(invoiceAmount) : undefined;

      // NOTE vai btc address ub regtest
      const response = await sdk.receivePayment({
        paymentMethod: new ReceivePaymentMethod.BitcoinAddress(),
      });

      console.log('Invoice generated:', response.paymentRequest);
      console.log('Receive fees:', response.fee);
      receiverFees = response.fee;
      return {
        address: response.paymentRequest,
        receiveFeeSats: response.fee,
      };
    } catch (err) {
      console.error('Error generating invoice:', err);
      Alert.alert('Invoice Error', err.message);
    }
  }

  // NOTE: prepare payment and send payment
  async function prepareAndSendPayment(paymentRequest, amountSats) {
    const sdk = await connectToSdk();
    if (!sdk || !paymentRequest) {
      Alert.alert('Error', 'SDK not connected or no payment request');
      return;
    }

    try {
      const prepareResponse = await sdk.prepareSendPayment({
        paymentRequest,
        amountSats,
      });

      prepareSendResponse = prepareResponse;
      if (
        prepareResponse.paymentMethod instanceof SendPaymentMethod.Bolt11Invoice
      ) {
        const lightningFee =
          prepareResponse.paymentMethod.inner.lightningFeeSats;
        const sparkFee =
          prepareResponse.paymentMethod.inner.sparkTransferFeeSats;

        return {
          lightningFee: lightningFee,
          sparkFee: sparkFee,
        };
      }
      return {};
    } catch (err) {
      console.error('Error preparing payment:', err);
      Alert.alert('Prepare Error', err.message);
    }
  }

  function btcToSatoshi(btc) {
    if (btc === null || btc === undefined) return 0;
    return BigInt(Math.round(Number(btc) * 100_000_000));
  }
  function satoshiToBtc(sats) {
    if (sats === null || sats === undefined) return 0;

    // Handle BigInt or number or string safely
    const satsNumber = typeof sats === 'bigint' ? Number(sats) : Number(sats);

    return satsNumber / 100_000_000;
  }
  // {
  //     "fee": "0.00059502",
  //     "estimateGas": 141,
  //     "feesOptions": [
  //         {
  //             "title": "Recommended",
  //             "gasPrice": 422
  //         },
  //         {
  //             "title": "Normal",
  //             "gasPrice": 358
  //         }
  //     ]
  // }
  async function getEstimateFee({
    fromAddress,
    toAddress,
    amount,
    privateKey,
    chain_name,
    deriveAddresses,
    balance,
    extendedPrivateKey,
    feeMultiplier,
    estimateGas: virtualSize,
    feesType,
    selectedUTXOs,
  }) {
    try {
      const amountSats = btcToSatoshi(amount);

      const {lightningFee} = await prepareAndSendPayment(toAddress, amountSats);
      const fee = satoshiToBtc(lightningFee);
      return {
        fee: fee,
        estimateGas: 0,
        feesOptions: [],
      };
    } catch (error) {
      console.error('Error in bitcoin gas fee', error);
      throw error;
    }
  }
  async function send({
    to,
    from,
    amount,
    privateKey,
    transactionFee,
    chain_name,
    deriveAddresses,
    balance,
    extendedPrivateKey,
    selectedUTXOs,
  }) {
    try {
      const amountToSend = new BigNumber(amount);
      const sdk = await connectToSdk();
      if (!sdk || !prepareSendResponse) {
        Alert.alert('Error', 'SDK not connected or no payment request');
        return;
      }
      // If the fees are acceptable, continue to send the token payment
      if (
        prepareSendResponse.paymentMethod?.tag ===
        SendPaymentMethod_Tags.SparkAddress
      ) {
        console.log(
          `Token ID: ${prepareSendResponse.paymentMethod.inner.tokenIdentifier}`,
        );
        console.log(
          `Fees: ${prepareSendResponse.paymentMethod.inner.fee} token base units`,
        );
      }
      if (
        prepareSendResponse.paymentMethod?.tag ===
        SendPaymentMethod_Tags.SparkInvoice
      ) {
        console.log(
          `Token ID: ${prepareSendResponse.paymentMethod.inner.tokenIdentifier}`,
        );
        console.log(
          `Fees: ${prepareSendResponse.paymentMethod.inner.fee} token base units`,
        );
      }

      // Send the token payment
      const sendResponse = await sdk.sendPayment({
        prepareResponse: prepareSendResponse,
        options: undefined,
        idempotencyKey: undefined,
      });
      const payment = sendResponse.payment;
      console.log('payment=>', payment);
      return payment.details.inner.paymentHash;
    } catch (error) {
      console.error('Error in bitcoin gas fee', error);
      throw error;
    }
  }
  async function waitForConfirmation({transaction}) {
    const transactionID = transaction;
    console.log('transactionID:', transactionID);

    const sdk = await connectToSdk();

    if (!sdk) {
      Alert.alert('Error', 'SDK not connected');
      return;
    }

    return new Promise(async (resolve, reject) => {
      let listenerId = null;
      let timeoutId = null;
      let resolved = false;

      try {
        const eventListener = new JsEventListener(async event => {
          console.log('event:', event);

          if (resolved) return;

          if (event.tag === 'PaymentSucceeded') {
            resolved = true;

            // 🧹 cleanup
            if (listenerId !== null) {
              sdk.removeEventListener(listenerId);
            }
            if (timeoutId) {
              clearTimeout(timeoutId);
            }

            resolve(true);
          }
        });

        listenerId = await sdk.addEventListener(eventListener);
        console.log('Event listener registered:', listenerId);

        // ⏱️ 90 seconds timeout
        timeoutId = setTimeout(() => {
          if (resolved) return;

          resolved = true;

          console.log('⏱️ Payment confirmation timeout (90s)');

          // 🧹 cleanup
          if (listenerId !== null) {
            sdk.removeEventListener(listenerId);
          }

          resolve('pending');
        }, 90_000); // 90 seconds
      } catch (error) {
        console.error('Error in waitForConfirmation:', error);

        // 🧹 cleanup
        if (listenerId !== null) {
          sdk.removeEventListener(listenerId);
        }
        if (timeoutId) {
          clearTimeout(timeoutId);
        }

        reject(error);
      }
    });
  }

  // async function setupEventListener() {
  //   const sdk = await connectToSdk();
  //   if (!sdk || !prepareSendResponse) {
  //     Alert.alert('Error', 'SDK not connected or no payment request');
  //     return;
  //   }
  //   const eventListener = new JsEventListener(event => {
  //     // Refresh balance on payment events
  //     if (
  //       event.type === 'paymentSucceeded' ||
  //       event.type === 'paymentReceived'
  //     ) {
  //       // fetchBalance(sdkInstance);
  //       // fetchPayments(sdkInstance);
  //       console.log("=========PAYMENT SUCCESSFULL===========")
  //     }
  //   });

  //   const id = sdkInstance.addEventListener(eventListener);
  //   // setListenerId(id);
  //   console.log('Event listener registered:', id);
  // }

  return {
    connectToSdk,
    getBalance,
    isValidAddress,
    fetchPayments,
    generateInvoiceViaBolt11,
    generateInvoiceViaBitcoinAddress,
    prepareAndSendPayment,
    getEstimateFee,
    send,
    waitForConfirmation,
  };
};

Wallet Creation by Alchemy SDK

Swatantra goswami — Sat, 27 Dec 2025 15:21:25 +0000

Initialize Object
Alchemy Supported chain list:
https://www.alchemy.com/docs/wallets/supported-chains

const { Alchemy } = require('alchemy-sdk')

const getAlchemy = (chainId) => {
    const alchemyApiKey = ''

    return new Alchemy({
        apiKey: alchemyApiKey,
        network: 'eth-sepolia' // chain-id
    })
}

const getTokenMetaDataFromAlchemy = async (tokenAddress, chainId) => {
    try {
        const alchemy = getAlchemy(chainId)
        return alchemy.core.getTokenMetadata(tokenAddress)
    } catch (error) {
        console.log(error)
    }
    return
}

/** 
    const addresses = [
        {
            address: '0xED1B7De57918f6B7c8a7a7767557f09A80eC2a35',
            networks: ['eth-sepolia', 'eth-mainnet']
        }
    ] 
*/
const getPortfolio = async (addresses, chainId) => {
    try {
        const withPrices = true
        const includeNativeTokens = true
        const withMetadata = true
        const alchemy = getAlchemy(chainId)
        const { data } = await alchemy.portfolio.getTokensByWallet(
            addresses,
            withMetadata,
            withPrices,
            includeNativeTokens
        )
        const wei = BigInt(data.tokens[0].tokenBalance)
        const eth = Number(wei) / 1e18 // safe here because value is small

        console.log('ETH balance:', eth) // 0.05
        return JSON.stringify(data, null, 2)
    } catch (error) {
        console.log(error)
    }
}

module.exports = {
    getAlchemy,
    getTokenMetaDataFromAlchemy,
    getPortfolio
}

Now it's time to call the alchemy function

const {
    getAlchemy,
    getTokenMetaDataFromAlchemy,
    getPortfolio
} = require('./getAlchemy')

const callingFUntion = async () => {
    const addresses = [
        {
            address: '0xED1B7De57918f6B7c8a7a7767557f09A80eC2a35',
            networks: ['eth-sepolia', 'eth-mainnet']
        }
    ]
    console.log(await getPortfolio(addresses, '1'))
}
callingFUntion()

BitCoin Chain Integration

Swatantra goswami — Tue, 05 Aug 2025 07:12:36 +0000

run node on server
create a bitcoin core instance

const Client = require("bitcoin-core");
const client = new Client({
    network: "testnet",
    host: "116.202.196.59",
    port: "8332",
    username: "btcuser",
    password: "btcpassword",
    version: "0.18.1",
});

generate a new address

const getNewAddr = async () => {
    const newAddr = await client.getNewAddress();
    return newAddr;
};

get total balance

const getTotalBal = async () => {
  const balance = await client.getBalance("*", 0);
  return balance;
};

get trx details

const getTxnDetails = async (txId) => {
  const txn = await client.getTransaction(txId);
  return txn;
};

get blocks

const getBlock = async (blockHash) => {
  const block = await client.getBlock(blockHash);
  return block;
};

transfer bitcoin

const transfer = async (toAddr, amt) => {
  const txn = await client.sendToAddress(toAddr, amt);
  return txn;
};

Ethereum chain Integration

Swatantra goswami — Tue, 05 Aug 2025 07:07:44 +0000

const { ethers } = require('ethers')
const bip39 = require('bip39')


export class Ethereum {
    constructor(rpcUrl) {

    }

    // provider
    getProvider() {
        const provider = new ethers.providers.JsonRpcProvider(`https://rpc-amoy.polygon.technology`);
        return provider;
    }

    // generate address
    generateAddress() {
        const mnemonic = bip39.generateMnemonic(96);
        const eightWords = mnemonic.split(' ').slice(0, 8).join(' ');
        const seed = bip39.mnemonicToSeedSync(eightWords);
        const hdNode = ethers.utils.HDNode.fromSeed(seed);
        const { address, privateKey } = hdNode.derivePath("m/44'/60'/0'/0/0");
        return { address, privateKey }
    }
    // calculate gas fees
    async calculateGas(toAddress, from) {
        const txData = {
            to: toAddress,
            value: ethers.parseEther('0.01'),
            from: '0xYourWalletAddressHere'
        };
        const gasLimit = await provider.estimateGas(txData);
    }
    // get balance
    async getBalance(address) {
        const provider = this.getProvider();
        const balance = await provider.getBalance(address) // returns the BigNumber object
        const balanceEther = ethers.utils.formatEther(balance) // return balance in ether
        const balanceWei = ethers.utils.parseEther(balanceEther)
        return {
            balance: balance,
            balanceEther: balanceEther,
            balanceWei: balanceWei
        }
    }
    // validate address
    validateAddress(address) {
        return ethers.isAddress(address);
    }
    // do transaction
    async transfer(sendersPk, amount, toAddress) {
        const provider = this.getProvider();
        const wallet = new ethers.Wallet(sendersPk, provider);
        const tx = await wallet.sendTransaction({
            to: toAddress,
            value: ethers.utils.parseEther(amount)
        })
        await tx.wait();
    }

    // token transfer
    async tokenTransfer(tokenAddress, toAddress, amount) {
        const provider = this.getProvider();
        const ERC20_ABI = [
            "function name() view returns (string)",
            "function symbol() view returns (string)",
            "function decimals() view returns (uint8)",
            "function balanceOf(address a) view returns (uint)",
            "function transfer(address to, uint amount) returns (bool)",
        ];
        const contract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
        const res = await contract.transfer(toAddress, amount)
        return res.hash;
    }

    // get transaction details
    transactionDetails() {

    }

    // get token details or import token
    async getTokenDetails(accountAddress, tokenAddress) {
        const provider = this.getProvider();
        const ERC20_ABI = [
            "function name() view returns (string)",
            "function symbol() view returns (string)",
            "function decimals() view returns (uint8)",
            "function balanceOf(address a) view returns (uint)",
            "function transfer(address to, uint amount) returns (bool)",
        ];
        const contract = new ethers.Contract(tokenAddress, ERC20_ABI, provider);
        const name = (await contract.name());
        const symbol = (await contract.symbol());
        const decimals = (await contract.decimals());
        const balance = await contract.balanceOf(accountAddress)
        return {
            name,
            symbol,
            decimals,
            balance
        }
    }

}