public override async Task SendTransaction(SendTransaction tx)
{
// var web3 = new Web3(CurrentNetwork);
var path = Environment.CurrentDirectory + $"\\ethereum{WalletName}.json";
var wallet = LoadWalletFromJsonFile(path, Password);
Account accountFrom = wallet.GetAccount(0);
var web3 = new Web3(accountFrom, CurrentNetwork);
var wei = Web3.Convert.ToWei(tx.Amount);
try
{
var transaction =
await web3.TransactionManager
.SendTransactionAsync(
accountFrom.Address,
tx.Receiver,
new HexBigInteger(wei));
var a = 1;
}
catch (Exception e)
{
throw e;
}
}
private Hash32 UpdateDaedric(Transaction tx)
{
var transactionRequest = SendTransaction.Create(_appsetting.Network_Url);
var sendResponse = transactionRequest.Invoke(tx).Result;
return(sendResponse);
}
public async Task <Transaction> SendCoin(Recipient recipient)
{
var amount = (await GetBalance()).balance / 100;
BuildTransaction buildTransaction = new BuildTransaction {
WalletName = walletName,
AccountName = accountName,
CoinType = 105,
Password = password,
DestinationAddress = recipient.address,
Amount = amount.ToString(),
FeeType = "low",
AllowUnconfirmed = true
};
var transaction = await stratApi.BuildTransaction(buildTransaction);
SendTransaction sendTransaction = new SendTransaction {
Hex = transaction.Hex
};
var resp = await stratApi.SendTransaction(sendTransaction);
return(new Transaction {
confirmation = transaction.TransactionId
});
}
public async Task <SendTransaction> SendTxAsync(Network network, string txHex)
{
List <KeyValuePair <string, string> > postParam = new List <KeyValuePair <string, string> >(new [] { new KeyValuePair <string, string>("tx_hex", txHex) });
SendTransaction response =
await PostQuery <SendTransaction, SendTransactionError>(string.Format(SendTransactionUrl, network._network), postParam);
return(response);
}
public async Task <Recipient> SendCoin(Recipient recipient)
{
if (newRecipient(recipient))
{
try
{
BuildTransaction buildTransaction = new BuildTransaction
{
WalletName = walletName,
AccountName = accountName,
CoinType = 105,
Password = password,
DestinationAddress = recipient.address,
Amount = 100m,
FeeType = "low",
AllowUnconfirmed = true
};
var transaction = await stratApi.BuildTransaction(buildTransaction);
SendTransaction sendTransaction = new SendTransaction
{
Hex = transaction.Hex
};
var resp = await stratApi.SendTransaction(sendTransaction);
recipient.is_sent = true;
UpdateRecipient(recipient);
Throttling.AddressesSeen.Enqueue(recipient.address);
Throttling.IPAddressesSeen.Enqueue(recipient.ip_address);
return(recipient);
}
catch (Refit.ApiException exc)
{
Console.WriteLine(exc.ToString());
Console.WriteLine(exc.Content);
recipient.is_error = true;
UpdateRecipient(recipient);
throw new FaucetException(ERROR_WALLET);
}
}
else
{
throw new FaucetException(ERROR_DUPE);
}
}
public async Task <Hash32> Transfer(Address to, BigInteger amount, BigInteger stepLimit, int?networkID = null)
{
var builder = new TransferTransactionBuilder();
builder.PrivateKey = PrivateKey;
builder.To = to;
builder.Value = amount;
builder.StepLimit = stepLimit;
builder.NID = networkID ?? Consts.ApiUrl.GetNetworkID(ApiUrl);
var tx = builder.Build();
var sendTransaction = new SendTransaction(ApiUrl);
return(await sendTransaction.Invoke(tx));
}
public static Hash32 Transfer(Address to, PrivateKey privateKey, BigInteger amount, BigInteger stepLimit, string Api)
{
var builder = new TransferTransactionBuilder
{
PrivateKey = privateKey,
To = to,
Value = amount,
StepLimit = stepLimit,
NID = 3
};
var tx = builder.Build();
var sendTransaction = new SendTransaction(Api);
return(sendTransaction.Invoke(tx).Result);
}
public void Test_RPCInvalidRequestException()
{
var txBuilder = new TransactionBuilder();
txBuilder.PrivateKey = PrivateKey.Random();
txBuilder.To = "hx0000000000000000000000000000000000000000";
txBuilder.StepLimit = 100000000;
txBuilder.NID = 2;
txBuilder.Value = 0;
var tx = txBuilder.Build();
var gendTransactin = new SendTransaction(Consts.ApiUrl.TestNet);
Assert.ThrowsAsync(typeof(RPCInvalidRequestException), async() => await gendTransactin.Invoke(tx));
}
public abstract Task SendTransaction(SendTransaction tx);
public override Task SendTransaction(SendTransaction txx)
{
var walletFilePath = System.Environment.CurrentDirectory + $"\\bitcoin{WalletName}.json";
var safe = Safe.Load(Password, walletFilePath);
BitcoinAddress addressToSend;
try
{
addressToSend = BitcoinAddress.Create(txx.Receiver, CurrentNetwork);
}
catch (Exception ex)
{
throw ex;
}
var operationsPerAddresses = QueryOperationsPerSafeAddresses(safe, 7);
var operationsPerNotEmptyPrivateKeys = new Dictionary <BitcoinExtKey, List <BalanceOperation> >();
foreach (var elem in operationsPerAddresses)
{
var balance = Money.Zero;
foreach (var op in elem.Value)
{
balance += op.Amount;
}
if (balance <= Money.Zero)
{
continue;
}
var secret = safe.FindPrivateKey(elem.Key);
operationsPerNotEmptyPrivateKeys.Add(secret, elem.Value);
}
Script changeScriptPubKey = null;
var operationsPerChangeAddresses = QueryOperationsPerSafeAddresses(safe, minUnusedKeys: 1, hdPathType: HdPathType.Change);
foreach (var elem in operationsPerChangeAddresses)
{
if (elem.Value.Count == 0)
{
changeScriptPubKey = safe.FindPrivateKey(elem.Key).ScriptPubKey;
}
}
if (changeScriptPubKey == null)
{
throw new ArgumentNullException();
}
var unspentCoins = GetUnspentCoins(operationsPerNotEmptyPrivateKeys.Keys);
Money fee;
try
{
const int txSizeInBytes = 250;
using (var client = new HttpClient())
{
const string request = @"https://bitcoinfees.21.co/api/v1/fees/recommended";
var result = client.GetAsync(request, HttpCompletionOption.ResponseContentRead).Result;
var json = JObject.Parse(result.Content.ReadAsStringAsync().Result);
var fastestSatoshiPerByteFee = json.Value <decimal>("fastestFee");
// fee = new Money(fastestSatoshiPerByteFee * txSizeInBytes, MoneyUnit.Satoshi);
fee = new Money(decimal.Parse("0.1"), MoneyUnit.BTC);
}
}
catch
{
throw new Exception("Can't get tx fee");
}
var availableAmount = Money.Zero;
var unconfirmedAvailableAmount = Money.Zero;
foreach (var elem in unspentCoins)
{
if (true) //todo
{
availableAmount += elem.Key.Amount;
if (!elem.Value)
{
unconfirmedAvailableAmount += elem.Key.Amount;
}
}
else
{
if (elem.Value)
{
availableAmount += elem.Key.Amount;
}
}
}
var amountToSend = ParseBtcString(txx.Amount.ToString(CultureInfo.InvariantCulture));
var totalOutAmount = amountToSend + fee;
var coinsToSpend = new HashSet <Coin>();
var unspentConfirmedCoins = new List <Coin>();
var unspentUnconfirmedCoins = new List <Coin>();
foreach (var elem in unspentCoins)
{
if (elem.Value)
{
unspentConfirmedCoins.Add(elem.Key);
}
else
{
unspentUnconfirmedCoins.Add(elem.Key);
}
}
var haveEnough = SelectCoins(ref coinsToSpend, totalOutAmount, unspentConfirmedCoins);
if (!haveEnough)
{
haveEnough = SelectCoins(ref coinsToSpend, totalOutAmount, unspentUnconfirmedCoins);
}
if (!haveEnough)
{
throw new Exception("Not enough funds.");
}
var signingKeys = new HashSet <ISecret>();
foreach (var coin in coinsToSpend)
{
foreach (var elem in operationsPerNotEmptyPrivateKeys)
{
if (elem.Key.ScriptPubKey == coin.ScriptPubKey)
{
signingKeys.Add(elem.Key);
}
}
}
var builder = new TransactionBuilder();
var tx = builder
.AddCoins(coinsToSpend)
.AddKeys(signingKeys.ToArray())
.Send(addressToSend, amountToSend)
.SetChange(changeScriptPubKey)
.SendFees(fee)
.BuildTransaction(true);
var qBitClient = new QBitNinjaClient(CurrentNetwork);
BroadcastResponse broadcastResponse;
var success = false;
var tried = 0;
const int maxTry = 7;
do
{
tried++;
broadcastResponse = qBitClient.Broadcast(tx).Result;
var getTxResp = qBitClient.GetTransaction(tx.GetHash()).Result;
if (getTxResp == null)
{
Thread.Sleep(3000);
continue;
}
else
{
success = true;
var transaction = new Transaction();
transaction.Hash = getTxResp.TransactionId.ToString();
transaction.Text =
$"Transaction ID:${txx.Count} {getTxResp.TransactionId}, sent coins {txx.Amount.ToString()}, confirms:0";
transaction.Value = txx.Amount;
// return transaction;
return(new Task(() => {}));
}
} while (tried <= maxTry);
return(null);
}
