// Create the default config
let mut config = LiquidSdk::default_config(
    LiquidNetwork::Mainnet,
    Some("<your-Breez-API-key>".to_string()),
)?;

// Configure asset metadata. Setting the optional fiat ID will enable
// paying fees using the asset (if available).
config.asset_metadata = Some(vec![
    AssetMetadata {
        asset_id: "18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec".to_string(),
        name: "PEGx EUR".to_string(),
        ticker: "EURx".to_string(),
        precision: 8,
        fiat_id: Some("EUR".to_string()),
    },
]);

// Create the default config
var config = try defaultConfig(network: LiquidNetwork.mainnet, breezApiKey: "<your-Breez-API-key>")

// Configure asset metadata. Setting the optional fiat ID will enable
// paying fees using the asset (if available).
config.assetMetadata = [
    AssetMetadata(
        assetId: "18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec",
        name: "PEGx EUR",
        ticker: "EURx",
        precision: 8,
        fiatId: "EUR"
    )
]

// Create the default config
val config : Config = defaultConfig(LiquidNetwork.MAINNET, "<your Breez API key>")

// Configure asset metadata. Setting the optional fiat ID will enable
// paying fees using the asset (if available).
config.assetMetadata = listOf(
    AssetMetadata(
        assetId = "18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec",
        name = "PEGx EUR",
        ticker = "EURx",
        precision = 8.toUByte(),
        fiatId = "EUR"
    )
)

// Create the default config
const config = defaultConfig('mainnet', '<your-Breez-API-key>')

// Configure asset metadata
config.assetMetadata = [
  {
    assetId: '18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec',
    name: 'PEGx EUR',
    ticker: 'EURx',
    precision: 8
  }
]

// Create the default config
const config = await defaultConfig(
  LiquidNetwork.MAINNET,
  '<your-Breez-API-key>'
)

// Configure asset metadata. Setting the optional fiat ID will enable
// paying fees using the asset (if available).
config.assetMetadata = [
  {
    assetId: '18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec',
    name: 'PEGx EUR',
    ticker: 'EURx',
    precision: 8,
    fiatId: 'EUR'
  }
]

// Create the default config
Config config = defaultConfig(network: LiquidNetwork.mainnet, breezApiKey: "<your-Breez-API-key>");

// Configure asset metadata. Setting the optional fiat ID will enable
// paying fees using the asset (if available).
config = config.copyWith(
  assetMetadata: [
    AssetMetadata(
      assetId: "18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec",
      name: "PEGx EUR",
      ticker: "EURx",
      precision: 8,
      fiatId: "EUR",
    ),
  ],
);

# Create the default config
config = default_config(
    network=LiquidNetwork.MAINNET,
    breez_api_key="<your-Breez-API-key>"
)

# Configure asset metadata. Setting the optional fiat ID will enable
# paying fees using the asset (if available).
config.asset_metadata = [
    AssetMetadata(
        asset_id="18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec",
        name="PEGx EUR",
        ticker="EURx",
        precision=8,
        fiat_id="EUR"
    )
]

// Create the default config
breezApiKey := "<your-Breez-API-key>"
config, err := breez_sdk_liquid.DefaultConfig(breez_sdk_liquid.LiquidNetworkMainnet, &breezApiKey)
if err != nil {
    return err
}

// Configure asset metadata. Setting the optional fiat ID will enable
// paying fees using the asset (if available).
fiatId := "EUR"
assetMetadata := []breez_sdk_liquid.AssetMetadata{
    {
        AssetId:   "18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec",
        Name:      "PEGx EUR",
        Ticker:    "EURx",
        Precision: 8,
        FiatId:    &fiatId,
    },
}
config.AssetMetadata = &assetMetadata

// Create the default config
var config = BreezSdkLiquidMethods.DefaultConfig(
    LiquidNetwork.Mainnet,
    "<your-Breez-API-key>"
) with
{
    // Configure asset metadata. Setting the optional fiat ID will enable
    // paying fees using the asset (if available).
    assetMetadata = new List<AssetMetadata>
    {
        new(
            assetId: "18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec",
            name: "PEGx EUR",
            ticker: "EURx",
            precision: 8,
            fiatId: "EUR"
        )
    }
};

