/// <summary>
/// Send more than one transaction. You have to add BitcoinBasedNode.Models, and create object. When adding single transaction, you can skip everything except address, and amount,
/// other parameters will be ignored.
/// </summary>
/// <param name="transactions">
/// Create new object OutbountTransactions.
/// </param>
/// <returns></returns>
public SendTransactionResult SendTransactions(OutboundTransactions transactions)
{
IRestRequest req = GenerateStandardRequest();
JArray parameter = new JArray();
parameter.Add("");
JObject transactionsArray = new JObject();
foreach (OutboundTransaction transaction in transactions.transactions)
{
transactionsArray.Add
(
new JProperty(transaction.address, transaction.amount)
);
}
parameter.Add(transactionsArray);
parameter.Add(transactions.minconf);
parameter.Add(transactions.comment);
parameter.Add(transactions.substractFeeFrom);
parameter.Add(transactions.replacableBip125);
parameter.Add(transactions.confTarget);
parameter.Add(transactions.estimateMode.ToString());
JObject obj = BodySkeleton("sendmany", parameter);
req.AddJsonBody(obj.ToString());
var response = client.Execute(req);
ValidateResponse(response);
SendTransactionResult result = JsonConvert.DeserializeObject <SendTransactionResult>(response.Content);;
return(result);
}
public SendTransactionResult SendTransaction(OutboundTransaction transaction)
{
IRestRequest req = new RestRequest(Method.POST);
req = addMandatoryHeader(req);
JArray parameter = new JArray();
parameter.Add(transaction.address);
parameter.Add(transaction.amount);
parameter.Add(transaction.comment);
parameter.Add(transaction.comment_to);
parameter.Add(transaction.substractfeefromamount);
parameter.Add(transaction.replacableviabip125);
parameter.Add(transaction.conf_target);
parameter.Add(transaction.estimate_mode.ToString());
JObject obj = BodySkeleton("sendtoaddress", parameter);
req.AddJsonBody(obj.ToString());
var response = client.Execute(req);
ValidateResponse(response);
SendTransactionResult res = JsonConvert.DeserializeObject <SendTransactionResult>(response.Content);
return(res);
}
/// <summary>
/// Advanced transaction sending. If you want to stay some parameters as default, just leave them, and specify values of interested parameters.
/// </summary>
/// <param name="address">
/// Bitcoin address
/// </param>
/// <param name="amount">
/// Amount to send
/// </param>
/// <param name="comment">
/// Transaction comment in string.
/// </param>
/// <param name="comment_to">
/// Comment persona.
/// </param>
/// <param name="substractFeeFromAmount">
/// Do you want to send exactly number of bitcoins? If you want to send for example whole wallet balance just use this option.
/// </param>
/// <param name="replacableBIP125">
/// Don't touch if you dont understand.
/// </param>
/// <param name="conf_target">
/// Target of confirmations in Blockchain.
/// </param>
/// <param name="estimateMode">
/// Enum value to decide how to choose fee for your transaction
/// </param>
/// <returns></returns>
public SendTransactionResult SendTransaction(string address, decimal amount, string comment = "", string comment_to = "", bool substractFeeFromAmount = false, bool replacableBIP125 = false, int conf_target = 3, ESTIMATE_MODE estimateMode = ESTIMATE_MODE.UNSET)
{
IRestRequest req = new RestRequest(Method.POST);
req = addMandatoryHeader(req);
JArray parameter = new JArray();
parameter.Add(address);
parameter.Add(amount);
parameter.Add(comment);
parameter.Add(comment_to);
parameter.Add(substractFeeFromAmount);
parameter.Add(replacableBIP125);
parameter.Add(conf_target);
parameter.Add(estimateMode.ToString());
JObject obj = BodySkeleton("sendtoaddress", parameter);
req.AddJsonBody(obj.ToString());
var response = client.Execute(req);
ValidateResponse(response);
SendTransactionResult res = JsonConvert.DeserializeObject <SendTransactionResult>(response.Content);
return(res);
}
public async Task <BaseResponse> SendTransactionAsync(Transaction tx)
{
SendTransactionResult result = await _walletJob.SendTransactionAsync(tx).ConfigureAwait(false);
if (result.Success)
{
return(new SuccessResponse());
}
else
{
return new FailureResponse {
Message = result.FailingReason, Details = ""
}
};
}
}
/// <summary>
/// Simply send transaction to address with amount.
/// </summary>
/// <param name="address">
/// Bitcoin address, it is not validating for it here.
/// </param>
/// <param name="amount">
/// amount of bitcoins you want to send in 0.00000000 format
/// </param>
/// <returns></returns>
public SendTransactionResult SendTransaction(string address, decimal amount)
{
IRestRequest req = new RestRequest(Method.POST);
req = addMandatoryHeader(req);
JArray parameter = new JArray();
parameter.Add(address);
parameter.Add(amount);
JObject obj = BodySkeleton("sendtoaddress", parameter);
req.AddJsonBody(obj.ToString());
var response = client.Execute(req);
ValidateResponse(response);
SendTransactionResult res = JsonConvert.DeserializeObject <SendTransactionResult>(response.Content);
return(res);
}
public static async Task <SendTransactionResult> SendTransactionAsync(Transaction tx)
{
var successfulResult = new SendTransactionResult
{
Success = true,
FailingReason = ""
};
Debug.WriteLine($"Transaction Id: {tx.GetHash()}");
// QBit's success response is buggy so let's check manually, too
BroadcastResponse broadcastResponse;
var success = false;
var tried = 0;
const int maxTry = 7;
do
{
tried++;
Debug.WriteLine($"Try broadcasting transaction... ({tried})");
broadcastResponse = await _qBitClient.Broadcast(tx).ConfigureAwait(false);
var getTxResp = await _qBitClient.GetTransaction(tx.GetHash()).ConfigureAwait(false);
if (getTxResp != null)
{
success = true;
break;
}
else
{
await Task.Delay(3000).ConfigureAwait(false);
}
} while(tried < maxTry);
if (!success)
{
if (broadcastResponse.Error != null)
{
// Try broadcasting with smartbit if QBit fails (QBit issue)
if (broadcastResponse.Error.ErrorCode == RejectCode.INVALID && broadcastResponse.Error.Reason == "Unknown")
{
Debug.WriteLine("Try broadcasting transaction with smartbit...");
var post = "https://testnet-api.smartbit.com.au/v1/blockchain/pushtx";
if (CurrentNetwork == Network.Main)
{
post = "https://api.smartbit.com.au/v1/blockchain/pushtx";
}
var content = new StringContent(new JObject(new JProperty("hex", tx.ToHex())).ToString(), Encoding.UTF8,
"application/json");
var resp = await _httpClient.PostAsync(post, content).ConfigureAwait(false);
var json = JObject.Parse(await resp.Content.ReadAsStringAsync().ConfigureAwait(false));
if (json.Value <bool>("success"))
{
Debug.WriteLine("Transaction is successfully propagated on the network.");
return(successfulResult);
}
else
{
Debug.WriteLine(
$"Error code: {json["error"].Value<string>("code")} Reason: {json["error"].Value<string>("message")}");
}
}
else
{
Debug.WriteLine($"Error code: {broadcastResponse.Error.ErrorCode} Reason: {broadcastResponse.Error.Reason}");
}
}
Debug.WriteLine(
"The transaction might not have been successfully broadcasted. Please check the Transaction ID in a block explorer.");
return(new SendTransactionResult
{
Success = false,
FailingReason =
"The transaction might not have been successfully broadcasted. Please check the Transaction ID in a block explorer."
});
}
Debug.WriteLine("Transaction is successfully propagated on the network.");
return(successfulResult);
}
