DEV Community: Swatantra goswami

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
        }
    }

}

EtherJs Functions working

Swatantra goswami — Tue, 05 Aug 2025 06:58:54 +0000

get instance of ethers

const {ethers} = require('ethers')
const provider = new ethers.prividers.JsonRpcProvider(`infura url`);

get current block number

const block = await provider.getBlockNumber();

get balance

const balance = await provider.getBalance('address in hex') // returns the BigNumber object
const balanceEther = ethers.utils.formatEther(balance) // return balance in ether
const balanceWei = ethers.utils.parseEther(balanceEther) // return BigNumber

Interact with Contract

const contractInstance = new ethers.Contract(contractAddress, contractABI, signerOrProvider);

In frontend We don't want to specify the externally infura provider to the etherjs

const provider = new ethers.providers.Web3Provider(window.ethereum)

sendTransaction

const wallet = new ethers.Wallet('senders pk', provider);
const tx = await wallet.sendTransaction({
    to:'',
    value:ether.utils.parseEther("0.025")
})
await tx.wait();

send Token with contract interaction

account1=''
account2=''

privateKey1=''
const wallet = new ethers.Wallet(privateKey1, provider);

const usdtTokenAbi=[]
const usdtTokenContractAddress = ''

const contractInstance = new ethers.Contract(usdtTokenContractAddress,usdtTokenAbi, provider);


const main = async () => {
const balance = await contractInstance.balanceOf(account1)
    const contractWithWallet = contractInstance.connect(wallet);
    await contractWithWallet.transfer(account2, amoutToSend);
    tx.wait();

}

contract eventStream ( get transaction details )

const usdtTokenAbi=[]
const usdtTokenContractAddress = ''

const contractInstance = new ethers.Contract(usdtTokenContractAddress,usdtTokenAbi, provider);
const latestBlockNumber = await provider.getBlockNumber(); 

const transferEvents = await contractInstance.queryFilter(
    'Transfer', 
    latestBlockNumber - 10, // fromBlockNumber 
    latestBlockNumber // toBlockNumber
);

get block information

const main = () => {
    const block = await provider.getBlockNumber();
    const blockInfo = await provider.getBlock(block);
    consoel.log(blockInfo);
    const { transactions } = await provider.getBlockWithTransactions(block);
    console.log(transactions[0])
}

get token details

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()) as string;
const symbol = (await contract.symbol()) as string;
const decimals = (await contract.decimals()) as number;

https://docs.ethers.org/v5/
https://github.com/dappuniversity/ethers_examples

Css Notes

Swatantra goswami — Fri, 28 Mar 2025 06:49:09 +0000

https://css-tricks.com/snippets/css/a-guide-to-flexbox/#aa-background