private Task <ChainCodeInvokeResponse> ChaincodeInvoke(IChaincodeStub stub)
{
try
{
var chaincode = new Chaincode();
chaincode.NameSpace = stub.GetChaincodeNameSpace();
chaincode.Name = stub.GetChaincodeName();
chaincode.Version = stub.GetChaincodeVersion();
var ass = _assemblyProvider.GetAssembly(stub.GetChannelId(), stub.GetChaincodeName(), stub.GetChaincodeNameSpace(), stub.GetChaincodeVersion());
var classfullname = chaincode.NameSpace + "." + chaincode.Name;
//必须使用 名称空间+类名称
var type = ass.GetType(classfullname);
//方法的名称
MethodInfo method = type.GetMethod("Invoke");
//必须使用名称空间+类名称
var obj = ass.CreateInstance(classfullname);
var rs = method.Invoke(obj, new object[] { stub });
if (rs != null)
{
return(Task.FromResult((ChainCodeInvokeResponse)rs));
}
}
catch (Exception ex)
{
return(null);
}
return(null);
}
/// <summary>
/// 在本地创建新的通道(特殊 等于是在本地创建创世区块)
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private ChainCodeInvokeResponse CreateNewChannel(IChaincodeStub stub)
{
var identity = stub.GetPeerIdentity();
var args = stub.GetArgs();
if (args.Length != 1)
{
return(stub.Response("参数个数不正确", StatusCode.BAD_ARGS_NUMBER));
}
//组织
var OrgConfig = new OrgConfig();
OrgConfig.OrgId = identity.OrgId;
OrgConfig.Name = identity.Name;
OrgConfig.Certificate = identity.Certificate;
OrgConfig.Address = identity.Address;
//通道
var channel = new ChannelConfig();
channel.ChannelID = args[0];
channel.OrgConfigs.Add(OrgConfig);
//初始化系统链码
InitSystemChainCode(channel);
stub.SetChannelConfig(channel);
return(stub.Response("", StatusCode.Successful));
}
private async Task <ByteString> InitLedger(IChaincodeStub stub, Parameters args)
{
var cars = new List <Car>
{
new Car("Toyota", "Prius", "blue", "Tomoko"),
new Car("Ford", "Mustang", "red", "Brad"),
new Car("Hyundai", "Tucson", "green", "Jin Soo"),
new Car("Volkswagen", "Passat", "yellow", "Max"),
new Car("Tesla", "S", "black", "Michael"),
new Car("Peugeot", "205", "purpe", "Michel"),
new Car("Chery", "522L", "white", "Aarav"),
new Car("Fiat", "Punto", "violet", "Pari"),
new Car("Tata", "Nano", "indigo", "Valeria"),
new Car("Holden", "Barina", "brown", "Shotaro")
};
for (var index = 0; index < cars.Count; index++)
{
var car = cars[index];
if (await stub.PutStateJson($"CAR{index}", car))
{
_logger.LogInformation("Added car", car.ToString());
}
else
{
_logger.LogError($"Error writing car {car} onto the ledger");
}
}
return(ByteString.Empty);
}
public override Response Init(IChaincodeStub stub)
{
Assert.AreEqual(stub.Function, "init");
Assert.AreEqual(stub.Args.Count, 3);
stub.PutState("a", ByteString.CopyFromUtf8("100").ToByteArray());
return(NewSuccessResponse("OK response1"));
}
//将身份信息注册到通道中
private ChainCodeInvokeResponse RegistMember(IChaincodeStub stub)
{
var args = stub.GetArgs();
if (args.Length != 1)
{
return(stub.Response("", StatusCode.BAD_ARGS_NUMBER));
}
//获取ca
var ca = Newtonsoft.Json.JsonConvert.DeserializeObject <Certificate>(args[0]);
//获取配置
var chainconfig = stub.GetState <ChannelConfig>(ConfigKey.Channel);
if (!ca.Check())
{
return(stub.Response("CA证书校验失败", StatusCode.BAD_OTHERS));
}
//获取组织
var org = chainconfig.OrgConfigs.Where(p => p.OrgId == ca.TBSCertificate.Issuer).FirstOrDefault();
if (org == null)
{
return(stub.Response("通道不存在" + ca.TBSCertificate.Issuer, StatusCode.BAD_OTHERS));
}
//判断组织中是否已经注册了该账号
//org.OrgMember.Where(p=>p.Certificate.TBSCertificate)
throw new NotImplementedException();
}
public ChainCodeInvokeResponse Invoke(IChaincodeStub stub)
{
try
{
var funcname = stub.GetFunction();
switch (funcname)
{
case ConfigKey.InitChannelFunc:
return(CreateNewChannel(stub));
case ConfigKey.AddOrgFunc:
return(AddOrg(stub));
case ConfigKey.UpdateOrgFunc:
return(UpdateOrg(stub));
case ConfigKey.AddOrgMemberFunc:
return(AddOrgMember(stub));
case ConfigKey.UpdateOrgMemberFunc:
return(UpdateOrgMember(stub));
default:
return(null);
}
}
catch (Exception ex)
{
return(stub.Response(ex.Message, StatusCode.BAD_OTHERS));
}
}
public static async Task <bool> PutPrivateData <T>(
this IChaincodeStub stub,
string collection,
string key,
T value
)
{
return(await stub.PutPrivateData(collection, key, value.ToString().ToByteString()).InvokeSafe());
}
/// <summary>
/// 更新组织 只能更改自己的组织节点
/// </summary>
/// <param name="stub"></param>
/// <returns></returns>
private ChainCodeInvokeResponse UpdateOrg(IChaincodeStub stub)
{
if (stub.GetArgs().Count() != 1)
{
return(stub.Response("", StatusCode.BAD_ARGS_NUMBER));
}
var arg = stub.GetArgs()[0];
OrgConfig newOrg = Newtonsoft.Json.JsonConvert.DeserializeObject <OrgConfig>(arg);
#region 数据完整性校验
if (string.IsNullOrEmpty(newOrg.OrgId))
{
return(stub.Response("组织ID不能为空", StatusCode.BAD_OTHERS));
}
if (string.IsNullOrEmpty(newOrg.Name))
{
return(stub.Response("组织名称不能为空", StatusCode.BAD_OTHERS));
}
if (string.IsNullOrEmpty(newOrg.Address))
{
return(stub.Response("组织链接地址不能为空", StatusCode.BAD_OTHERS));
}
if (newOrg.Certificate == null)
{
return(stub.Response("组织证书不能为空", StatusCode.BAD_OTHERS));
}
if (!newOrg.Certificate.Check())
{
return(stub.Response("证书数据不完整", StatusCode.BAD_OTHERS));
}
if (newOrg.Certificate.TBSCertificate.CAType != CAType.Peer)
{
return(stub.Response("证书类型不正确", StatusCode.BAD_OTHERS));
}
#endregion
var channelconfig = stub.GetChannelConfig();
//获取旧的组织配置
var oldorg = channelconfig.OrgConfigs.Where(p => p.OrgId == newOrg.OrgId).FirstOrDefault();
if (oldorg == null)
{
return(stub.Response("组织不存在", StatusCode.BAD_OTHERS));
}
oldorg.Address = newOrg.Address;
oldorg.Name = newOrg.Name;
oldorg.Certificate = newOrg.Certificate;
stub.SetChannelConfig(channelconfig);
return(stub.Response("", StatusCode.Successful));
}
private ChainCodeInvokeResponse FindByKey(IChaincodeStub stub)
{
if (stub.GetArgs().Length != 1)
{
return(stub.Response("", StatusCode.BAD_ARGS_NUMBER));
}
var rs = stub.GetState <Account>("a");
return(stub.Response(rs));
}
private async Task <ByteString> CreateCar(IChaincodeStub stub, Parameters args)
{
args.AssertCount(5);
var car = new Car(args.Get <string>(1), args.Get <string>(2), args.Get <string>(3), args.Get <string>(4));
await stub.PutState(args.Get <string>(0), JsonConvert.SerializeObject(car));
return(ByteString.Empty);
}
public override Response Invoke(IChaincodeStub stub)
{
string aKey = stub.StringArgs[1];
byte[] epBytes = stub.GetStateValidationParameter(aKey);
StateBasedEndorsement stateBasedEndorsement = new StateBasedEndorsement(epBytes);
Assert.AreEqual(stateBasedEndorsement.ListOrgs().Count, 2);
stub.SetStateValidationParameter(aKey, stateBasedEndorsement.Policy());
return(NewSuccessResponse("OK response2"));
}
public override async Task <Response> Invoke(IChaincodeStub stub)
{
var function = stub.GetFunctionAndParameters().Function;
_logger.LogInformation($"========== START: {function} ==========");
var result = await base.Invoke(stub);
_logger.LogInformation($"========== END: {function} ==========");
return(result);
}
private async Task <ByteString> ChangeCarOwner(IChaincodeStub stub, Parameters args)
{
args.AssertCount(2);
var car = await stub.GetStateJson <Car>(args.Get <string>(0));
car.Owner = args.Get <string>(1);
await stub.PutStateJson(args.Get <string>(0), car);
return(ByteString.Empty);
}
public override Response Init(IChaincodeStub stub)
{
try
{
Thread.Sleep(10);
}
catch (ThreadInterruptedException)
{
}
return(NewSuccessResponse());
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="stub"></param>
/// <returns></returns>
public ChainCodeInvokeResponse InitChaincode(IChaincodeStub stub)
{
try
{
/**
* 1.获取链码的配置信息
* 2.判断链码的状态 待初始化 运行中 已停止
* 3.状态为待初始化的才可进行初始化操作
* 4.初始化需要调用链码的 Init方法 需要用到链码执行器
*/
var args = stub.GetArgs();
if (args.Length != 2)
{
return(stub.Response("", StatusCode.BAD_ARGS_NUMBER));
}
var channelconfig = stub.GetChannelConfig();
var chaincode = channelconfig.ChainCodeConfigs
.Where(p => p.Name == args[0]).FirstOrDefault();
if (chaincode == null)
{
return(stub.Response("链码不存在", StatusCode.BAD_OTHERS));
}
//如果不是已安装状态
if (chaincode.Status != ChaincodeStatus.INSTALLED)
{
return(stub.Response("链码状态不正确", StatusCode.BAD_CHAINCODE_STATUS));
}
chaincode.Status = ChaincodeStatus.SERVICE;
var code = new QMBlockSDK.TX.Chaincode();
code.Name = chaincode.Name;
//code.NameSpace = chaincode.Namespace;
//code.Version = chaincode.Version;
code.Args = Newtonsoft.Json.JsonConvert.DeserializeObject <string[]>(args[1]);
var rs = stub.InitChaincode(code.Name, code.Args);
if (rs)
{
stub.SetChannelConfig(channelconfig);
return(stub.Response("", StatusCode.Successful));
}
else
{
return(stub.Response("", StatusCode.BAD_OTHERS));
}
}
catch (Exception ex)
{
return(stub.Response(ex.Message, StatusCode.BAD_OTHERS));
}
}
public ChainCodeInvokeResponse Invoke(IChaincodeStub stub)
{
var func = stub.GetFunction().ToUpper();
switch (func)
{
case "TRANSFER":
return(Transfer(stub));
default:
return(stub.Response("can not find function", StatusCode.BAD_OTHERS));
}
}
public ChainCodeInvokeResponse Query(IChaincodeStub stub)
{
var func = stub.GetFunction().ToUpper();
switch (func)
{
case "FINDBYKEY":
return(FindByKey(stub));
default:
return(null);
}
}
public override Response Invoke(IChaincodeStub stub)
{
Assert.AreEqual(stub.Function, "invoke");
Assert.AreEqual(stub.Args.Count, 3);
string aKey = stub.StringArgs[1];
Assert.AreEqual(aKey, "a");
string aVal = stub.GetStringState(aKey);
stub.PutState(aKey, ByteString.CopyFromUtf8("120").ToByteArray());
stub.DelState("delKey");
return(NewSuccessResponse("OK response2"));
}
public static async Task <T?> TryGetState <T>(this IChaincodeStub stub, string key)
where T : struct
{
try
{
var stateResult = await stub.GetState(key);
return(stateResult.Convert <T>());
}
catch
{
return(null);
}
}
public override Response Invoke(IChaincodeStub stub)
{
string query = stub.StringArgs[1];
using (IQueryResultsEnumerable <IKeyValue> stateByRange = stub.GetQueryResult(query))
{
foreach (IKeyValue kv in stateByRange)
{
//Do Nothing, just enumerate
}
}
return(NewSuccessResponse("OK response2"));
}
public override Response Invoke(IChaincodeStub stub)
{
string key = stub.StringArgs[1];
using (IQueryResultsEnumerable <IKeyModification> stateByRange = stub.GetHistoryForKey(key))
{
foreach (IKeyModification kv in stateByRange)
{
//Do Nothing, just enumerate
}
}
return(NewSuccessResponse("OK response2"));
}
public override Response Invoke(IChaincodeStub stub)
{
try
{
string function = stub.Function.ToLowerInvariant();
if (methodInfos.ContainsKey(function))
{
return((Response)methodInfos[function].Invoke(this, new object[] { stub }));
}
return(NewErrorResponse("Unknown function " + function));
}
catch (Exception e)
{
return(NewErrorResponse(e.Message));
}
}
private async Task <ByteString> InternalQuery(IChaincodeStub stub, Parameters args)
{
args.AssertCount(1);
var a = args[0];
var aValueBytes = await stub.GetState(a);
if (aValueBytes == null)
{
throw new Exception($"Failed to get state of asset holder {a}");
}
_logger.LogInformation($"Query Response: name={a}, value={aValueBytes.ToStringUtf8()}");
return(aValueBytes);
}
private async Task <ByteString> QueryCar(IChaincodeStub stub, Parameters args)
{
args.AssertCount(1);
var carNumber = args.Get <string>(0);
var carBytes = await stub.GetState(carNumber);
if (carBytes == null || carBytes.Length <= 0)
{
throw new Exception($"Car {carNumber} does not exist.");
}
_logger.LogInformation(carBytes.ToStringUtf8());
return(carBytes);
}
public ChainCodeInvokeResponse Init(IChaincodeStub stub)
{
var account = new Account()
{
Name = "李四",
Money = 1000
};
stub.PutState("a", account);
account = new Account()
{
Name = "张三",
Money = 1000
};
stub.PutState("b", account);
return(stub.Response("", StatusCode.Successful));
}
private async Task <ChainCodeInvokeResponse> SystemQuery(IChaincodeStub stub)
{
switch (stub.GetChaincodeName())
{
case ConfigKey.SysCodeLifeChaincode:
return(new CodeLifeChaincode().Query(stub));
case ConfigKey.SysNetConfigChaincode:
return(new NetConfigChaincode().Query(stub));
case ConfigKey.SysBlockQueryChaincode:
return(new BlockQueryChaincode().Query(stub));
default:
return(null);
}
}
public override Response Invoke(IChaincodeStub stub)
{
Assert.AreEqual(stub.Function, "invoke");
Assert.AreEqual(stub.Args.Count, 3);
string aKey = stub.StringArgs[1];
string bKey = stub.StringArgs[2];
using (IQueryResultsEnumerable <IKeyValue> stateByRange = stub.GetStateByRange(aKey, bKey))
{
foreach (IKeyValue kv in stateByRange)
{
//Do Nothing, just enumerate
}
}
return(NewSuccessResponse("OK response2"));
}
private async Task <ByteString> QueryAllCars(IChaincodeStub stub, Parameters args)
{
var startKey = "CAR0";
var endKey = "CAR999";
var iterator = await stub.GetStateByRange(startKey, endKey);
var result = new List <CarQueryResult>();
while (true)
{
var iterationResult = await iterator.Next();
if (iterationResult.Value != null && iterationResult.Value.Value.Length > 0)
{
var queryResult = new CarQueryResult
{
Key = iterationResult.Value.Key
};
try
{
queryResult.Record =
JsonConvert.DeserializeObject <Car>(iterationResult.Value.Value.ToStringUtf8());
}
catch (Exception ex)
{
_logger.LogError(ex,
$"An error occured while trying to deserialize {iterationResult.Value.Value.ToStringUtf8()}");
}
result.Add(queryResult);
}
if (iterationResult.Done)
{
_logger.LogInformation("End of data");
await iterator.Close();
_logger.LogInformation("Result", result);
return(JsonConvert.SerializeObject(result).ToByteString());
}
}
}
private async Task <ByteString> InternalInvoke(IChaincodeStub stub, Parameters args)
{
args.AssertCount(3);
var a = args.Get <string>(0);
var b = args.Get <string>(1);
if (string.IsNullOrEmpty(a) || string.IsNullOrEmpty(b))
{
throw new Exception("Asset holding must not be empty");
}
var aValue = await stub.TryGetState <int>(a);
if (!aValue.HasValue)
{
throw new Exception("Failed to get state of asset holder A");
}
var bValue = await stub.TryGetState <int>(b);
if (!bValue.HasValue)
{
throw new Exception("Failed to get state of asset holder B");
}
if (!args.TryGet <int>(2, out var amount))
{
throw new Exception("Expecting integer value for amount to be transferred");
}
aValue -= amount;
bValue += amount;
_logger.LogInformation($"aValue = {aValue}, bValue = {bValue}");
await stub.PutState(a, aValue);
await stub.PutState(b, bValue);
return(ByteString.Empty);
}
public ChainCodeInvokeResponse Query(IChaincodeStub stub)
{
try
{
var funcname = stub.GetFunction();
switch (funcname)
{
//查询配置信息
case ConfigKey.QueryChannelConfig:
return(QueryChannelConfig(stub));
default:
return(null);
}
}
catch (Exception ex)
{
return(stub.Response(ex.Message, StatusCode.BAD_OTHERS));
}
}
