public ChaincodeStub(string channelId, string txId, Handler handler, List <ByteString> args, SignedProposal signedProposal)
{
ChannelId = channelId;
TxId = txId;
this.handler = handler;
this.args = args.ToList();
SignedProposal = signedProposal;
if (SignedProposal == null || SignedProposal.ProposalBytes.IsEmpty)
{
creator = null;
TxTimestamp = null;
transientMap = new Dictionary <string, ByteString>();
Binding = null;
}
else
{
Proposal proposal = Proposal.Parser.ParseFrom(signedProposal.ProposalBytes);
Header header = Header.Parser.ParseFrom(proposal.Header);
ChannelHeader channelHeader = ChannelHeader.Parser.ParseFrom(header.ChannelHeader);
ValidateProposalType(channelHeader);
SignatureHeader signatureHeader = SignatureHeader.Parser.ParseFrom(header.SignatureHeader);
ChaincodeProposalPayload chaincodeProposalPayload = ChaincodeProposalPayload.Parser.ParseFrom(proposal.Payload);
TxTimestamp = channelHeader.Timestamp.ToDateTimeOffset();
creator = signatureHeader.Creator;
transientMap = chaincodeProposalPayload.TransientMap.ToDictionary(a => a.Key, a => a.Value);
Binding = ComputeBinding(channelHeader, signatureHeader);
}
}
public virtual async Task <ProposalResponse> SendProposalAsync(SignedProposal proposal, CancellationToken token = default(CancellationToken))
{
if (shutdown)
{
throw new PeerException("Shutdown");
}
return(await ecl.ProcessProposalAsync(proposal, null, null, token));
}
public override Task <ProposalResponse> SendProposalAsync(SignedProposal proposal, CancellationToken token = default(CancellationToken))
{
if (throwThis != null)
{
throw throwThis;
}
return(Task.FromResult(returned));
}
public ProposalResponse SendProposal(SignedProposal proposal)
{
if (shutdown)
{
throw new PeerException("Shutdown");
}
return(ecl.ProcessProposal(proposal));
}
public void TestGetSignedProposalWithEmptyProposal()
{
SignedProposal signedProposal = new SignedProposal {
ProposalBytes = ByteString.Empty
};
ChaincodeStub stub = new ChaincodeStub("myc", "txId", handler.Object, new List <ByteString>(), signedProposal);
Assert.AreEqual(stub.SignedProposal, signedProposal);
}
public void TestGetBindingEmptyProposal()
{
SignedProposal signedProposal = new SignedProposal {
ProposalBytes = ByteString.Empty
};
ChaincodeStub stub = new ChaincodeStub("myc", "txId", handler.Object, new List <ByteString>(), signedProposal);
Assert.IsNull(stub.Binding);
}
} // verify
public void SetProposal(SignedProposal signedProposal)
{
try
{
Proposal = Proposal.Parser.ParseFrom(signedProposal.ProposalBytes);
}
catch (InvalidProtocolBufferException e)
{
throw new ProposalException($"{Peer} transaction: {TransactionID} Proposal exception", e);
}
}
private ChaincodeStub CreateChaincodeStub(
IHandler handler,
string channelId,
string txId,
ChaincodeInput chaincodeInput,
SignedProposal signedProposal
)
{
return(new ChaincodeStub(handler, channelId, txId, chaincodeInput, signedProposal,
new NullLogger <ChaincodeStub>()));
}
public IChaincodeStub Create(
IHandler handler,
string channelId,
string txId,
ChaincodeInput chaincodeInput,
SignedProposal signedProposal
)
{
using (var scope = _serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
return(new ChaincodeStub(handler, channelId, txId, chaincodeInput, signedProposal,
scope.ServiceProvider.GetRequiredService <ILogger <ChaincodeStub> >()));
}
}
public void TestGetSignedProposal()
{
SignedProposal signedProposal = new SignedProposal {
ProposalBytes = new Proposal {
Header = new Header {
ChannelHeader = new ChannelHeader {
Type = (int)HeaderType.EndorserTransaction, Timestamp = new Timestamp()
}.ToByteString()
}.ToByteString()
}.ToByteString()
};
ChaincodeStub stub = new ChaincodeStub("myc", "txId", handler.Object, new List <ByteString>(), signedProposal);
Assert.AreEqual(stub.SignedProposal, signedProposal);
}
public void TestGetTxTimestamp()
{
DateTimeOffset?instant = DateTimeOffset.Now;
Timestamp timestamp = Timestamp.FromDateTimeOffset(instant.Value);
SignedProposal signedProposal = new SignedProposal {
ProposalBytes = new Proposal {
Header = new Header {
ChannelHeader = new ChannelHeader {
Type = (int)HeaderType.EndorserTransaction, Timestamp = timestamp
}.ToByteString()
}.ToByteString()
}.ToByteString()
};
ChaincodeStub stub = new ChaincodeStub("myc", "txId", handler.Object, new List <ByteString>(), signedProposal);
Assert.AreEqual(stub.TxTimestamp, instant);
}
public ChaincodeStub(
IHandler handler,
string channelId,
string txId,
ChaincodeInput chaincodeInput,
SignedProposal signedProposal,
ILogger <ChaincodeStub> logger
)
{
_handler = handler;
ChannelId = channelId;
TxId = txId;
_logger = logger;
Args = chaincodeInput.Args.Select(entry => entry.ToStringUtf8()).ToList();
DecodedSignedProposal = ValidateSignedProposal(signedProposal);
}
public void TestGetBinding()
{
byte[] expectedDigest = "5093dd4f4277e964da8f4afbde0a9674d17f2a6a5961f0670fc21ae9b67f2983".FromHexString();
SignedProposal signedProposal = new SignedProposal {
ProposalBytes = new Proposal {
Header = new Header {
ChannelHeader = new ChannelHeader {
Type = (int)HeaderType.EndorserTransaction, Timestamp = new Timestamp(), Epoch = 10
}.ToByteString(), SignatureHeader = new SignatureHeader {
Nonce = ByteString.CopyFromUtf8("nonce"), Creator = ByteString.CopyFromUtf8("creator")
}.ToByteString()
}.ToByteString(),
}.ToByteString()
};
ChaincodeStub stub = new ChaincodeStub("myc", "txId", handler.Object, new List <ByteString>(), signedProposal);
CollectionAssert.AreEqual(stub.Binding, expectedDigest);
}
public void TestGetCreator()
{
DateTimeOffset?instant = DateTimeOffset.Now;
byte[] creator = "CREATOR".ToBytes();
Timestamp timestamp = Timestamp.FromDateTimeOffset(instant.Value);
SignedProposal signedProposal = new SignedProposal {
ProposalBytes = new Proposal {
Header = new Header {
ChannelHeader = new ChannelHeader {
Type = (int)HeaderType.EndorserTransaction, Timestamp = timestamp
}.ToByteString(), SignatureHeader = new SignatureHeader {
Creator = ByteString.CopyFrom(creator)
}.ToByteString()
}.ToByteString(),
}.ToByteString()
};
ChaincodeStub stub = new ChaincodeStub("myc", "txId", handler.Object, new List <ByteString>(), signedProposal);
CollectionAssert.AreEqual(stub.Creator, creator);
}
public void TestGetTransient()
{
ChaincodeProposalPayload payload = new ChaincodeProposalPayload();
payload.TransientMap.Add("key0", ByteString.CopyFromUtf8("value0"));
payload.TransientMap.Add("key1", ByteString.CopyFromUtf8("value1"));
SignedProposal signedProposal = new SignedProposal {
ProposalBytes = new Proposal {
Header = new Header {
ChannelHeader = new ChannelHeader {
Type = (int)HeaderType.EndorserTransaction, Timestamp = new Timestamp()
}.ToByteString(),
}.ToByteString(), Payload = payload.ToByteString()
}.ToByteString()
};
ChaincodeStub stub = new ChaincodeStub("myc", "txId", handler.Object, new List <ByteString>(), signedProposal);
Assert.That.ContainsDictionary <string, byte[], byte>(stub.Transient, new Dictionary <string, byte[]> {
{ "key0", "value0".ToBytes() }, { "key1", "value1".ToBytes() }
});
}
public void SelfSignedTLSCertTest()
{
bool handshakeOccured = false;
Server sv = new Server();
TLSCertificateKeyPair serverCert = TLSCertificateKeyPair.CreateServerCert("localhost");
TLSCertificateKeyPair clientCert = TLSCertificateKeyPair.CreateClientCert();
KeyCertificatePair pair = new KeyCertificatePair(serverCert.CertPEMBytes.ToUTF8String(), serverCert.KeyPEMBytes.ToUTF8String());
ServerCredentials credentials = new SslServerCredentials(new[] { pair }, clientCert.CertPEMBytes.ToUTF8String(), true);
sv.Ports.Add(new ServerPort("localhost", 0, credentials));
sv.Services.Add(Endorser.BindService(new MockEndorser()).Intercept(new MultalTLSInterceptor(clientCert.CertPEMBytes, (b) => handshakeOccured = b)));
sv.Start();
int port = sv.Ports.First().BoundPort;
ChannelCredentials cred = new SslCredentials(serverCert.CertPEMBytes.ToUTF8String(), new KeyCertificatePair(clientCert.CertPEMBytes.ToUTF8String(), clientCert.KeyPEMBytes.ToUTF8String()));
Channel chan = new Channel("localhost", port, cred);
SignedProposal prop = new SignedProposal();
Endorser.EndorserClient cl = new Endorser.EndorserClient(chan);
cl.ProcessProposal(prop);
Assert.IsTrue(handshakeOccured, "Handshake didn't occur");
chan.ShutdownAsync().RunAndUnwrap();
sv.ShutdownAsync().RunAndUnwrap();
}
public override Task <ProposalResponse> ProcessProposal(SignedProposal request, ServerCallContext context)
{
return(Task.FromResult(new ProposalResponse()));
}
private DecodedSignedProposal ValidateSignedProposal(SignedProposal signedProposal)
{
if (signedProposal == null)
{
return(null);
}
var decodedSignedProposal = new DecodedSignedProposal
{
Signature = signedProposal.Signature
};
try
{
_proposal = Proposal.Parser.ParseFrom(signedProposal.ProposalBytes);
decodedSignedProposal.Proposal = new ChaincodeProposal();
}
catch (Exception ex)
{
throw new Exception($"Failed extracting proposal from signedProposal: {ex}");
}
if (_proposal.Header == null || _proposal.Header.Length == 0)
{
throw new Exception("Proposal header is empty");
}
if (_proposal.Payload == null || _proposal.Payload.Length == 0)
{
throw new Exception("Proposal payload is empty");
}
Header header;
try
{
header = Header.Parser.ParseFrom(_proposal.Header);
decodedSignedProposal.Proposal.Header = new ChaincodeProposalHeader();
}
catch (Exception ex)
{
throw new Exception($"Could not extract the header from the proposal: {ex}");
}
SignatureHeader signatureHeader;
try
{
signatureHeader = SignatureHeader.Parser.ParseFrom(header.SignatureHeader);
decodedSignedProposal.Proposal.Header.SignatureHeader =
new ChaincodeProposalHeaderSignatureHeader {
Nonce = signatureHeader.Nonce
};
}
catch (Exception ex)
{
throw new Exception($"Decoding SignatureHeader failed: {ex}");
}
try
{
var creator = SerializedIdentity.Parser.ParseFrom(signatureHeader.Creator);
decodedSignedProposal.Proposal.Header.SignatureHeader.Creator = creator;
Creator = creator;
}
catch (Exception ex)
{
throw new Exception($"Decoding SerializedIdentity failed: {ex}");
}
try
{
var channelHeader = ChannelHeader.Parser.ParseFrom(header.ChannelHeader);
decodedSignedProposal.Proposal.Header.ChannelHeader = channelHeader;
TxTimestamp = channelHeader.Timestamp;
}
catch (Exception ex)
{
throw new Exception($"Decoding ChannelHeader failed: {ex}");
}
ChaincodeProposalPayload payload;
try
{
payload = ChaincodeProposalPayload.Parser.ParseFrom(_proposal.Payload);
decodedSignedProposal.Proposal.Payload = payload;
}
catch (Exception ex)
{
throw new Exception($"Decoding ChaincodeProposalPayload failed: {ex}");
}
TransientMap = payload.TransientMap;
Binding = ComputeProposalBinding(decodedSignedProposal);
return(decodedSignedProposal);
}
private ChaincodeStub CreateTestChaincodeStub(SignedProposal proposal)
{
return(CreateChaincodeStub(null, "ChannelId", "TxId", new ChaincodeInput(), proposal));
}
