public static TransactionBroadcast Sign(this TransactionBroadcast transaction, ICryptoContext cryptoContext, IPrivateKey privateKey, SigningContext context) { var clone = transaction.Clone(); if (transaction.Signature?.RawBytes.Length == cryptoContext.SignatureLength) { Logger.Debug("The transaction was already signed, returning a clone."); return(clone); } clone.Signature = null; var signatureBytes = cryptoContext.Sign(privateKey, clone.ToByteArray(), context.ToByteArray()).SignatureBytes; clone.Signature = new Signature { RawBytes = signatureBytes.ToByteString(), SigningContext = context }; return(clone); }
public static TransactionBroadcast GetPublicTransaction(uint amount = 123, string senderPublicKey = "sender", string receiverPublicKey = "receiver", string signature = "signature", long timestamp = 12345, ulong transactionFees = 2, ulong nonce = 0, ulong gasPrice = 1, NetworkType networkType = NetworkType.Devnet) { var transaction = new TransactionBroadcast { PublicEntry = new PublicEntry { Amount = ((UInt256)amount).ToUint256ByteString(), Nonce = nonce, ReceiverAddress = receiverPublicKey.ToUtf8ByteString(), SenderAddress = senderPublicKey.ToUtf8ByteString(), GasPrice = ((UInt256)gasPrice).ToUint256ByteString(), Signature = new Signature { SigningContext = new SigningContext { NetworkType = networkType, SignatureType = SignatureType.TransactionPublic }, RawBytes = signature.ToUtf8ByteString() } } }; return(transaction); }
public CryptoBenchmark() { _context = new SigningContext { NetworkType = NetworkType.Mainnet, SignatureType = SignatureType.TransactionConfidential }; var key = ByteString.CopyFrom(new byte[32]); var amount = ByteString.CopyFrom(new byte[32]); _transaction = new TransactionBroadcast { PublicEntry = new PublicEntry { Amount = amount, Nonce = 1, SenderAddress = key, ReceiverAddress = key, GasPrice = amount } }; _crypto = new NoopCryptoContext(); }
public int Compare(TransactionBroadcast x, TransactionBroadcast y) { if (ReferenceEquals(x, y)) { return(0); } if (ReferenceEquals(null, y)) { return(1); } if (ReferenceEquals(null, x)) { return(-1); } var feeComparison = x.SummedEntryFees().CompareTo(y.SummedEntryFees()); if (feeComparison != 0) { return(feeComparison); } var timeStampComparison = y.Timestamp.CompareTo(x.Timestamp); if (timeStampComparison != 0) { return(timeStampComparison); } return(ByteUtil.ByteListMinSizeComparer.Default.Compare(x.Signature.ToByteArray(), y.Signature.ToByteArray())); }
public static TransactionBroadcast GetContractTransaction(ByteString data, UInt256 amount, uint gasLimit, UInt256 gasPrice, string senderPublicKey = null, string receiverPublicKey = null, string signature = "signature", long timestamp = 12345, ulong nonce = 0, NetworkType networkType = NetworkType.Devnet) { var transaction = new TransactionBroadcast { PublicEntry = new PublicEntry { Amount = amount.ToUint256ByteString(), Nonce = nonce, ReceiverAddress = receiverPublicKey?.ToUtf8ByteString() ?? ByteString.CopyFrom(new byte[20]), SenderAddress = senderPublicKey?.ToUtf8ByteString() ?? ByteString.CopyFrom(new byte[20]), Signature = new Signature { SigningContext = new SigningContext { NetworkType = networkType, SignatureType = SignatureType.TransactionPublic }, RawBytes = signature.ToUtf8ByteString() }, Data = data, GasLimit = gasLimit, GasPrice = gasPrice.ToUint256ByteString(), } }; return(transaction); }
public static BroadcastRawTransactionRequest GenerateTransaction(uint amount, int fee, int nonce = 0) { var cryptoWrapper = new FfiWrapper(); var privateKey = cryptoWrapper.GeneratePrivateKey(); var publicKey = ByteString.CopyFrom(privateKey.GetPublicKey().Bytes); var transaction = new TransactionBroadcast { PublicEntry = new PublicEntry { Amount = ((UInt256)amount).ToUint256ByteString(), Nonce = (ulong)nonce, SenderAddress = privateKey.GetPublicKey().Bytes.ToByteString(), ReceiverAddress = publicKey, TransactionFees = ((UInt256)fee).ToUint256ByteString(), Timestamp = Timestamp.FromDateTime(DateTime.UtcNow) }.Sign(cryptoWrapper, privateKey, DevNetPublicTransactionContext) }; var broadcastRawTransactionRequest = new BroadcastRawTransactionRequest { Transaction = transaction }; return(broadcastRawTransactionRequest); }
public void Can_Identify_Broadcast_Message() { var message = new TransactionBroadcast() .ToSignedProtocolMessage() .ToSignedProtocolMessage(); message.IsBroadCastMessage().Should().BeTrue(); }
public JsonProtoObjectConverterTests() { _jsonProtoObjectConverter = new JsonProtoObjectConverter <TransactionBroadcast>(); _transaction = TransactionHelper.GetContractTransaction(ByteString.CopyFromUtf8("test"), 10, 10, 10); _transactionJson = "{ \"publicEntry\": { \"receiverAddress\": \"AAAAAAAAAAAAAAAAAAAAAAAAAAA=\", \"senderAddress\": \"AAAAAAAAAAAAAAAAAAAAAAAAAAA=\", \"amount\": \"Cg==\", \"data\": \"dGVzdA==\", \"gasPrice\": \"Cg==\", \"gasLimit\": \"10\", \"signature\": { \"signingContext\": { \"networkType\": \"DEVNET\", \"signatureType\": \"TRANSACTION_PUBLIC\" }, \"rawBytes\": \"c2lnbmF0dXJl\" } } }"; _transactionJson = "{ \"publicEntry\": { \"receiverAddress\": \"AAAAAAAAAAAAAAAAAAAAAAAAAAA=\", \"senderAddress\": \"AAAAAAAAAAAAAAAAAAAAAAAAAAA=\", \"amount\": \"Cg==\", \"data\": \"dGVzdA==\", \"gasPrice\": \"Cg==\", \"gasLimit\": \"10\", \"signature\": { \"signingContext\": { \"networkType\": \"DEVNET\", \"signatureType\": \"TRANSACTION_PUBLIC\" }, \"rawBytes\": \"c2lnbmF0dXJl\" } } }"; _transactionJson = "{ \"publicEntry\": { \"receiverAddress\": \"AAAAAAAAAAAAAAAAAAAAAAAAAAA=\", \"senderAddress\": \"AAAAAAAAAAAAAAAAAAAAAAAAAAA=\", \"amount\": \"Cg==\", \"data\": \"dGVzdA==\", \"gasPrice\": \"Cg==\", \"gasLimit\": \"10\", \"signature\": { \"signingContext\": { \"networkType\": \"DEVNET\", \"signatureType\": \"TRANSACTION_PUBLIC\" }, \"rawBytes\": \"c2lnbmF0dXJl\" } } }"; }
public bool ValidateTransaction(TransactionBroadcast transactionBroadcast, NetworkType networkType) { return(ValidateTransactionFields(transactionBroadcast) && CheckContractInputFields(transactionBroadcast) && CheckCfEntries(transactionBroadcast) && CheckStEntries(transactionBroadcast) && ValidateTransactionSignature(transactionBroadcast, networkType)); }
public static UInt256 SummedEntryFees(this TransactionBroadcast transaction) { var sum = transaction.ContractEntries.Sum(e => e.Base.TransactionFees.ToUInt256()) + transaction.PublicEntries.Sum(e => e.Base.TransactionFees.ToUInt256()) + transaction.ConfidentialEntries.Sum(e => e.Base.TransactionFees.ToUInt256()); return(sum); }
public void Can_Clean_Up_Broadcast() { var correlationId = CorrelationId.GenerateCorrelationId(); var fakeMessage = new TransactionBroadcast() .ToProtocolMessage(PeerIdHelper.GetPeerId("Test"), correlationId); _fakeChannel.WriteInbound(fakeMessage); _broadcastManager.Received(1).RemoveSignedBroadcastMessageData(correlationId); }
private void AddKeyValueStoreEntryExpectation(TransactionBroadcast transaction) { var mempoolDoc = new MempoolDocument { Transaction = transaction }; _memPool.Repository.ReadItem(Arg.Is <ByteString>(k => k.SequenceEqual(transaction.Signature.RawBytes))) .Returns(mempoolDoc); _memPool.Repository.TryReadItem(Arg.Is <ByteString>(k => k.SequenceEqual(transaction.Signature.RawBytes))) .Returns(true); }
public static Signature GenerateSignature(IWrapper cryptoWrapper, IPrivateKey privateKey, TransactionBroadcast transactionBroadcast, SigningContext signingContext) { var transactionWithoutSig = transactionBroadcast.Clone(); transactionWithoutSig.Signature = null; var signature = cryptoWrapper.StdSign(privateKey, transactionWithoutSig.ToByteArray(), signingContext.ToByteArray()); var sig = new Signature { RawBytes = ByteString.CopyFrom(signature.SignatureBytes), SigningContext = signingContext }; return(sig); }
public bool CreateItem(TransactionBroadcast transactionBroadcast) { Guard.Argument(transactionBroadcast.Signature, nameof(transactionBroadcast.Signature)).NotNull(); try { Repository.Add(new MempoolDocument { Transaction = transactionBroadcast }); } catch (Exception e) { Log.Logger.Error(e, e.Message); return(false); } return(true); }
public static TransactionBroadcast GetContractTransaction(ByteString data, UInt256 amount, uint gasLimit, UInt256 gasPrice, byte[] targetContract = null, // to be reviewed string senderPublicKey = "sender", string receiverPublicKey = "receiver", string signature = "signature", long timestamp = 12345, ulong transactionFees = 2, ulong nonce = 0, NetworkType networkType = NetworkType.Devnet) { var transaction = new TransactionBroadcast { PublicEntry = new PublicEntry { Amount = amount.ToUint256ByteString(), Nonce = nonce, ReceiverAddress = receiverPublicKey.ToUtf8ByteString(), SenderAddress = senderPublicKey.ToUtf8ByteString(), TransactionFees = ((UInt256)transactionFees).ToUint256ByteString(), Timestamp = new Timestamp { Seconds = timestamp }, Signature = new Signature { SigningContext = new SigningContext { NetworkType = networkType, SignatureType = SignatureType.TransactionPublic }, RawBytes = signature.ToUtf8ByteString() }, Data = data, GasLimit = gasLimit, GasPrice = gasPrice.ToUint256ByteString(), TargetContract = targetContract } }; return(transaction); }
private IActionResult GenerateTweet(IPrivateKey privateKey, IPublicKey publicKey, string message) { if (String.IsNullOrEmpty(message)) { return(BadRequest("Messages must contain text")); } if (message.Length > 240) { return(BadRequest("Messages have a maximum length of 240 characters.")); } var publicKeyByteString = ByteString.CopyFrom(publicKey.Bytes); var transaction = new TransactionBroadcast(); var publicEntry = new PublicEntry(); publicEntry.Amount = ByteString.CopyFrom(0); var contractEntry = new ContractEntry(); contractEntry.Amount = ByteString.CopyFrom(0); contractEntry.Data = ByteString.CopyFromUtf8($"tw:{message}"); var contractEntryBase = new BaseEntry(); contractEntryBase.SenderPublicKey = publicKeyByteString; contractEntryBase.TransactionFees = ByteString.CopyFrom(0); contractEntry.Base = contractEntryBase; publicEntry.Base = contractEntryBase; transaction.Timestamp = Timestamp.FromDateTime(DateTime.UtcNow); transaction.ContractEntries.Add(contractEntry); transaction.PublicEntries.Add(publicEntry); transaction.Signature = SignatureHelper.GenerateSignature(_cryptoWrapper, privateKey, transaction, _signingContext); _transactionReceivedEvent.OnTransactionReceived(transaction); return(Ok()); }
public void Init() { _keySigner = Substitute.For <FakeKeySigner>(); _keySigner.Verify(Arg.Any <ISignature>(), Arg.Any <byte[]>(), default).ReturnsForAnyArgs(true); _fakeBroadcastManager = Substitute.For <IBroadcastManager>(); _broadcastHandler = new BroadcastHandler(_fakeBroadcastManager); var fakeSignature = Substitute.For <ISignature>(); fakeSignature.SignatureBytes.Returns(ByteUtil.GenerateRandomByteArray(new FfiWrapper().SignatureLength)); _signingContext = DevNetPeerSigningContext.Instance; var peerId = PeerIdHelper.GetPeerId("Test"); var innerMessage = new TransactionBroadcast(); _broadcastMessageSigned = innerMessage .ToSignedProtocolMessage(peerId, fakeSignature, _signingContext) .ToSignedProtocolMessage(peerId, fakeSignature, _signingContext); }
public Keccak SendTransaction(PublicEntry publicEntry) { TransactionBroadcast broadcast = new TransactionBroadcast { PublicEntry = publicEntry }; _transactionReceived.OnTransactionReceived(broadcast.ToProtocolMessage(_peerId)); byte[] kvmAddressBytes = Keccak.Compute(publicEntry.SenderAddress.ToByteArray()).Bytes.AsSpan(12).ToArray(); string hex = kvmAddressBytes.ToHexString() ?? throw new ArgumentNullException("kvmAddressBytes.ToHexString()"); publicEntry.SenderAddress = kvmAddressBytes.ToByteString(); if (publicEntry.ReceiverAddress.Length == 1) { publicEntry.ReceiverAddress = ByteString.Empty; } return(publicEntry.GetHash(HashProvider)); }
protected override Keccak Handle(byte[] transaction, IWeb3EthApi api) { PublicEntry publicEntry; try { Transaction tx = Rlp.Decode <Transaction>(transaction); EthereumEcdsa ecdsa = new EthereumEcdsa(MainnetSpecProvider.Instance, LimboLogs.Instance); tx.SenderAddress = ecdsa.RecoverAddress(tx, MainnetSpecProvider.IstanbulBlockNumber); tx.Timestamp = (UInt256)DateTimeOffset.UtcNow.ToUnixTimeSeconds(); publicEntry = new PublicEntry { Data = (tx.Data ?? tx.Init).ToByteString(), GasLimit = (ulong)tx.GasLimit, GasPrice = tx.GasPrice.ToUint256ByteString(), Nonce = (ulong)tx.Nonce, SenderAddress = tx.SenderAddress.Bytes.ToByteString(), ReceiverAddress = tx.To?.Bytes.ToByteString() ?? ByteString.Empty, Amount = tx.Value.ToUint256ByteString(), Signature = new Protocol.Cryptography.Signature { RawBytes = ByteString.CopyFrom((byte)1) } }; } catch { try { TransactionBroadcast transactionBroadcast = TransactionBroadcast.Parser.ParseFrom(transaction); publicEntry = transactionBroadcast.PublicEntry; } catch (Exception) { throw new InvalidDataException($"Transaction data could not be deserialized into a {nameof(PublicEntry)}"); } } return(api.SendTransaction(publicEntry)); }
public static TransactionBroadcast GetPublicTransaction(uint amount = 123, string senderPublicKey = "sender", string receiverPublicKey = "receiver", string signature = "signature", long timestamp = 12345, ulong transactionFees = 2, ulong nonce = 0, NetworkType networkType = NetworkType.Devnet) { var transaction = new TransactionBroadcast { PublicEntries = { new PublicEntry { Amount = ((UInt256)amount).ToUint256ByteString(), Base = new BaseEntry { Nonce = nonce, ReceiverPublicKey = receiverPublicKey.ToUtf8ByteString(), SenderPublicKey = senderPublicKey.ToUtf8ByteString(), TransactionFees = ((UInt256)transactionFees).ToUint256ByteString(), } } }, Timestamp = new Timestamp { Seconds = timestamp }, Signature = new Signature { SigningContext = new SigningContext { NetworkType = networkType, SignatureType = SignatureType.TransactionPublic }, RawBytes = signature.ToUtf8ByteString() } }; return(transaction); }
private bool ValidateTransactionSignature(TransactionBroadcast transactionBroadcast, NetworkType networkType) { if (transactionBroadcast.Signature.RawBytes == ByteString.Empty) { _logger.Error("Transaction signature is null"); return(false); } var transactionSignature = _cryptoContext.GetSignatureFromBytes(transactionBroadcast.Signature.RawBytes.ToByteArray(), transactionBroadcast.PublicEntries.First().Base.SenderPublicKey.ToByteArray()); var transactionWithoutSig = transactionBroadcast.Clone(); transactionWithoutSig.Signature = null; if (!_cryptoContext.Verify(transactionSignature, transactionWithoutSig.ToByteArray(), transactionBroadcast.Signature.SigningContext.ToByteArray())) { return(true); } _logger.Information( "Transaction Signature {signature} invalid.", transactionSignature); return(false); }
private bool CheckContractInputFields(TransactionBroadcast transactionBroadcast) { // @TODO DO SOMETHING return(true); }
public bool CreateItem(TransactionBroadcast transactionBroadcast) { throw new NotImplementedException(); }
private bool ValidateTransactionFields(TransactionBroadcast transactionBroadcast) { // @TODO DO SOMETHING return(true); }
private bool CheckStEntries(TransactionBroadcast transactionBroadcast) { // @TODO DO SOMETHING return(true); }
public MempoolTests() { _memPool = new Mempool(Substitute.For <IMempoolRepository <MempoolDocument> >()); _transactionBroadcast = TransactionHelper.GetPublicTransaction(); }