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