let info = sdk.get_info().await?;
let asset_balances = info.wallet_info.asset_balances;

if let info = try? sdk.getInfo() {
    let assetBalances = info.walletInfo.assetBalances
    
    print(assetBalances)
}

try {
    val info = sdk.getInfo()
    val assetBalances = info?.walletInfo?.assetBalances
} catch (e: Exception) {
    // handle error
}

const info = await sdk.getInfo()
const assetBalances = info.walletInfo.assetBalances

const info = await getInfo()
const assetBalances = info.walletInfo.assetBalances

GetInfoResponse? info = await breezSDKLiquid.instance!.getInfo();
List<AssetBalance> assetBalances = info.walletInfo.assetBalances;

try:
    info = sdk.get_info()
    asset_balances = info.wallet_info.asset_balances
except Exception as error:
    logging.error(error)
    raise

if info, err := sdk.GetInfo(); err == nil {
    assetBalances := info.WalletInfo.AssetBalances
    log.Printf("Asset balances: %#v", assetBalances)
}

try
{
    var info = sdk.GetInfo();
    var assetBalances = info?.walletInfo?.assetBalances;
}
catch (Exception)
{
    // Handle error
}

// Create a Liquid BIP21 URI/address to receive an asset payment to.
// Note: Not setting the amount will generate an amountless BIP21 URI.
let usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2".to_string();
let optional_amount = Some(ReceiveAmount::Asset {
    asset_id: usdt_asset_id,
    payer_amount: Some(1.50),
});
let prepare_response = sdk
    .prepare_receive_payment(&PrepareReceiveRequest {
        payment_method: PaymentMethod::LiquidAddress,
        amount: optional_amount,
    })
    .await?;

// If the fees are acceptable, continue to create the Receive Payment
let receive_fees_sat = prepare_response.fees_sat;
info!("Fees: {} sats", receive_fees_sat);

// Create a Liquid BIP21 URI/address to receive an asset payment to.
// Note: Not setting the amount will generate an amountless BIP21 URI.
let usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
let optionalAmount = ReceiveAmount.asset(assetId: usdtAssetId, payerAmount: 1.50)
let prepareResponse = try? sdk
    .prepareReceivePayment(req: PrepareReceiveRequest(
        paymentMethod: PaymentMethod.liquidAddress,
        amount: optionalAmount
    ))

// If the fees are acceptable, continue to create the Receive Payment
let receiveFeesSat = prepareResponse!.feesSat;
print("Fees: {} sats", receiveFeesSat);

try {
    // Create a Liquid BIP21 URI/address to receive an asset payment to.
    // Note: Not setting the amount will generate an amountless BIP21 URI.
    val usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
    val optionalAmount = ReceiveAmount.Asset(usdtAssetId, 1.50)
    val prepareRequest = PrepareReceiveRequest(PaymentMethod.LIQUID_ADDRESS, optionalAmount)
    val prepareResponse = sdk.prepareReceivePayment(prepareRequest)

    // If the fees are acceptable, continue to create the Receive Payment
    val receiveFeesSat = prepareResponse.feesSat;
    // Log.v("Breez", "Fees: ${receiveFeesSat} sats")
} catch (e: Exception) {
    // handle error
}

// Create a Liquid BIP21 URI/address to receive an asset payment to.
// Note: Not setting the amount will generate an amountless BIP21 URI.
const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2'
const optionalAmount: ReceiveAmount = {
  type: 'asset',
  assetId: usdtAssetId,
  payerAmount: 1.5
}

const prepareResponse = await sdk.prepareReceivePayment({
  paymentMethod: 'liquidAddress',
  amount: optionalAmount
})

// If the fees are acceptable, continue to create the Receive Payment
const receiveFeesSat = prepareResponse.feesSat
console.log(`Fees: ${receiveFeesSat} sats`)

