Wallet API

import { WalletServiceClient } from './proto/WalletServiceClientPb'
import { GetBalancesRequest } from './proto/wallet_pb'

const client = new WalletServiceClient('http://localhost:5003')

const request = new GetBalancesRequest()
request.setNetwork({ protocol: 1, id: '0a03cf40' })

const response = await client.getBalances(request, {})
const balances = response.getBalancesMap()

import (
    pb "github.com/hydra/hydra-go/proto"
)

client := pb.NewWalletServiceClient(conn)

req := &pb.GetBalancesRequest{
    Network: &pb.Network{
        Protocol: pb.Protocol_PROTOCOL_BITCOIN,
        Id:       "0a03cf40",
    },
}

resp, err := client.GetBalances(context.Background(), req)
if err != nil {
    log.Fatal(err)
}

balances := resp.Balances

use hydra_app::wallet_service_client::WalletServiceClient;
use hydra_app::{GetBalancesRequest, Network};

let mut client = WalletServiceClient::new(channel);

let request = tonic::Request::new(GetBalancesRequest {
    network: Some(Network {
        protocol: Protocol::Bitcoin as i32,
        id: "0a03cf40".to_string(),
    }),
});

let response = client.get_balances(request).await?;
let balances = response.into_inner().balances;

const request = new GetBalanceRequest()
request.setNetwork({ protocol: 1, id: '0a03cf40' })
request.setAssetId('0x0000000000000000000000000000000000000000000000000000000000000000')

const response = await client.getBalance(request, {})
const balance = response.getBalance()

req := &pb.GetBalanceRequest{
    Network: &pb.Network{
        Protocol: pb.Protocol_PROTOCOL_BITCOIN,
        Id:       "0a03cf40",
    },
    AssetId: "0x0000000000000000000000000000000000000000000000000000000000000000",
}

resp, err := client.GetBalance(context.Background(), req)
if err != nil {
    log.Fatal(err)
}

balance := resp.Balance

let request = tonic::Request::new(GetBalanceRequest {
    network: Some(Network {
        protocol: Protocol::Bitcoin as i32,
        id: "0a03cf40".to_string(),
    }),
    asset_id: "0x0000000000000000000000000000000000000000000000000000000000000000".to_string(),
});

let response = client.get_balance(request).await?;
let balance = response.into_inner().balance;

const request = new GetTransactionsRequest()
request.setNetwork({ protocol: 1, id: '0a03cf40' })

const response = await client.getTransactions(request, {})
const transactions = response.getTransactionsList()

req := &pb.GetTransactionsRequest{
    Network: &pb.Network{
        Protocol: pb.Protocol_PROTOCOL_BITCOIN,
        Id:       "0a03cf40",
    },
}

resp, err := client.GetTransactions(context.Background(), req)
if err != nil {
    log.Fatal(err)
}

transactions := resp.Transactions

let request = tonic::Request::new(GetTransactionsRequest {
    network: Some(Network {
        protocol: Protocol::Bitcoin as i32,
        id: "0a03cf40".to_string(),
    }),
});

let response = client.get_transactions(request).await?;
let transactions = response.into_inner().transactions;

const request = new GetTransactionRequest()
request.setNetwork({ protocol: 1, id: '0a03cf40' })
request.setTxid('abc123...')

const response = await client.getTransaction(request, {})
const transaction = response.getTransaction()

req := &pb.GetTransactionRequest{
    Network: &pb.Network{
        Protocol: pb.Protocol_PROTOCOL_BITCOIN,
        Id:       "0a03cf40",
    },
    Txid: "abc123...",
}

resp, err := client.GetTransaction(context.Background(), req)
if err != nil {
    log.Fatal(err)
}

transaction := resp.Transaction

let request = tonic::Request::new(GetTransactionRequest {
    network: Some(Network {
        protocol: Protocol::Bitcoin as i32,
        id: "0a03cf40".to_string(),
    }),
    txid: "abc123...".to_string(),
});

let response = client.get_transaction(request).await?;
let transaction = response.into_inner().transaction;

