Client API

import { FeeOption } from './proto/models'

const response = await hydraGrpcClient.sendTransaction({
  network: {
    protocol: Protocol.BITCOIN,
    id: '0a03cf40'
  },
  toAddress: 'tb1q...',
  amount: {
    value: '0.001',
    assetId: 'BTC'
  },
  feeOption: FeeOption.MEDIUM
})

console.log('Transaction ID:', response.txid)

req := &pb.SendTransactionRequest{
    Network: &pb.Network{
        Protocol: pb.Protocol_BITCOIN,
        Id:       "0a03cf40",
    },
    To: "tb1q...",
    Amount: &pb.Amount{
        Value:   "0.001",
        AssetId: "BTC",
    },
    FeeOption: pb.FeeOption_MEDIUM,
}

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

txid := resp.Txid

let request = tonic::Request::new(SendTransactionRequest {
    network: Some(Network {
        protocol: Protocol::Bitcoin as i32,
        id: "0a03cf40".to_string(),
    }),
    to_address: "tb1q...".to_string(),
    amount: Some(Amount {
        value: "0.001".to_string(),
        asset_id: "BTC".to_string(),
    }),
    fee_option: FeeOption::Medium as i32,
});

let response = client.send_transaction(request).await?;
let txid = response.into_inner().txid;

// Send USDC on Ethereum Sepolia
const response = await hydraGrpcClient.sendTokenTransaction({
  network: {
    protocol: Protocol.EVM,
    id: '11155111'
  },
  toAddress: '0x...',
  tokenId: '0x...', // USDC contract address
  amount: {
    value: '100.0',
    assetId: 'USDC'
  },
  feeOption: FeeOption.MEDIUM
})

req := &pb.SendTokenTransactionRequest{
    Network: &pb.Network{
        Protocol: pb.Protocol_EVM,
        Id:       "11155111",
    },
    To: "0x...",
    TokenId:   "0x...",
    Amount: &pb.Amount{
        Value:   "100.0",
        AssetId: "USDC",
    },
    FeeOption: pb.FeeOption_MEDIUM,
}

resp, err := client.SendTokenTransaction(context.Background(), req)

let request = tonic::Request::new(SendTokenTransactionRequest {
    network: Some(Network {
        protocol: Protocol::Evm as i32,
        id: "11155111".to_string(),
    }),
    to_address: "0x...".to_string(),
    token_id: "0x...".to_string(),
    amount: Some(Amount {
        value: "100.0".to_string(),
        asset_id: "USDC".to_string(),
    }),
    fee_option: FeeOption::Medium as i32,
});

let response = client.send_token_transaction(request).await?;

const response = await hydraGrpcClient.bumpTransaction({
  network: {
    protocol: Protocol.BITCOIN,
    id: '0a03cf40'
  },
  txid: 'abc123...',
  feeOption: FeeOption.HIGH
})

req := &pb.BumpTransactionRequest{
    Network: &pb.Network{
        Protocol: pb.Protocol_BITCOIN,
        Id:       "0a03cf40",
    },
    Txid:      "abc123...",
    FeeOption: pb.FeeOption_HIGH,
}

resp, err := client.BumpTransaction(context.Background(), req)

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

let response = client.bump_transaction(request).await?;

const response = await hydraGrpcClient.setTokenAllowance({
  network: {
    protocol: Protocol.EVM,
    id: '11155111'
  },
  spender: '0x...', // Contract or address to approve
  allowance: {
    tokenId: '0x...', // Token contract
    amount: '1000.0'
  },
  feeOption: FeeOption.MEDIUM
})

req := &pb.SetTokenAllowanceRequest{
    Network: &pb.Network{
        Protocol: pb.Protocol_EVM,
        Id:       "11155111",
    },
    Spender: "0x...",
    Allowance: &pb.SetTokenAllowance{
        TokenId: "0x...",
        Amount:  "1000.0",
    },
    FeeOption: pb.FeeOption_MEDIUM,
}

resp, err := client.SetTokenAllowance(context.Background(), req)

let request = tonic::Request::new(SetTokenAllowanceRequest {
    network: Some(Network {
        protocol: Protocol::Evm as i32,
        id: "11155111".to_string(),
    }),
    spender: "0x...".to_string(),
    allowance: Some(SetTokenAllowance {
        token_id: "0x...".to_string(),
        amount: "1000.0".to_string(),
    }),
    fee_option: FeeOption::Medium as i32,
});

let response = client.set_token_allowance(request).await?;

async function getAllDepositAddresses() {
  const networks = await hydraGrpcClient.getNetworks()
  const addresses: Record<string, string> = {}

  for (const network of networks) {
    try {
      const address = await hydraGrpcClient.getDepositAddress(network)
      addresses[network.id] = address
    } catch (error) {
      console.error(`Failed to get address for ${network.id}:`, error)
    }
  }

  return addresses
}

func getAllDepositAddresses(client pb.ClientServiceClient) (map[string]string, error) {
    networksResp, err := appClient.GetNetworks(context.Background(), &pb.GetNetworksRequest{})
    if err != nil {
        return nil, err
    }

    addresses := make(map[string]string)

    for _, network := range networksResp.Networks {
        resp, err := client.GetDepositAddress(context.Background(), &pb.GetDepositAddressRequest{
            Network: network,
        })
        if err != nil {
            log.Printf("Failed to get address for %s: %v", network.Id, err)
            continue
        }

        addresses[network.Id] = resp.Address
    }

    return addresses, nil
}

async fn get_all_deposit_addresses(
    client: &mut ClientServiceClient<Channel>,
    app_client: &mut AppServiceClient<Channel>,
) -> Result<HashMap<String, String>, Box<dyn std::error::Error>> {
    let networks = app_client
        .get_networks(GetNetworksRequest {})
        .await?
        .into_inner()
        .networks;

    let mut addresses = HashMap::new();

    for network in networks {
        match client
            .get_deposit_address(GetDepositAddressRequest {
                network: Some(network.clone()),
            })
            .await
        {
            Ok(resp) => {
                addresses.insert(network.id.clone(), resp.into_inner().address);
            }
            Err(e) => {
                eprintln!("Failed to get address for {}: {}", network.id, e);
            }
        }
    }

    Ok(addresses)
}