// Create a Liquid BIP21 URI/address to receive an asset payment to.
// Note: Not setting the amount will generate an amountless BIP21 URI.
const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2'
const optionalAmount: ReceiveAmount = {
  type: ReceiveAmountVariant.ASSET,
  assetId: usdtAssetId,
  payerAmount: 1.50
}

const prepareResponse = await prepareReceivePayment({
  paymentMethod: PaymentMethod.LIQUID_ADDRESS,
  amount: optionalAmount
})

// If the fees are acceptable, continue to create the Receive Payment
const receiveFeesSat = prepareResponse.feesSat
console.log(`Fees: ${receiveFeesSat} sats`)

// Create a Liquid BIP21 URI/address to receive an asset payment to.
// Note: Not setting the amount will generate an amountless BIP21 URI.
String usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2";
ReceiveAmount_Asset optionalAmount = ReceiveAmount_Asset(assetId: usdtAssetId, payerAmount: 1.50);
PrepareReceiveResponse prepareResponse = await breezSDKLiquid.instance!.prepareReceivePayment(
  req: PrepareReceiveRequest(
    paymentMethod: PaymentMethod.liquidAddress,
    amount: optionalAmount,
  ),
);

// If the fees are acceptable, continue to create the Receive Payment
BigInt receiveFeesSat = prepareResponse.feesSat;
print("Fees: $receiveFeesSat sats");

try:
    # Create a Liquid BIP21 URI/address to receive an asset payment to.
    # Note: Not setting the amount will generate an amountless BIP21 URI.
    usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
    optional_amount = ReceiveAmount.ASSET(usdt_asset_id, 1.50)
    prepare_request = PrepareReceiveRequest(
        payment_method=PaymentMethod.LIQUID_ADDRESS,
        amount=optional_amount
    )
    prepare_response = sdk.prepare_receive_payment(prepare_request)

    # If the fees are acceptable, continue to create the Receive Payment
    receive_fees_sat = prepare_response.fees_sat
    logging.debug(f"Fees: {receive_fees_sat} sats")
    return prepare_response
except Exception as error:
    logging.error(error)
    raise

// Create a Liquid BIP21 URI/address to receive an asset payment to.
// Note: Not setting the amount will generate an amountless BIP21 URI.
usdtAssetId := "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
payerAmount := float64(1.50)
var optionalAmount breez_sdk_liquid.ReceiveAmount = breez_sdk_liquid.ReceiveAmountAsset{
    AssetId:     usdtAssetId,
    PayerAmount: &payerAmount,
}
prepareRequest := breez_sdk_liquid.PrepareReceiveRequest{
    PaymentMethod: breez_sdk_liquid.PaymentMethodLiquidAddress,
    Amount:        &optionalAmount,
}
if prepareResponse, err := sdk.PrepareReceivePayment(prepareRequest); err == nil {
    // If the fees are acceptable, continue to create the Receive Payment
    receiveFeesSat := prepareResponse.FeesSat
    log.Printf("Fees: %v sats", receiveFeesSat)
}

try
{
    // Create a Liquid BIP21 URI/address to receive an asset payment to.
    // Note: Not setting the amount will generate an amountless BIP21 URI.
    var usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2";
    var optionalAmount = new ReceiveAmount.Asset(usdtAssetId, 1.50);
    var prepareRequest = new PrepareReceiveRequest(PaymentMethod.LiquidAddress, optionalAmount);
    var prepareResponse = sdk.PrepareReceivePayment(prepareRequest);

    // If the fees are acceptable, continue to create the Receive Payment
    var receiveFeesSat = prepareResponse.feesSat;
    Console.WriteLine($"Fees: {receiveFeesSat} sats");
}
catch (Exception)
{
    // Handle error
}

