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();
}
