public override Task <string> SendTransactionAsync(TransactionInput transactionInput)
{
if (transactionInput == null)
{
throw new ArgumentNullException(nameof(transactionInput));
}
return(SignAndSendTransactionAsync(transactionInput));
}
private TransactionInput BuildTransaction <TConstructorParams>(string contractByteCode, string from,
HexBigInteger gas, TConstructorParams inputParams)
{
var encodedData = _constructorCallEncoder.EncodeRequest(inputParams, contractByteCode);
var transaction = new TransactionInput(encodedData, gas, from);
return(transaction);
}
public TransactionInput BuildTransaction <TConstructorParams>(string contractByteCode, string from,
HexBigInteger gas, HexBigInteger gasPrice, HexBigInteger value, TConstructorParams inputParams)
{
var encodedData = _constructorCallEncoder.EncodeRequest(inputParams, contractByteCode);
var transaction = new TransactionInput(encodedData, null, from, gas, gasPrice, value);
return(transaction);
}
public TransactionInput BuildTransaction <TConstructorParams>(string contractByteCode, string from,
TConstructorParams inputParams)
{
var encodedData = _constructorCallEncoder.EncodeRequest(inputParams, contractByteCode);
var transaction = new TransactionInput(encodedData, null, from);
return(transaction);
}
public RpcRequest BuildRequest(TransactionInput input, object id = null)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
return(base.BuildRequest(id, input));
}
public async Task <HexBigInteger> GetGasPriceAsync(TransactionInput transactionInput)
{
//if (transactionInput.GasPrice != null) return transactionInput.GasPrice;
//if (DefaultGasPrice >= 0) return new HexBigInteger(DefaultGasPrice);
var ethGetGasPrice = new EthGasPrice(Client);
return(await ethGetGasPrice.SendRequestAsync().ConfigureAwait(false));
}
public Task <string> SendTransactionAsync(TFunctionInput functionInput,
TransactionInput input)
{
var encodedInput = GetData(functionInput);
input.Data = encodedInput;
return(base.SendTransactionAsync(input));
}
public Task <TransactionReceipt> SendTransactionAndWaitForReceiptAsync(TFunctionInput functionInput,
TransactionInput input, CancellationTokenSource receiptRequestCancellationToken = null)
{
var encodedInput = GetData(functionInput);
input.Data = encodedInput;
return(base.SendTransactionAndWaitForReceiptAsync(input, receiptRequestCancellationToken));
}
public void Initialise(TransactionInput transactionInput)
{
this.AddressTo = transactionInput.To;
this.AmountInEther = Web3.Web3.Convert.FromWei(transactionInput.Value.Value);
this.Data = transactionInput.Data;
this.Gas = (ulong)transactionInput.Gas.Value;
this.GasPrice = Web3.Web3.Convert.FromWei(transactionInput.GasPrice.Value, Nethereum.Util.UnitConversion.EthUnit.Gwei);
}
public TransactionInput BuildTransaction(string abi, string contractByteCode, string from, HexBigInteger gas, HexBigInteger gasPrice,
HexBigInteger value, object[] values)
{
var encodedData = BuildEncodedData(abi, contractByteCode, values);
var transaction = new TransactionInput(encodedData, null, from, gas, gasPrice, value);
return(transaction);
}
private TransactionInput BuildTransaction(string abi, string contractByteCode, string from, HexBigInteger gas,
object[] values)
{
var encodedData = BuildEncodedData(abi, contractByteCode, values);
var transaction = new TransactionInput(encodedData, gas, from);
return(transaction);
}
public Task <string> SendRequestAsync(TransactionInput input, object id = null)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
return(base.SendRequestAsync(id, input));
}
private Transaction MakeTransaction(Dictionary <string, List <UTXO> > dic_UTXO, string fromAddress, string targetAddress, Hash256 asset, decimal sendCount)
{
//从字典取出utxo列表
List <UTXO> uTXOs = dic_UTXO[asset.ToString()];
Transaction transaction = new Transaction();
decimal count = decimal.Zero;
List <TransactionInput> transactionInputs = new List <TransactionInput>();
for (int i = 0; i < uTXOs.Count; i++)
{
TransactionInput transactionInput = new TransactionInput();
transactionInput.hash = uTXOs[i].txid;
transactionInput.index = (ushort)uTXOs[i].n;
transactionInputs.Add(transactionInput);
count += uTXOs[i].value;
if (count >= sendCount)
{
break;
}
}
transaction.inputs = transactionInputs.ToArray();
//输入大于等于输出
if (count >= sendCount)
{
List <TransactionOutput> transactionOutputs = new List <TransactionOutput>();
//输出
if (sendCount > decimal.Zero)
{
TransactionOutput transactionOutput = new TransactionOutput();
transactionOutput.assetId = asset;
transactionOutput.value = sendCount;
transactionOutput.toAddress = Helper.GetPublicKeyHashFromAddress(targetAddress);
transactionOutputs.Add(transactionOutput);
}
//找零
decimal change = count - sendCount;
if (change > decimal.Zero)
{
TransactionOutput transactionOutput = new TransactionOutput();
transactionOutput.toAddress = Helper.GetPublicKeyHashFromAddress(fromAddress);
transactionOutput.value = change;
transactionOutput.assetId = asset;
transactionOutputs.Add(transactionOutput);
}
transaction.outputs = transactionOutputs.ToArray();
}
else
{
throw new Exception("余额不足!");
}
return(transaction);
}
public async Task <dynamic> ExecuteTestAsync(RpcClient client)
{
//The compiled solidity contract to be deployed
//contract test { function multiply(uint a) returns(uint d) { return a * 7; } }
var contractByteCode = "0x606060405260728060106000396000f360606040526000357c010000000000000000000000000000000000000000000000000000000090048063c6888fa1146037576035565b005b604b60048080359060200190919050506061565b6040518082815260200191505060405180910390f35b6000600782029050606d565b91905056";
//Create a new Eth Send Transanction RPC Handler
var ethSendTransation = new EthSendTransaction(client);
//As the input the compiled contract is the Data, together with our address
var transactionInput = new TransactionInput();
transactionInput.Data = contractByteCode;
transactionInput.From = "0x12890d2cce102216644c59dae5baed380d84830c";
// retrieve the hash
var transactionHash = await ethSendTransation.SendRequestAsync(transactionInput);
//the contract should be mining now
//get contract address
var ethGetTransactionReceipt = new EthGetTransactionReceipt(client);
TransactionReceipt receipt = null;
//wait for the contract to be mined to the address
while (receipt == null)
{
receipt = await ethGetTransactionReceipt.SendRequestAsync(transactionHash);
}
//Encode and build function parameters
var function = new FunctionCallEncoder();
//Input the function method Sha3Encoded (4 bytes)
var sha3Signature = "c6888fa1";
//Define input parameters
var inputParameters = new[] { new Parameter("uint", "a") };
//encode the function call (function + parameter input)
//using 69 as the input
var functionCall = function.EncodeRequest(sha3Signature, inputParameters, 69);
//reuse the transaction input, (just the address)
//the destination address is the contract address
transactionInput.To = receipt.ContractAddress;
//use as data the function call
transactionInput.Data = functionCall;
// rpc method to do the call
var ethCall = new EthCall(client);
// call and get the result
var resultFunction = await ethCall.SendRequestAsync(transactionInput);
// decode the output
var functionDecoder = new FunctionCallDecoder();
var output = functionDecoder.DecodeOutput <int>(resultFunction, new Parameter("uint", "d"));
//visual test
return("The result of deploying a contract and calling a function to multiply 7 by 69 is: " + output + " and should be 483");
}
public Block GenerateBlock(
ByteArray blockHash,
ByteArray transactionHash,
InputInfo[] inputs,
OutputInfo[] outputs)
{
BlockHeader blockHeader = new BlockHeader()
{
BlockHash = blockHash,
BlockNonce = 0,
BlockTargetDifficulty = 0,
BlockTimestamp = this.GetCurrentBlockTimeStamp(),
BlockTimestampUnix = 0,
BlockVersion = 1,
MerkleRootHash = ByteArray.Empty,
PreviousBlockHash = this.previousBlockHash,
};
this.blockTimeStamp = this.blockTimeStamp.AddDays(1);
string expectedFileName = string.Format(CultureInfo.InvariantCulture, "blk{0:00000}.dat", this.GetCurentBlockchainFileIndex());
Block block = new Block(expectedFileName, blockHeader);
Transaction transaction = new Transaction()
{
TransactionHash = transactionHash,
TransactionLockTime = 0,
TransactionVersion = 1,
};
foreach (InputInfo inputInfo in inputs)
{
TransactionInput transactionInput = new TransactionInput()
{
InputScript = ByteArray.Empty,
SourceTransactionHash = inputInfo.SourceTransactionHash,
SourceTransactionOutputIndex = inputInfo.SourceTransactionOutputIndex,
};
transaction.AddInput(transactionInput);
}
foreach (OutputInfo outputInfo in outputs)
{
TransactionOutput transactionOutput = new TransactionOutput()
{
OutputScript = ByteArray.Empty,
OutputValueSatoshi = (ulong)(outputInfo.OutputValueSatoshi * DatabaseGenerator.BtcToSatoshi),
};
transaction.AddOutput(transactionOutput);
}
block.AddTransaction(transaction);
this.previousBlockHash = block.BlockHeader.BlockHash;
return(block);
}
public override void Run(string[] args)
{
var cmdArgs = this.ParseArgs(args);
var rootAccount = new Account(RootPrivateKey);
var rootWeb3 = new Web3(rootAccount, Rpcclient);
var contract = rootWeb3.Eth.GetContract(Abi, _contractAddress);
var function = contract.GetFunction("Batch");
var count = 0;
using (var fr = new StreamReader(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "acc.txt"))) {
List <string> adds = new List <string>();
while (true)
{
var line = fr.ReadLine();
if (string.IsNullOrEmpty(line))
{
break;
}
var addr = line.Split(",")[0];
adds.Add(addr);
var accountNum = 200;
if (adds.Count == accountNum)
{
try {
var gas = function.EstimateGasAsync(RootPubAddress,
new HexBigInteger(100000000),
new HexBigInteger(Web3.Convert.ToWei(10000, UnitConversion.EthUnit.Ether)),
new object[] { adds.ToArray() }).Result;
var ti = new TransactionInput()
{
From = RootPubAddress,
Gas = new HexBigInteger(gas.Value),
Value = new HexBigInteger(Web3.Convert.ToWei(10000, UnitConversion.EthUnit.Ether)),
GasPrice = new HexBigInteger(Web3.Convert.ToWei(2, UnitConversion.EthUnit.Gwei)),
To = _contractAddress
};
var ret = function.SendTransactionAndWaitForReceiptAsync(ti, null, new object[] { adds.ToArray() }).Result;
count += accountNum;
Console.WriteLine($"process count {count} cur status {ret.Status.Value}");
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}
adds.Clear();
}
}
}
}
public override Task <string> SendTransactionAsync(TransactionInput transactionInput,
CancellationToken cancellationToken = default(CancellationToken))
{
if (transactionInput == null)
{
throw new ArgumentNullException(nameof(transactionInput));
}
return(SignAndSendTransactionAsync(transactionInput, cancellationToken));
}
private TransactionInput BuildTransaction(string abi, string contractByteCode, string from, object[] values)
{
var contract = abiDeserialiser.DeserialiseContract(abi);
var encodedData = constructorCallEncoder.EncodeRequest(contractByteCode,
contract.Constructor.InputParameters, values);
var transaction = new TransactionInput(encodedData, null, from);
return(transaction);
}
public string SignTransaction(TransactionInput transaction)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
SetDefaultGasPriceAndCostIfNotSet(transaction);
return(_transactionSigner.SignTransaction((Account)Account, transaction, ChainId, FeeCurrency, GatewayFeeRecipient, GatewayFee));
}
public async Task <string> Transfer(string fromAccount, string toAccount, HexBigInteger value, HexBigInteger gas, HexBigInteger gasPrice)
{
TransactionInput ti = new TransactionInput(null,
toAccount,
fromAccount,
gas, gasPrice, value);
return(await web3.Eth.Transactions.SendTransaction.SendRequestAsync(ti));
}
/// Sets the DNA based on the input fields
/// 1. Estimate Gas parameter
/// 2. Send transaction
/// 3. Wait for receipt
private IEnumerator SetDNA()
{
string wallet = inputWallet.text;
string privateKey = inputPrivateKey.text;
var contract = new Contract(null, itemManagerABI, itemManagerContractAddress);
var function = contract.GetFunction("setDNA");
EthEstimateGasUnityRequest estimateRequest = new EthEstimateGasUnityRequest(url);
// convert string to hex to work the same way as Javascript Example
string id = int.Parse(inputSetDNAItemID.text).ToString("x");
string hexString = System.Numerics.BigInteger.Parse(inputSetDNADNA.text).ToString("x");
TransactionInput estimateInput = function.CreateTransactionInput(wallet, id, hexString);
yield return(estimateRequest.SendRequest(estimateInput));
if (estimateRequest.Exception != null)
{
Debug.Log(estimateRequest.Exception);
yield break;
}
Debug.Log("Gas: " + estimateRequest.Result.Value);
var req = new TransactionSignedUnityRequest(url, privateKey, wallet);
var callInput = function.CreateTransactionInput(
wallet,
estimateRequest.Result,
new HexBigInteger("0x0"),
id,
hexString);
yield return(req.SignAndSendTransaction(callInput));
textSetDNAStatus.text = "waiting";
var receiptRequest = new EthGetTransactionReceiptUnityRequest(url);
bool done = false;
while (!done)
{
yield return(receiptRequest.SendRequest(req.Result));
if (receiptRequest.Result != null)
{
done = true;
}
yield return(new WaitForSeconds(1.0f));
}
textSetDNAStatus.text = "done";
}
protected TransactionInput CreateTransactionInput(string encodedFunctionCall, string from)
{
var tx = new TransactionInput(encodedFunctionCall, ContractAddress)
{
From = @from
};
return(tx);
}
public TransactionInput BuildTransaction(HexBigInteger type, string abi, string contractByteCode, string from, HexBigInteger gas, HexBigInteger maxFeePerGas, HexBigInteger maxPriorityFeePerGas,
HexBigInteger value, HexBigInteger nonce, object[] values)
{
var encodedData = BuildEncodedData(abi, contractByteCode, values);
var transaction = new TransactionInput(type, encodedData, null, from, gas, value, maxFeePerGas, maxPriorityFeePerGas);
transaction.Nonce = nonce;
return(transaction);
}
public TransactionInput BuildTransaction <TConstructorParams>(HexBigInteger type, string contractByteCode, string from, HexBigInteger gas, HexBigInteger maxFeePerGas, HexBigInteger maxPriorityFeePerGas,
HexBigInteger value, HexBigInteger nonce, TConstructorParams inputParams)
{
var encodedData = _constructorCallEncoder.EncodeRequest(inputParams, contractByteCode);
var transaction = new TransactionInput(type, encodedData, null, from, gas, value, maxFeePerGas, maxPriorityFeePerGas);
transaction.Nonce = nonce;
return(transaction);
}
private async Task <string> RelayTransaction(
Relay relay,
TransactionInput transaction,
string hubAddress)
{
var nonce = await _relayHubManager
.GetNonceAsync(hubAddress, transaction.From)
.ConfigureAwait(false);
var hash = GetTransactionHash(
transaction.From,
transaction.To,
transaction.Data,
relay.Fee,
transaction.GasPrice.Value,
transaction.Gas.Value,
nonce,
hubAddress,
relay.Address);
var signer = new EthereumMessageSigner();
var signature = signer.Sign(hash.HexToByteArray(), _privateKey);
var approvalDataSig = signer.Sign(
GetApprovalData(
transaction,
relay.Fee,
transaction.GasPrice.Value,
transaction.Gas.Value,
nonce,
hubAddress,
relay.Address),
_privateKey);
var transactionCount = await _ethApiContractService.Transactions.GetTransactionCount
.SendRequestAsync(relay.Address)
.ConfigureAwait(false);
var relayMaxNonce = transactionCount.Value + new BigInteger(_options.AllowedRelayNonceGap);
var txHash = await SendViaRelay(
relay.Url,
transaction,
relay.Fee,
transaction.GasPrice.Value,
transaction.Gas.Value,
nonce,
hubAddress,
relay.Address,
signature,
approvalDataSig,
relayMaxNonce)
.ConfigureAwait(false);
return(txHash);
}
public TransactionInput GetTransferEtherInput(string data, string toAddress, HexBigInteger gas, HexBigInteger gasPrice, HexBigInteger value)
{
TransactionInput input = new TransactionInput(
data,
toAddress,
publicAddress,
gas, gasPrice, value);
return(input);
}
public override Task <string> SendTransactionAsync(TransactionInput transactionInput)
{
transactionInput.From = Account.Address;
if (transactionInput.Gas == null)
{
transactionInput.Gas = new HexBigInteger(0);
}
transactionInput.Gas = new HexBigInteger(transactionInput.Gas.Value + DefaultGasIncrement);
return(base.SendTransactionAsync(transactionInput));
}
public override Task <string> SendTransactionAsync(string from, string to, HexBigInteger amount)
{
if (!from.IsTheSameAddress(Account.Address))
{
throw new Exception("Invalid account used");
}
var transactionInput = new TransactionInput(null, to, from, null, null, amount);
return(SendTransactionAsync(transactionInput));
}
public string SignTransaction(TransactionInput transaction)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
SetDefaultGasIfNotSet(transaction);
return(_transactionSigner.SignTransaction((Account)Account, transaction, ChainId));
}
public override async Task <string> SendTransactionAsync(string from, string to, HexBigInteger amount)
{
if (from != Account.Address)
{
throw new Exception("Invalid account used");
}
var transactionInput = new TransactionInput(from, to, amount);
return(await SendTransactionAsync(transactionInput));
}
public ActionResult Save(TransactionInput input)
{
// Save the transaction
Transaction transaction = new Transaction()
{
AccountId = Guid.Empty,
Description = input.Description,
Date = input.Date,
Amount = input.Amount,
DateEntered = DateTime.Now
};
bool result = Repository.SetTransaction(transaction);
if (Request.IsAjaxRequest())
{
return Index("");
}
return RedirectToAction("Index");
}
public TestWindow(Program.Logger _logger)
{
StackPanel sp1 = null;
StackPanel sp2 = null;
EventHandler<Program.LogData> _LoggerLogAdded = (sender, e) => ((Action)(() =>
{
TextBlock tb = new TextBlock();
tb.Text = e.Text;
tb.Foreground = e.Kind == Program.LogData.LogKind.error ? Brushes.Red : Brushes.White;
tb.Margin = new Thickness(0.0, 10.0, 0.0, 10.0);
sp2.Children.Add(tb);
})).BeginExecuteInUIThread();
Loaded += (sender, e) =>
{
Grid grid = new Grid();
grid.RowDefinitions.Add(new RowDefinition());
grid.RowDefinitions.Add(new RowDefinition());
grid.RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto });
grid.ColumnDefinitions.Add(new ColumnDefinition());
ScrollViewer sv1 = new ScrollViewer();
sv1.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
sv1.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
sv1.SetValue(Grid.RowProperty, 0);
sv1.SetValue(Grid.ColumnProperty, 0);
sp1 = new StackPanel();
sp1.Background = Brushes.Black;
ScrollViewer sv2 = new ScrollViewer();
sv2.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
sv2.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
sv2.SetValue(Grid.RowProperty, 1);
sv2.SetValue(Grid.ColumnProperty, 0);
sp2 = new StackPanel();
sp2.Background = Brushes.Black;
sv1.Content = sp1;
sv2.Content = sp2;
TextBox tb = new TextBox();
tb.SetValue(Grid.RowProperty, 2);
tb.SetValue(Grid.ColumnProperty, 0);
grid.Children.Add(sv1);
grid.Children.Add(sv2);
grid.Children.Add(tb);
Content = grid;
Console.SetOut(new TextBlockStreamWriter(sp1));
_logger.LogAdded += _LoggerLogAdded;
//SimulationWindow sw = new SimulationWindow();
//sw.ShowDialog();
this.StartTask(string.Empty, string.Empty, () =>
{
//string testPrivateRsaParameters;
//using (RSACryptoServiceProvider rsacsp = new RSACryptoServiceProvider(2048))
// testPrivateRsaParameters = rsacsp.ToXmlString(true);
//RealInboundChennel ric = new RealInboundChennel(7777, RsaKeySize.rsa2048, 100);
//ric.Accepted += (sender2, e2) =>
//{
// this.StartTask("", "", () =>
// {
// e2.WriteBytes(BitConverter.GetBytes(true));
// bool b = BitConverter.ToBoolean(e2.ReadBytes(), 0);
// SessionChannel sc = e2.NewSession();
// sc.WriteBytes(BitConverter.GetBytes(true));
// sc.Close();
// //e2.Close();
// });
// //e2.Close();
// //Console.WriteLine("");
//};
//ric.RequestAcceptanceStart();
//AutoResetEvent are = new AutoResetEvent(false);
//SocketChannel socketc = null;
//RealOutboundChannel roc = new RealOutboundChannel(IPAddress.Loopback, 7777, RsaKeySize.rsa2048, testPrivateRsaParameters);
//roc.Connected += (sender2, e2) =>
//{
// socketc = e2;
// socketc.Sessioned += (sender3, e3) =>
// {
// bool b3 = BitConverter.ToBoolean(e3.ReadBytes(), 0);
// Console.WriteLine("");
// };
// are.Set();
// //e2.Close();
// //Console.WriteLine("connected");
//};
//roc.RequestConnection();
//are.WaitOne();
//bool b2 = BitConverter.ToBoolean(socketc.ReadBytes(), 0);
//socketc.WriteBytes(BitConverter.GetBytes(true));
//socketc.Close();
//CirculatedInteger ci = new CirculatedInteger(5);
//Console.WriteLine(ci.GetForward(0));
//Console.WriteLine(ci.GetForward(1));
//Console.WriteLine(ci.GetForward(2));
//Console.WriteLine(ci.GetForward(3));
//Console.WriteLine(ci.GetForward(4));
//Console.WriteLine(ci.GetForward(5));
//Console.WriteLine(ci.GetForward(6));
//Console.WriteLine(ci.GetBackward(0));
//Console.WriteLine(ci.GetBackward(1));
//Console.WriteLine(ci.GetBackward(2));
//Console.WriteLine(ci.GetBackward(3));
//Console.WriteLine(ci.GetBackward(4));
//Console.WriteLine(ci.GetBackward(5));
//Console.WriteLine(ci.GetBackward(6));
Secp256k1KeyPair<Sha256Hash> secp256k1KeyPair = new Secp256k1KeyPair<Sha256Hash>(true);
Sha256Ripemd160Hash address = new Sha256Ripemd160Hash(secp256k1KeyPair.pubKey.pubKey);
TransactionInput ti1 = new TransactionInput();
ti1.LoadVersion1(0, 0, 0);
TransactionOutput to1 = new TransactionOutput();
to1.LoadVersion0(address, new Creacoin(50m));
CoinbaseTransaction ct1 = new CoinbaseTransaction();
ct1.LoadVersion0(new TransactionOutput[] { to1 });
byte[] ctBytes1 = ct1.ToBinary();
CoinbaseTransaction ct2 = SHAREDDATA.FromBinary<CoinbaseTransaction>(ctBytes1);
TransferTransaction tt1 = new TransferTransaction();
tt1.LoadVersion1(new TransactionInput[] { ti1 }, new TransactionOutput[] { to1 });
tt1.Sign(new TransactionOutput[] { to1 }, new DSAPRIVKEYBASE[] { secp256k1KeyPair.privKey });
byte[] ttBytes1 = tt1.ToBinary();
TransferTransaction tt2 = SHAREDDATA.FromBinary<TransferTransaction>(ttBytes1);
ResTransactions rt1 = new ResTransactions(new Transaction[] { ct1, tt1 });
byte[] rtBytes1 = rt1.ToBinary();
ResTransactions rt2 = SHAREDDATA.FromBinary<ResTransactions>(rtBytes1);
byte[] test1 = SHAREDDATA.ToBinary<Transaction>(ct2);
CoinbaseTransaction ct3 = SHAREDDATA.FromBinary<Transaction>(test1) as CoinbaseTransaction;
byte[] test2 = SHAREDDATA.ToBinary<Transaction>(tt2);
TransferTransaction tt3 = SHAREDDATA.FromBinary<Transaction>(test2) as TransferTransaction;
//string pathBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
//New.BlockManagerDB bmdb = new New.BlockManagerDB(pathBase);
//New.BlockDB blkdb = new New.BlockDB(pathBase);
//New.BlockFilePointersDB bfpdb = new New.BlockFilePointersDB(pathBase);
//New.BlockManager bm = new New.BlockManager(bmdb, blkdb, bfpdb);
//New.TestBlock block1 = new New.TestBlock(1);
//bm.AddMainBlock(block1);
//bm.AddMainBlock(block1);
//Test10NodesInv();
//TestDHT();
//bool isFirst = true;
//int portNumber = 0;
//CreaNode cnlt = null;
//tb.KeyDown += (sender2, e2) =>
//{
// if (e2.Key != Key.Enter)
// return;
// if (isFirst)
// {
// portNumber = int.Parse(tb.Text);
// FirstNodeInfosDatabase fnidb = new FirstNodeInfosDatabase(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
// cnlt = new CreaNode((ushort)portNumber, 0, "test", fnidb);
// cnlt.Start();
// cnlt.ReceivedNewChat += (sender3, e3) =>
// {
// this.ConsoleWriteLine(e3.Message);
// };
// isFirst = false;
// return;
// }
// Chat chat = new Chat();
// chat.LoadVersion0(portNumber.ToString(), tb.Text);
// chat.Sign(secp256k1KeyPair.privKey);
// cnlt.DiffuseNewChat(chat);
//};
});
};
Closed += (sender, e) =>
{
_logger.LogAdded -= _LoggerLogAdded;
string fileText = string.Empty;
foreach (var child in sp1.Children)
fileText += (child as TextBlock).Text + Environment.NewLine;
File.AppendAllText(Path.Combine(new FileInfo(Assembly.GetEntryAssembly().Location).DirectoryName, "LogTest.txt"), fileText);
};
}
public void NewTransaction(IAccount iAccount, Sha256Ripemd160Hash address, CurrencyUnit amount, CurrencyUnit fee)
{
if (!isSystemStarted)
throw new InvalidOperationException("core_not_started");
Account account = iAccount as Account;
if (account == null)
throw new ArgumentException("iaccount_type");
utxodb.Open();
List<Utxo> utxosList = blockChain.GetAllUtxos(account.Address.Hash);
utxosList.Sort((a, b) =>
{
if (a.blockIndex < b.blockIndex)
return -1;
else if (a.blockIndex > b.blockIndex)
return 1;
if (a.txIndex < b.txIndex)
return -1;
else if (a.txIndex > b.txIndex)
return 1;
if (a.txOutIndex < b.txOutIndex)
return -1;
else if (a.txOutIndex > b.txOutIndex)
return 1;
return 0;
});
Utxo[] utxos = utxosList.ToArray();
utxodb.Close();
List<TransactionInput> usedTxInList = new List<TransactionInput>();
foreach (var unconfirmedTh in transactionHistories.unconfirmedTransactionHistories.ToArray())
for (int i = 0; i < unconfirmedTh.prevTxOuts.Length; i++)
if (unconfirmedTh.prevTxOuts[i].Address.Equals(account.Address.Hash))
usedTxInList.Add(unconfirmedTh.transaction.TxInputs[i]);
usedTxInList.Sort((a, b) =>
{
if (a.PrevTxBlockIndex < b.PrevTxBlockIndex)
return -1;
else if (a.PrevTxBlockIndex > b.PrevTxBlockIndex)
return 1;
if (a.PrevTxIndex < b.PrevTxIndex)
return -1;
else if (a.PrevTxIndex > b.PrevTxIndex)
return 1;
if (a.PrevTxOutputIndex < b.PrevTxOutputIndex)
return -1;
else if (a.PrevTxOutputIndex > b.PrevTxOutputIndex)
return 1;
return 0;
});
TransactionInput[] usedTxIns = usedTxInList.ToArray();
List<Utxo> unusedUtxosList = new List<Utxo>();
int position = -1;
for (int i = 0; i < usedTxIns.Length; i++)
{
bool flag = false;
while (position < utxos.Length)
{
position++;
if (usedTxIns[i].PrevTxBlockIndex == utxos[position].blockIndex && usedTxIns[i].PrevTxIndex == utxos[position].txIndex && usedTxIns[i].PrevTxOutputIndex == utxos[position].txOutIndex)
{
flag = true;
break;
}
else
unusedUtxosList.Add(utxos[position]);
}
if (!flag)
throw new InvalidOperationException();
}
long rawFeeAndAmount = amount.rawAmount + fee.rawAmount;
List<Utxo> useUtxosList = new List<Utxo>();
long rawFeeAndAmountAndChange = 0;
bool flag2 = false;
foreach (var utxo in unusedUtxosList)
{
useUtxosList.Add(utxo);
if ((rawFeeAndAmountAndChange += utxo.amount.rawAmount) > rawFeeAndAmount)
{
flag2 = true;
break;
}
}
if (!flag2)
for (int i = position + 1; i < utxos.Length; i++)
{
useUtxosList.Add(utxos[i]);
if ((rawFeeAndAmountAndChange += utxos[i].amount.rawAmount) > rawFeeAndAmount)
{
flag2 = true;
break;
}
}
if (!flag2)
throw new InvalidOperationException();
Utxo[] useUtxos = useUtxosList.ToArray();
TransactionInput[] txIns = new TransactionInput[useUtxos.Length];
for (int i = 0; i < txIns.Length; i++)
{
txIns[i] = new TransactionInput();
txIns[i].LoadVersion0(useUtxos[i].blockIndex, useUtxos[i].txIndex, useUtxos[i].txOutIndex, account.Ecdsa256KeyPair.pubKey);
}
long rawChange = rawFeeAndAmountAndChange - rawFeeAndAmount;
TransactionOutput[] txOuts = new TransactionOutput[rawChange == 0 ? 1 : 2];
txOuts[0] = new TransactionOutput();
txOuts[0].LoadVersion0(address, amount);
if (rawChange != 0)
{
txOuts[1] = new TransactionOutput();
txOuts[1].LoadVersion0(account.Address.Hash, new CurrencyUnit(rawChange));
}
TransactionOutput[] prevTxOuts = new TransactionOutput[useUtxos.Length];
for (int i = 0; i < prevTxOuts.Length; i++)
prevTxOuts[i] = blockChain.GetMainBlock(txIns[i].PrevTxBlockIndex).Transactions[txIns[i].PrevTxIndex].TxOutputs[txIns[i].PrevTxOutputIndex];
Ecdsa256PrivKey[] privKeys = new Ecdsa256PrivKey[useUtxos.Length];
for (int i = 0; i < privKeys.Length; i++)
privKeys[i] = account.Ecdsa256KeyPair.privKey;
TransferTransaction ttx = new TransferTransaction();
ttx.LoadVersion0(txIns, txOuts);
ttx.Sign(prevTxOuts, privKeys);
creaNodeTest.DiffuseNewTransaction(ttx);
}
//TransactionOutput、TransactionInput、CoinbaseTransaction、TransferTransactionのテスト
public static void Test10()
{
Ecdsa256KeyPair keypair1 = new Ecdsa256KeyPair(true);
Ecdsa256KeyPair keypair2 = new Ecdsa256KeyPair(true);
Ecdsa256KeyPair keypair3 = new Ecdsa256KeyPair(true);
Sha256Ripemd160Hash address1 = new Sha256Ripemd160Hash(keypair1.pubKey.pubKey);
CurrencyUnit amount1 = new Creacoin(50.0m);
Sha256Ripemd160Hash address2 = new Sha256Ripemd160Hash(keypair2.pubKey.pubKey);
CurrencyUnit amount2 = new Creacoin(25.0m);
Sha256Ripemd160Hash address3 = new Sha256Ripemd160Hash(keypair3.pubKey.pubKey);
CurrencyUnit amount3 = new Yumina(0.01m);
TransactionOutput txOut1 = new TransactionOutput();
txOut1.LoadVersion0(address1, amount1);
TransactionOutput txOut2 = new TransactionOutput();
txOut2.LoadVersion0(address2, amount2);
TransactionOutput txOut3 = new TransactionOutput();
txOut3.LoadVersion0(address3, amount3);
if (txOut1.Address != address1)
throw new Exception("test10_1");
if (txOut1.Amount != amount1)
throw new Exception("test10_2");
byte[] txOutBytes = txOut1.ToBinary();
if (txOutBytes.Length != 29)
throw new Exception("test10_3");
TransactionOutput txOutRestore = SHAREDDATA.FromBinary<TransactionOutput>(txOutBytes, 0);
if (!txOut1.Address.Equals(txOutRestore.Address))
throw new Exception("test10_4");
if (txOut1.Amount.rawAmount != txOutRestore.Amount.rawAmount)
throw new Exception("test10_5");
TransactionInput txIn1 = new TransactionInput();
txIn1.LoadVersion0(0, 0, 0, keypair1.pubKey);
TransactionInput txIn2 = new TransactionInput();
txIn2.LoadVersion0(1, 0, 0, keypair2.pubKey);
TransactionInput txIn3 = new TransactionInput();
txIn3.LoadVersion0(2, 0, 0, keypair3.pubKey);
if (txIn1.PrevTxBlockIndex != 0)
throw new Exception("test10_6");
if (txIn1.PrevTxIndex != 0)
throw new Exception("test10_7");
if (txIn1.PrevTxOutputIndex != 0)
throw new Exception("test10_8");
if (txIn1.SenderPubKey != keypair1.pubKey)
throw new Exception("test10_9");
TransactionOutput[] txOuts = new TransactionOutput[] { txOut1, txOut2, txOut3 };
CoinbaseTransaction cTx = new CoinbaseTransaction();
cTx.LoadVersion0(txOuts);
if (cTx.TxOutputs != txOuts)
throw new Exception("test10_10");
if (cTx.TxInputs.Length != 0)
throw new Exception("test10_11");
byte[] cTxBytes = cTx.ToBinary();
if (cTxBytes.Length != 97)
throw new Exception("test10_12");
CoinbaseTransaction cTxRestore = SHAREDDATA.FromBinary<CoinbaseTransaction>(cTxBytes);
if (!cTx.Id.Equals(cTxRestore.Id))
throw new Exception("test10_13");
if (cTx.Verify())
throw new Exception("test10_14");
if (cTx.VerifyNotExistDustTxOutput())
throw new Exception("test10_15");
if (!cTx.VerifyNumberOfTxInputs())
throw new Exception("test10_16");
if (!cTx.VerifyNumberOfTxOutputs())
throw new Exception("test10_17");
TransactionOutput[] txOuts2 = new TransactionOutput[11];
for (int i = 0; i < txOuts2.Length; i++)
txOuts2[i] = txOut1;
CoinbaseTransaction cTx2 = new CoinbaseTransaction();
cTx2.LoadVersion0(txOuts2);
if (cTx2.Verify())
throw new Exception("test10_18");
if (!cTx2.VerifyNotExistDustTxOutput())
throw new Exception("test10_19");
if (!cTx2.VerifyNumberOfTxInputs())
throw new Exception("test10_20");
if (cTx2.VerifyNumberOfTxOutputs())
throw new Exception("test10_21");
TransactionOutput[] txOuts3 = new TransactionOutput[] { txOut1, txOut2 };
CoinbaseTransaction cTx3 = new CoinbaseTransaction();
cTx3.LoadVersion0(txOuts3);
if (!cTx3.Verify())
throw new Exception("test10_22");
if (!cTx3.VerifyNotExistDustTxOutput())
throw new Exception("test10_23");
if (!cTx3.VerifyNumberOfTxInputs())
throw new Exception("test10_24");
if (!cTx3.VerifyNumberOfTxOutputs())
throw new Exception("test10_25");
TransactionInput[] txIns = new TransactionInput[] { txIn1, txIn2, txIn3 };
TransferTransaction tTx1 = new TransferTransaction();
tTx1.LoadVersion0(txIns, txOuts);
tTx1.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey });
if (tTx1.TxInputs != txIns)
throw new Exception("test10_26");
if (tTx1.TxOutputs != txOuts)
throw new Exception("test10_27");
byte[] txInBytes = txIn1.ToBinary();
if (txInBytes.Length != 153)
throw new Exception("test10_28");
TransactionInput txInRestore = SHAREDDATA.FromBinary<TransactionInput>(txInBytes, 0);
if (txIn1.PrevTxBlockIndex != txInRestore.PrevTxBlockIndex)
throw new Exception("test10_29");
if (txIn1.PrevTxIndex != txInRestore.PrevTxIndex)
throw new Exception("test10_30");
if (txIn1.PrevTxOutputIndex != txInRestore.PrevTxOutputIndex)
throw new Exception("test10_31");
if (!txIn1.SenderPubKey.pubKey.BytesEquals(txInRestore.SenderPubKey.pubKey))
throw new Exception("test10_32");
if (!txIn1.SenderSignature.signature.BytesEquals(txInRestore.SenderSignature.signature))
throw new Exception("test10_33");
byte[] tTxBytes = tTx1.ToBinary();
if (tTxBytes.Length != 557)
throw new Exception("test10_34");
TransferTransaction tTxRestore = SHAREDDATA.FromBinary<TransferTransaction>(tTxBytes);
if (!tTx1.Id.Equals(tTxRestore.Id))
throw new Exception("test10_35");
if (tTx1.Verify(txOuts))
throw new Exception("test10_36");
if (tTx1.VerifyNotExistDustTxOutput())
throw new Exception("test10_37");
if (!tTx1.VerifyNumberOfTxInputs())
throw new Exception("test10_38");
if (!tTx1.VerifyNumberOfTxOutputs())
throw new Exception("test10_39");
if (!tTx1.VerifySignature(txOuts))
throw new Exception("test10_40");
if (!tTx1.VerifyPubKey(txOuts))
throw new Exception("test10_41");
if (!tTx1.VerifyAmount(txOuts))
throw new Exception("test10_42");
if (tTx1.GetFee(txOuts).rawAmount != 0)
throw new Exception("test10_43");
TransactionOutput[] txOuts4 = new TransactionOutput[] { txOut2, txOut1, txOut3 };
if (tTx1.Verify(txOuts4))
throw new Exception("test10_44");
if (tTx1.VerifySignature(txOuts4))
throw new Exception("test10_45");
if (tTx1.VerifyPubKey(txOuts4))
throw new Exception("test10_46");
byte temp2 = tTx1.TxInputs[0].SenderSignature.signature[0];
tTx1.TxInputs[0].SenderSignature.signature[0] = 0;
if (tTx1.Verify(txOuts))
throw new Exception("test10_47");
if (tTx1.VerifySignature(txOuts))
throw new Exception("test10_48");
if (!tTx1.VerifyPubKey(txOuts))
throw new Exception("test10_49");
tTx1.TxInputs[0].SenderSignature.signature[0] = temp2;
TransferTransaction tTx2 = new TransferTransaction();
tTx2.LoadVersion0(txIns, txOuts);
tTx2.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair2.privKey, keypair1.privKey, keypair3.privKey });
if (tTx2.Verify(txOuts))
throw new Exception("test10_50");
if (tTx2.VerifySignature(txOuts))
throw new Exception("test10_51");
if (!tTx2.VerifyPubKey(txOuts))
throw new Exception("test10_52");
TransferTransaction tTx3 = new TransferTransaction();
tTx3.LoadVersion0(txIns, txOuts);
tTx3.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey });
byte temp = tTx3.TxInputs[0].SenderPubKey.pubKey[0];
tTx3.TxInputs[0].SenderPubKey.pubKey[0] = 0;
if (tTx3.Verify(txOuts))
throw new Exception("test10_50");
if (tTx3.VerifySignature(txOuts))
throw new Exception("test10_51");
if (tTx3.VerifyPubKey(txOuts))
throw new Exception("test10_52");
tTx3.TxInputs[0].SenderPubKey.pubKey[0] = temp;
TransferTransaction tTx4 = new TransferTransaction();
tTx4.LoadVersion0(txIns, txOuts2);
tTx4.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey });
if (tTx4.Verify(txOuts))
throw new Exception("test10_53");
if (!tTx4.VerifyNotExistDustTxOutput())
throw new Exception("test10_54");
if (!tTx4.VerifyNumberOfTxInputs())
throw new Exception("test10_55");
if (tTx4.VerifyNumberOfTxOutputs())
throw new Exception("test10_56");
if (!tTx4.VerifySignature(txOuts))
throw new Exception("test10_57");
if (!tTx4.VerifyPubKey(txOuts))
throw new Exception("test10_58");
if (tTx4.VerifyAmount(txOuts))
throw new Exception("test10_59");
if (tTx4.GetFee(txOuts).rawAmount != -47499990000)
throw new Exception("test10_60");
TransferTransaction tTx5 = new TransferTransaction();
tTx5.LoadVersion0(txIns, txOuts3);
tTx5.Sign(txOuts, new DSAPRIVKEYBASE[] { keypair1.privKey, keypair2.privKey, keypair3.privKey });
if (!tTx5.Verify(txOuts))
throw new Exception("test10_61");
if (!tTx5.VerifyNotExistDustTxOutput())
throw new Exception("test10_62");
if (!tTx5.VerifyNumberOfTxInputs())
throw new Exception("test10_63");
if (!tTx5.VerifyNumberOfTxOutputs())
throw new Exception("test10_64");
if (!tTx5.VerifySignature(txOuts))
throw new Exception("test10_65");
if (!tTx5.VerifyPubKey(txOuts))
throw new Exception("test10_66");
if (!tTx5.VerifyAmount(txOuts))
throw new Exception("test10_67");
if (tTx5.GetFee(txOuts).rawAmount != 10000)
throw new Exception("test10_68");
TransactionInput[] txIns2 = new TransactionInput[101];
for (int i = 0; i < txIns2.Length; i++)
txIns2[i] = txIn1;
TransactionOutput[] txOuts5 = new TransactionOutput[txIns2.Length];
for (int i = 0; i < txOuts5.Length; i++)
txOuts5[i] = txOut1;
Ecdsa256PrivKey[] privKeys = new Ecdsa256PrivKey[txIns2.Length];
for (int i = 0; i < privKeys.Length; i++)
privKeys[i] = keypair1.privKey;
TransferTransaction tTx6 = new TransferTransaction();
tTx6.LoadVersion0(txIns2, txOuts3);
tTx6.Sign(txOuts5, privKeys);
if (tTx6.Verify(txOuts5))
throw new Exception("test10_61");
if (!tTx6.VerifyNotExistDustTxOutput())
throw new Exception("test10_62");
if (tTx6.VerifyNumberOfTxInputs())
throw new Exception("test10_63");
if (!tTx6.VerifyNumberOfTxOutputs())
throw new Exception("test10_64");
if (!tTx6.VerifySignature(txOuts5))
throw new Exception("test10_65");
if (!tTx6.VerifyPubKey(txOuts5))
throw new Exception("test10_66");
if (!tTx6.VerifyAmount(txOuts5))
throw new Exception("test10_67");
if (tTx6.GetFee(txOuts5).rawAmount != 497500000000)
throw new Exception("test10_68");
byte[] cTxBytes2 = SHAREDDATA.ToBinary<Transaction>(cTx);
if (cTxBytes2.Length != 117)
throw new Exception("test10_69");
CoinbaseTransaction cTxRestore2 = SHAREDDATA.FromBinary<Transaction>(cTxBytes2) as CoinbaseTransaction;
if (!cTx.Id.Equals(cTxRestore2.Id))
throw new Exception("test10_70");
byte[] tTxBytes2 = SHAREDDATA.ToBinary<Transaction>(tTx6);
if (tTxBytes2.Length != 15445)
throw new Exception("test10_71");
TransferTransaction tTxRestore2 = SHAREDDATA.FromBinary<Transaction>(tTxBytes2) as TransferTransaction;
if (!tTx6.Id.Equals(tTxRestore2.Id))
throw new Exception("test10_72");
Sha256Sha256Hash ctxid = new Sha256Sha256Hash(cTxBytes);
if (!ctxid.Equals(cTx.Id))
throw new Exception("test10_73");
Sha256Sha256Hash ttxid = new Sha256Sha256Hash(tTx6.ToBinary());
if (!ttxid.Equals(tTx6.Id))
throw new Exception("test10_74");
Console.WriteLine("test10_succeeded");
}
public TransactionInput GenerateTransactionInput()
{
TransactionInput txIn = new TransactionInput();
txIn.LoadVersion0(bIndex, txIndex, txOutIndex, keyPair.pubKey);
return txIn;
}
public bool ContainsUnspent(TransactionInput input)
{
return ContainsUnspent(input.PrevHash, input.PrevIndex);
}