// Set the Liquid BIP21 or Liquid address you wish to pay
let destination = "<Liquid BIP21 or address>".to_string();
// If the destination is an address or an amountless BIP21 URI,
// you must specify an asset amount
let usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2".to_string();
let optional_amount = Some(PayAmount::Asset {
    asset_id: usdt_asset_id,
    receiver_amount: Some(1.50),
    estimate_asset_fees: Some(false),
});
let prepare_response = sdk
    .prepare_send_payment(&PrepareSendRequest {
        destination,
        amount: optional_amount,
    })
    .await?;

// If the fees are acceptable, continue to create the Send Payment
let send_fees_sat = prepare_response.fees_sat;
info!("Fees: {:?} sats", send_fees_sat);

// Set the Liquid BIP21 or Liquid address you wish to pay
let destination = "<Liquid BIP21 or address>"
// If the destination is an address or an amountless BIP21 URI,
// you must specify an asset amount
let usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
let optionalAmount = PayAmount.asset(
    assetId: usdtAssetId,
    receiverAmount: 1.50,
    estimateAssetFees: false
)
let prepareResponse = try? sdk
    .prepareSendPayment(req: PrepareSendRequest (
        destination: destination,
        amount: optionalAmount
    ))

// If the fees are acceptable, continue to create the Send Payment
let sendFeesSat = prepareResponse!.feesSat
print("Fees: {} sats", sendFeesSat);

// Set the Liquid BIP21 or Liquid address you wish to pay
val destination = "<Liquid BIP21 or address>"
try {
    // Create a Liquid BIP21 URI/address to receive an asset payment to.
    // Note: Not setting the amount will generate an amountless BIP21 URI.
    val usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
    val optionalAmount = PayAmount.Asset(usdtAssetId, 1.50, false)
    val prepareResponse = sdk.prepareSendPayment(PrepareSendRequest(destination, optionalAmount))

    // If the fees are acceptable, continue to create the Send Payment
    val sendFeesSat = prepareResponse.feesSat;
    // Log.v("Breez", "Fees: ${sendFeesSat} sats")
} catch (e: Exception) {
    // handle error
}

// Set the Liquid BIP21 or Liquid address you wish to pay
const destination = '<Liquid BIP21 or address>'
// If the destination is an address or an amountless BIP21 URI,
// you must specify an asset amount

const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2'
const optionalAmount: PayAmount = {
  type: 'asset',
  assetId: usdtAssetId,
  receiverAmount: 1.5,
  estimateAssetFees: false
}

const prepareResponse = await sdk.prepareSendPayment({
  destination,
  amount: optionalAmount
})

// If the fees are acceptable, continue to create the Send Payment
const sendFeesSat = prepareResponse.feesSat
console.log(`Fees: ${sendFeesSat} sats`)

// Set the Liquid BIP21 or Liquid address you wish to pay
const destination = '<Liquid BIP21 or address>'
// If the destination is an address or an amountless BIP21 URI,
// you must specify an asset amount

const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2'
const optionalAmount: PayAmount = {
  type: PayAmountVariant.ASSET,
  assetId: usdtAssetId,
  receiverAmount: 1.50,
  estimateAssetFees: false
}

const prepareResponse = await prepareSendPayment({
  destination,
  amount: optionalAmount
})

// If the fees are acceptable, continue to create the Send Payment
const sendFeesSat = prepareResponse.feesSat
console.log(`Fees: ${sendFeesSat} sats`)

// Set the Liquid BIP21 or Liquid address you wish to pay
String destination = "<Liquid BIP21 or address>";
// If the destination is an address or an amountless BIP21 URI,
// you must specify an asset amount
String usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2";
PayAmount_Asset optionalAmount = PayAmount_Asset(
  assetId: usdtAssetId,
  receiverAmount: 1.50,
  estimateAssetFees: false,
);
PrepareSendRequest prepareSendRequest = PrepareSendRequest(
  destination: destination,
  amount: optionalAmount,
);

PrepareSendResponse prepareSendResponse = await breezSDKLiquid.instance!.prepareSendPayment(
  req: prepareSendRequest,
);

// If the fees are acceptable, continue to create the Send Payment
BigInt? sendFeesSat = prepareSendResponse.feesSat;
print("Fees: $sendFeesSat sats");

