Wallet API

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

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

const request = new GetBalancesRequest()
request.setNetwork({
  protocol: 0,
  chainId: '0',
  name: 'Bitcoin'
})

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: 0,
        ChainId:  "0",
        Name:     "Bitcoin",
    },
}

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

balances := resp.Balances

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

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

let request = tonic::Request::new(GetBalancesRequest {
    network: Some(Network {
        protocol: 0,
        chain_id: "0".to_string(),
        name: "Bitcoin".to_string(),
    }),
});

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

const request = new GetBalanceRequest()
request.setNetwork({
  protocol: 0,
  chainId: '0',
  name: 'Bitcoin'
})
request.setAssetId('BTC')

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

req := &pb.GetBalanceRequest{
    Network: &pb.Network{
        Protocol: 0,
        ChainId:  "0",
        Name:     "Bitcoin",
    },
    AssetId: "BTC",
}

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: 0,
        chain_id: "0".to_string(),
        name: "Bitcoin".to_string(),
    }),
    asset_id: "BTC".to_string(),
});

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

const request = new GetTransactionsRequest()
request.setNetwork({
  protocol: 0,
  chainId: '0',
  name: 'Bitcoin'
})

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

req := &pb.GetTransactionsRequest{
    Network: &pb.Network{
        Protocol: 0,
        ChainId:  "0",
        Name:     "Bitcoin",
    },
}

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: 0,
        chain_id: "0".to_string(),
        name: "Bitcoin".to_string(),
    }),
});

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

const request = new GetTransactionRequest()
request.setNetwork({
  protocol: 0,
  chainId: '0',
  name: 'Bitcoin'
})
request.setTxid('abc123...')

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

req := &pb.GetTransactionRequest{
    Network: &pb.Network{
        Protocol: 0,
        ChainId:  "0",
        Name:     "Bitcoin",
    },
    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: 0,
        chain_id: "0".to_string(),
        name: "Bitcoin".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()

  const available = balanceType === 'onchain'
    ? balance.getOnchain()?.getConfirmed()
    : balance.getOffchain()?.getLocal()

  return BigInt(available || '0') >= BigInt(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

    if balanceType == "onchain" {
        available = balance.Onchain.Confirmed
    } else {
        available = balance.Offchain.Local
    }

    requiredBig := new(big.Int)
    requiredBig.SetString(requiredAmount, 10)

    availableBig := new(big.Int)
    availableBig.SetString(available, 10)

    return availableBig.Cmp(requiredBig) >= 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();

    let available = if balance_type == "onchain" {
        balance.onchain.unwrap().confirmed
    } else {
        balance.offchain.unwrap().local
    };

    let required: u64 = required_amount.parse()?;
    let available_amount: u64 = 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 uint32,
) 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: u32,
) -> 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
    }
}