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 void TestProposalBuilderWithOutMetaInf()
{
InstallProposalBuilder installProposalBuilder = InstallProposalBuilder.Create();
installProposalBuilder.ChaincodeLanguage(TransactionRequest.Type.GO_LANG);
installProposalBuilder.ChaincodePath("github.com/example_cc");
installProposalBuilder.ChaincodeSource(SAMPLE_GO_CC.Locate());
installProposalBuilder.ChaincodeName("example_cc.go");
installProposalBuilder.ChaincodeVersion("1");
Channel channel = hfclient.NewChannel("testProposalBuilderWithOutMetaInf");
TransactionContext transactionContext = new TransactionContext(channel, TestUtils.TestUtils.GetMockUser("rick", "rickORG"), Factory.Instance.GetCryptoSuite());
installProposalBuilder.Context(transactionContext);
Proposal proposal = installProposalBuilder.Build(); // Build it get the proposal. Then unpack it to see if it's what we expect.
ChaincodeProposalPayload chaincodeProposalPayload = ChaincodeProposalPayload.Parser.ParseFrom(proposal.Payload);
ChaincodeInvocationSpec chaincodeInvocationSpec = ChaincodeInvocationSpec.Parser.ParseFrom(chaincodeProposalPayload.Input);
ChaincodeSpec chaincodeSpec = chaincodeInvocationSpec.ChaincodeSpec;
ChaincodeInput input = chaincodeSpec.Input;
ChaincodeDeploymentSpec chaincodeDeploymentSpec = ChaincodeDeploymentSpec.Parser.ParseFrom(input.Args[1]);
ByteString codePackage = chaincodeDeploymentSpec.CodePackage;
List <string> tarBytesToEntryArrayList = TestUtils.TestUtils.TarBytesToEntryArrayList(codePackage.ToByteArray());
List <string> expect = new List <string>()
{
"src/github.com/example_cc/example_cc.go"
};
CollectionAssert.AreEquivalent(expect, tarBytesToEntryArrayList, "Tar in Install Proposal's codePackage does not have expected entries. ");
}
private Payload CreateTransactionCommonPayload(Proposal ccodeProposal, ByteString propResponsePayload, List <Endorsement> endrsements)
{
ChaincodeEndorsedAction chaincodeEndorsedAction = new ChaincodeEndorsedAction {
ProposalResponsePayload = propResponsePayload
};
chaincodeEndorsedAction.Endorsements.AddRange(endrsements);
//ChaincodeActionPayload
ChaincodeActionPayload chaincodeActionPayload = new ChaincodeActionPayload {
Action = chaincodeEndorsedAction
};
//We need to remove any transient fields - they are not part of what the peer uses to calculate hash.
ChaincodeProposalPayload p = ChaincodeProposalPayload.Parser.ParseFrom(ccodeProposal.Payload);
ChaincodeProposalPayload chaincodeProposalPayloadNoTrans = new ChaincodeProposalPayload {
Input = p.Input
};
chaincodeActionPayload.ChaincodeProposalPayload = chaincodeProposalPayloadNoTrans.ToByteString();
TransactionAction transactionAction = new TransactionAction();
Header header = Header.Parser.ParseFrom(ccodeProposal.Header);
if (Config.Instance.ExtraLogLevel(10))
{
if (null != diagnosticFileDumper)
{
StringBuilder sb = new StringBuilder(10000);
sb.Append("transaction header bytes:" + header.ToByteString().ToHexString());
sb.Append("\n");
sb.Append("transaction header sig bytes:" + header.SignatureHeader.ToHexString());
logger.Trace("transaction header: " + diagnosticFileDumper.CreateDiagnosticFile(sb.ToString()));
}
}
transactionAction.Header = header.SignatureHeader;
if (Config.Instance.ExtraLogLevel(10))
{
if (null != diagnosticFileDumper)
{
logger.Trace("transactionActionBuilder.setPayload: " + diagnosticFileDumper.CreateDiagnosticFile(chaincodeActionPayload.ToByteString().ToHexString()));
}
}
transactionAction.Payload = chaincodeActionPayload.ToByteString();
//Transaction
Transaction transaction = new Transaction();
transaction.Actions.Add(transactionAction);
return(new Payload {
Header = header, Data = transaction.ToByteString()
});
}
private static Proposal CreateChaincodeProposalWithTxIDNonceAndTransient(ChaincodeSpec ccis, TransactionHeader transactionHeader, Dictionary <string, string> transientMap)
{
var ccHdrExt = new ChaincodeHeaderExtension()
{
ChaincodeId = ccis.ChaincodeId
};
var ccHdrExtBytes = Util.Marshal(ccHdrExt);
var cis = new ChaincodeInvocationSpec()
{
ChaincodeSpec = ccis
};
var cisBytes = Util.Marshal(cis);
var ccPropPayload = new ChaincodeProposalPayload()
{
Input = cisBytes,
TransientMap = Util.ConvertMapField(transientMap)
};
var ccPropPayloadBytes = Util.Marshal(ccPropPayload);
var timestamp = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(DateTime.UtcNow);
// TODO: epoch is now set to zero. This must be changed once we
// get a more appropriate mechanism to handle it in.
ulong epoch = 0;
var hdr = new Header()
{
ChannelHeader = Util.Marshal(new ChannelHeader()
{
Type = (int)HeaderType.EndorserTransaction,
TxId = transactionHeader.Id,
Timestamp = timestamp,
ChannelId = transactionHeader.ChannelID,
Extension = ccHdrExtBytes,
Epoch = epoch
}),
SignatureHeader = Util.Marshal(new SignatureHeader()
{
Nonce = transactionHeader.Nonce,
Creator = transactionHeader.Creator
})
};
var hdrBytes = Util.Marshal(hdr);
var prop = new Proposal()
{
Header = hdrBytes,
Payload = ccPropPayloadBytes
};
return(prop);
}
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() }
});
}
private Proposal CreateFabricProposal(string chID, Protos.Peer.ChaincodeID ccodeID)
{
if (null == transientMap)
{
transientMap = new Dictionary <string, byte[]>();
}
if (IS_DEBUG_LEVEL)
{
foreach (KeyValuePair <string, byte[]> tme in transientMap)
{
logger.Debug($"transientMap('{tme.Key.LogString()}', '{Encoding.UTF8.GetString(tme.Value).LogString()}'))");
}
}
ChaincodeHeaderExtension chaincodeHeaderExtension = new ChaincodeHeaderExtension {
ChaincodeId = ccodeID
};
ChannelHeader chainHeader = ProtoUtils.CreateChannelHeader(HeaderType.EndorserTransaction, context.TxID, chID, context.Epoch, context.FabricTimestamp, chaincodeHeaderExtension, null);
ChaincodeInvocationSpec chaincodeInvocationSpec = CreateChaincodeInvocationSpec(ccodeID, ccType);
ChaincodeProposalPayload payload = new ChaincodeProposalPayload {
Input = chaincodeInvocationSpec.ToByteString()
};
foreach (KeyValuePair <string, byte[]> pair in transientMap)
{
payload.TransientMap.Add(pair.Key, ByteString.CopyFrom(pair.Value));
}
Header header = new Header {
SignatureHeader = ProtoUtils.GetSignatureHeaderAsByteString(context), ChannelHeader = chainHeader.ToByteString()
};
return(new Proposal {
Header = header.ToByteString(), Payload = payload.ToByteString()
});
}