# Set the Liquid BIP21 or Liquid address you wish to pay
destination = "<Liquid BIP21 or address>"
try:
    # If the destination is an address or an amountless BIP21 URI,
    # you must specify an asset amount
    usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
    optional_amount = PayAmount.ASSET(usdt_asset_id, 1.50, False)
    prepare_response = sdk.prepare_send_payment(PrepareSendRequest(destination, optional_amount))

    # If the fees are acceptable, continue to create the Send Payment
    send_fees_sat = prepare_response.fees_sat
    logging.debug(f"Fees: {send_fees_sat} sats")
    return prepare_response
except Exception as error:
    logging.error(error)
    raise

// Set the Liquid BIP21 or Liquid address you wish to pay
destination := "<Liquid BIP21 or address>"
// If the destination is an address or an amountless BIP21 URI,
// you must specify an asset amount
usdtAssetId := "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
receiverAmount := float64(1.50)
estimateAssetFees := false
var optionalAmount breez_sdk_liquid.PayAmount = breez_sdk_liquid.PayAmountAsset{
    AssetId:           usdtAssetId,
    ReceiverAmount:    receiverAmount,
    EstimateAssetFees: &estimateAssetFees,
}

prepareRequest := breez_sdk_liquid.PrepareSendRequest{
    Destination: destination,
    Amount:      &optionalAmount,
}
prepareResponse, err := sdk.PrepareSendPayment(prepareRequest)
if err != nil {
    log.Printf("Error: %#v", err)
    return
}

sendFeesSat := prepareResponse.FeesSat
log.Printf("Fees: %v sats", sendFeesSat)

// Set the Liquid BIP21 or address you wish to pay
var destination = "<Liquid BIP21 or address>";
try
{
    // If the destination is an address or an amountless BIP21 URI,
    // you must specify an asset amount
    var usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2";
    var optionalAmount = new PayAmount.Asset(usdtAssetId, 1.50, false);
    var prepareResponse = sdk.PrepareSendPayment(new PrepareSendRequest(destination, optionalAmount));

    // If the fees are acceptable, continue to create the Send Payment
    var sendFeesSat = prepareResponse.feesSat;
    Console.WriteLine($"Fees: {sendFeesSat} sats");
}
catch (Exception)
{
    // Handle error
}

let destination = "<Liquid BIP21 or address>".to_string();
let usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2".to_string();
// Set the optional estimate asset fees param to true
let optional_amount = Some(PayAmount::Asset {
    asset_id: usdt_asset_id,
    receiver_amount: Some(1.50),
    estimate_asset_fees: Some(true),
});
let prepare_response = sdk
    .prepare_send_payment(&PrepareSendRequest {
        destination,
        amount: optional_amount,
    })
    .await?;

// If the asset fees are set, you can use these fees to pay to send the asset
let send_asset_fees = prepare_response.estimated_asset_fees;
info!("Estimated Fees: ~{:?}", send_asset_fees);

// If the asset fess are not set, you can use the sats fees to pay to send the asset
let send_fees_sat = prepare_response.fees_sat;
info!("Fees: {:?} sats", send_fees_sat);

let destination = "<Liquid BIP21 or address>"
let usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
// Set the optional estimate asset fees param to true
let optionalAmount = PayAmount.asset(
    assetId: usdtAssetId,
    receiverAmount: 1.50,
    estimateAssetFees: true
)
let prepareResponse = try? sdk
    .prepareSendPayment(req: PrepareSendRequest (
        destination: destination,
        amount: optionalAmount
    ))

// If the asset fees are set, you can use these fees to pay to send the asset
let sendAssetFees = prepareResponse!.estimatedAssetFees
print("Estimated Fees: ~{}", sendAssetFees);

// If the asset fess are not set, you can use the sats fees to pay to send the asset
let sendFeesSat = prepareResponse!.feesSat
print("Fees: {} sats", sendFeesSat);

