Blockchain API

const blockNumber = await hydraGrpcClient.getBlockNumber({
  protocol: Protocol.BITCOIN,
  id: '0a03cf40' // Bitcoin Signet
})

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

let response = client.get_block_number(request).await?;
let block_number = response.into_inner().block_number;

// Get latest block header
const header = await hydraGrpcClient.getBlockHeader({
  protocol: Protocol.EVM,
  id: '11155111'
})

// Get specific block
const header = await hydraGrpcClient.getBlockHeader({
  protocol: Protocol.EVM,
  id: '11155111'
}, 1000000)

// Latest block
let request = tonic::Request::new(GetBlockHeaderRequest {
    network: Some(Network {
        protocol: Protocol::Evm as i32,
        id: "11155111".to_string(),
    }),
    block_number: None,
});

let response = client.get_block_header(request).await?;
let header = response.into_inner().header;

const fees = await hydraGrpcClient.getFeeEstimates({
  protocol: Protocol.BITCOIN,
  id: '0a03cf40'
})

console.log(`Low: ${fees.low} sat/vB`)
console.log(`Medium: ${fees.medium} sat/vB`)
console.log(`High: ${fees.high} sat/vB`)

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

let response = client.get_fee_estimates(request).await?;
let fees = response.into_inner();
println!("Low: {} sat/vB", fees.low);
println!("Medium: {} sat/vB", fees.medium);
println!("High: {} sat/vB", fees.high);

const allowance = await hydraGrpcClient.getTokenAllowance({
  network: {
    protocol: Protocol.EVM,
    id: '11155111'
  },
  tokenAddress: '0x...', // USDC
  owner: '0x...', // Your address
  spender: '0x...' // Contract address
})

console.log(`Allowance: ${allowance}`)

let request = tonic::Request::new(GetTokenAllowanceRequest {
    network: Some(Network {
        protocol: Protocol::Evm as i32,
        id: "11155111".to_string(),
    }),
    token_address: "0x...".to_string(),
    owner: "0x...".to_string(),
    spender: "0x...".to_string(),
});

let response = client.get_token_allowance(request).await?;
let allowance = response.into_inner().allowance;

async fn wait_for_confirmations(
    client: &mut BlockchainServiceClient<Channel>,
    network: Network,
    tx_block: u64,
    required_confirmations: u64,
) -> Result<(), Box<dyn std::error::Error>> {
    loop {
        let current_block = client
            .get_block_number(GetBlockNumberRequest {
                network: Some(network.clone()),
            })
            .await?
            .into_inner()
            .block_number;

        let confirmations = current_block.saturating_sub(tx_block);

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

        tokio::time::sleep(tokio::time::Duration::from_secs(15)).await;
    }
}

async fn get_fee_for_urgency(
    client: &mut BlockchainServiceClient<Channel>,
    network: Network,
    urgent: bool,
) -> Result<String, Box<dyn std::error::Error>> {
    let fees = client
        .get_fee_estimates(GetFeeEstimatesRequest {
            network: Some(network),
        })
        .await?
        .into_inner();

    Ok(if urgent { fees.high } else { fees.medium })
}