async function hasSufficientBalance(
  client: WalletServiceClient,
  network: Network,
  assetId: string,
  requiredAmount: string,
  balanceType: 'onchain' | 'offchain'
): Promise<boolean> {
  const request = new GetBalanceRequest()
  request.setNetwork(network)
  request.setAssetId(assetId)

  const response = await client.getBalance(request, {})
  const balance = response.getBalance()

  // Off-chain: size a single payment off max_sendable, not free_local.
  const available = balanceType === 'onchain'
    ? balance.getOnchain()?.getConfirmed()?.getValue()
    : balance.getOffchain()?.getMaxSendable()?.getValue()

  return new Big(available || '0').gte(new Big(requiredAmount))
}

func hasSufficientBalance(
    client pb.WalletServiceClient,
    network *pb.Network,
    assetId string,
    requiredAmount string,
    balanceType string,
) (bool, error) {
    req := &pb.GetBalanceRequest{
        Network: network,
        AssetId: assetId,
    }

    resp, err := client.GetBalance(context.Background(), req)
    if err != nil {
        return false, err
    }

    balance := resp.Balance
    var available string

    // Off-chain: size a single payment off MaxSendable, not FreeLocal.
    if balanceType == "onchain" {
        available = balance.Onchain.Confirmed.Value
    } else {
        available = balance.Offchain.MaxSendable.Value
    }

    // Amounts are decimal strings in whole units — parse as decimals, not ints.
    requiredDec, _, err := big.ParseFloat(requiredAmount, 10, 128, big.ToNearestEven)
    if err != nil {
        return false, err
    }
    availableDec, _, err := big.ParseFloat(available, 10, 128, big.ToNearestEven)
    if err != nil {
        return false, err
    }

    return availableDec.Cmp(requiredDec) >= 0, nil
}

async fn has_sufficient_balance(
    client: &mut WalletServiceClient<Channel>,
    network: Network,
    asset_id: String,
    required_amount: String,
    balance_type: &str,
) -> Result<bool, Box<dyn std::error::Error>> {
    let request = tonic::Request::new(GetBalanceRequest {
        network: Some(network),
        asset_id,
    });

    let response = client.get_balance(request).await?;
    let balance = response.into_inner().balance.unwrap();

    // Off-chain: size a single payment off max_sendable, not free_local.
    let available = if balance_type == "onchain" {
        balance.onchain.unwrap().confirmed.unwrap().value
    } else {
        balance.offchain.unwrap().max_sendable.unwrap().value
    };

    // Amounts are decimal strings in whole units.
    let required: Decimal = required_amount.parse()?;
    let available_amount: Decimal = available.parse()?;

    Ok(available_amount >= required)
}

async function waitForConfirmations(
  client: WalletServiceClient,
  network: Network,
  txid: string,
  requiredConfirmations: number
): Promise<void> {
  while (true) {
    const request = new GetTransactionRequest()
    request.setNetwork(network)
    request.setTxid(txid)

    const response = await client.getTransaction(request, {})
    const tx = response.getTransaction()

    if (tx.getConfirmations() >= requiredConfirmations) {
      return
    }

    await new Promise(resolve => setTimeout(resolve, 30000)) // Wait 30s
  }
}

func waitForConfirmations(
    client pb.WalletServiceClient,
    network *pb.Network,
    txid string,
    requiredConfirmations uint64,
) error {
    for {
        req := &pb.GetTransactionRequest{
            Network: network,
            Txid:    txid,
        }

        resp, err := client.GetTransaction(context.Background(), req)
        if err != nil {
            return err
        }

        tx := resp.Transaction

        if tx.Confirmations >= requiredConfirmations {
            return nil
        }

        time.Sleep(30 * time.Second) // Wait 30s
    }
}

async fn wait_for_confirmations(
    client: &mut WalletServiceClient<Channel>,
    network: Network,
    txid: String,
    required_confirmations: u64,
) -> Result<(), Box<dyn std::error::Error>> {
    loop {
        let request = tonic::Request::new(GetTransactionRequest {
            network: Some(network.clone()),
            txid: txid.clone(),
        });

        let response = client.get_transaction(request).await?;
        let tx = response.into_inner().transaction.unwrap();

        if tx.confirmations >= required_confirmations {
            return Ok(());
        }

        tokio::time::sleep(tokio::time::Duration::from_secs(30)).await; // Wait 30s
    }
}