val destination = "<Liquid BIP21 or address>"
try {
    val usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
    // Set the optional estimate asset fees param to true
    val optionalAmount = PayAmount.Asset(usdtAssetId, 1.50, true)
    val prepareResponse = sdk.prepareSendPayment(PrepareSendRequest(destination, optionalAmount))

    // If the asset fees are set, you can use these fees to pay to send the asset
    val sendAssetFees = prepareResponse.estimatedAssetFees;
    // Log.v("Breez", "Estimated Fees: ~${sendAssetFees}")
    
    // If the asset fess are not set, you can use the sats fees to pay to send the asset
    val sendFeesSat = prepareResponse.feesSat;
    // Log.v("Breez", "Fees: ${sendFeesSat} sats")
} catch (e: Exception) {
    // handle error
}

const destination = '<Liquid BIP21 or address>'
const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2'
// Set the optional estimate asset fees param to true
const optionalAmount: PayAmount = {
  type: 'asset',
  assetId: usdtAssetId,
  receiverAmount: 1.50,
  estimateAssetFees: true
}

const prepareResponse = await sdk.prepareSendPayment({
  destination,
  amount: optionalAmount
})

// If the asset fees are set, you can use these fees to pay to send the asset
const sendAssetFees = prepareResponse.estimatedAssetFees
console.log(`Estimated Fees: ~${sendAssetFees}`)

// If the asset fess are not set, you can use the sats fees to pay to send the asset
const sendFeesSat = prepareResponse.feesSat
console.log(`Fees: ${sendFeesSat} sats`)

const destination = '<Liquid BIP21 or address>'
const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2'
// Set the optional estimate asset fees param to true
const optionalAmount: PayAmount = {
  type: PayAmountVariant.ASSET,
  assetId: usdtAssetId,
  receiverAmount: 1.50,
  estimateAssetFees: true
}

const prepareResponse = await prepareSendPayment({
  destination,
  amount: optionalAmount
})

// If the asset fees are set, you can use these fees to pay to send the asset
const sendAssetFees = prepareResponse.estimatedAssetFees
console.log(`Estimated Fees: ~${sendAssetFees}`)

// If the asset fess are not set, you can use the sats fees to pay to send the asset
const sendFeesSat = prepareResponse.feesSat
console.log(`Fees: ${sendFeesSat} sats`)

String destination = "<Liquid BIP21 or address>";
String usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2";
// Set the optional estimate asset fees param to true
PayAmount_Asset optionalAmount = PayAmount_Asset(
  assetId: usdtAssetId,
  receiverAmount: 1.50,
  estimateAssetFees: true,
);
PrepareSendRequest prepareSendRequest = PrepareSendRequest(
  destination: destination,
  amount: optionalAmount,
);

PrepareSendResponse prepareSendResponse = await breezSDKLiquid.instance!.prepareSendPayment(
  req: prepareSendRequest,
);

// If the asset fees are set, you can use these fees to pay to send the asset
double? sendAssetFees = prepareSendResponse.estimatedAssetFees;
print("Estimated Fees: ~$sendAssetFees");

// If the asset fess are not set, you can use the sats fees to pay to send the asset
BigInt? sendFeesSat = prepareSendResponse.feesSat;
print("Fees: $sendFeesSat sats");

destination = "<Liquid BIP21 or address>"
try:
    usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
    # Set the optional estimate asset fees param to true
    optional_amount = PayAmount.ASSET(usdt_asset_id, 1.50, True)
    prepare_response = sdk.prepare_send_payment(PrepareSendRequest(destination, optional_amount))

    # If the asset fees are set, you can use these fees to pay to send the asset
    send_asset_fees = prepare_response.estimated_asset_fees
    logging.debug(f"Estimated Fees: ~{send_asset_fees}")

    # If the asset fess are not set, you can use the sats fees to pay to send the asset
    send_fees_sat = prepare_response.fees_sat
    logging.debug(f"Fees: {send_fees_sat} sats")
    return prepare_response
except Exception as error:
    logging.error(error)
    raise

destination := "<Liquid BIP21 or address>"
usdtAssetId := "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
receiverAmount := float64(1.50)
// Set the optional estimate asset fees param to true
estimateAssetFees := true
var optionalAmount breez_sdk_liquid.PayAmount = breez_sdk_liquid.PayAmountAsset{
    AssetId:           usdtAssetId,
    ReceiverAmount:    receiverAmount,
    EstimateAssetFees: &estimateAssetFees,
}

prepareRequest := breez_sdk_liquid.PrepareSendRequest{
    Destination: destination,
    Amount:      &optionalAmount,
}
prepareResponse, err := sdk.PrepareSendPayment(prepareRequest)
if err != nil {
    log.Printf("Error: %#v", err)
    return
}

// If the asset fees are set, you can use these fees to pay to send the asset
sendAssetFees := prepareResponse.EstimatedAssetFees
log.Printf("Estimated Fees: ~%v", sendAssetFees)

// If the asset fess are not set, you can use the sats fees to pay to send the asset
sendFeesSat := prepareResponse.FeesSat
log.Printf("Fees: %v sats", sendFeesSat)

var destination = "<Liquid BIP21 or address>";
try
{
    var usdtAssetId = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2";
    // Set the optional estimate asset fees param to true
    var optionalAmount = new PayAmount.Asset(usdtAssetId, 1.50, true);
    var prepareResponse = sdk.PrepareSendPayment(new PrepareSendRequest(destination, optionalAmount));

    // If the asset fees are set, you can use these fees to pay to send the asset
    var sendAssetFees = prepareResponse.estimatedAssetFees;
    Console.WriteLine($"Estimated Fees: ~{sendAssetFees}");

    // If the asset fess are not set, you can use the sats fees to pay to send the asset
    var sendFeesSat = prepareResponse.feesSat;
    Console.WriteLine($"Fees: {sendFeesSat} sats");
}
catch (Exception)
{
    // Handle error
}

// Set the use asset fees param to true
let send_response = sdk
    .send_payment(&SendPaymentRequest {
        prepare_response,
        use_asset_fees: Some(true),
    })
    .await?;
let payment = send_response.payment;

// Set the use asset fees param to true
let sendResponse = try? sdk.sendPayment(req: SendPaymentRequest (
    prepareResponse: prepareResponse,
    useAssetFees: true
))
let payment = sendResponse!.payment

try {
    // Set the use asset fees param to true
    val sendResponse = sdk.sendPayment(SendPaymentRequest(prepareResponse, true))
    val payment = sendResponse.payment
} catch (e: Exception) {
    // handle error
}

// Set the use asset fees param to true
const sendResponse = await sdk.sendPayment({
  prepareResponse,
  useAssetFees: true
})
const payment = sendResponse.payment

// Set the use asset fees param to true
const sendResponse = await sendPayment({
  prepareResponse,
  useAssetFees: true
})
const payment = sendResponse.payment

// Set the use asset fees param to true
SendPaymentResponse sendPaymentResponse = await breezSDKLiquid.instance!.sendPayment(
  req: SendPaymentRequest(prepareResponse: prepareResponse, useAssetFees: true),
);
Payment payment = sendPaymentResponse.payment;

try:
    # Set the use asset fees param to true
    send_response = sdk.send_payment(SendPaymentRequest(prepare_response, True))
    payment = send_response.payment
except Exception as error:
    logging.error(error)
    raise

// Set the use asset fees param to true
useAssetFees := true
req := breez_sdk_liquid.SendPaymentRequest{
    PrepareResponse: prepareResponse,
    UseAssetFees:    &useAssetFees,
}
if response, err := sdk.SendPayment(req); err == nil {
    payment := response.Payment
    log.Printf("Payment: %#v", payment)
}

try
{
    // Set the use asset fees param to true
    var sendRequest = new SendPaymentRequest(prepareResponse, true);
    var sendResponse = sdk.SendPayment(sendRequest);
    var payment = sendResponse.payment;
}
catch (Exception)
{
    // Handle error
}