/// <summary>
/// 节点对交易进行背书
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <EndorseResponse> Endorse(TxRequest request)
{
EndorseResponse response = new EndorseResponse();
//背书
var result = await _node.ChainCodeSubmit(request);
if (result.StatusCode != StatusCode.Successful)
{
response.Status = false;
response.Msg = result.StatusCode.ToString() + ":" + result.Message;
return(response);
}
response.TxReadWriteSet = result.TxReadWriteSet;
response.Status = true;
response.Msg = "背书完成";
response.Endorsement.Identity = _configProviders.GetPublicIndentity();
//var str = Newtonsoft.Json.JsonConvert.SerializeObject(response);
var privatekey = _configProviders.GetPrivateKey();
//节点对背书数据签名
// response.Endorsement.Signature = DataHelper.RSASignature(str, privatekey);
response.Endorsement.Signature = RSAHelper.SignData(privatekey, response);
return(response);
}
public Task <ChainCodeInvokeResponse> ChaincodeInit(TxRequest request)
{
if (request.Data.Type != TxType.Invoke)
{
return(Task.FromResult(new ChainCodeInvokeResponse()
{
StatusCode = StatusCode.BAD_TX_TYPE
}));
}
var stub = GetChaincodeStub(request);
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("Init");
//必须使用名称空间+类名称
var obj = ass.CreateInstance(classfullname);
var rs = method.Invoke(obj, new object[] { stub });
if (rs != null)
{
return(Task.FromResult((ChainCodeInvokeResponse)rs));
}
return(null);
}
public Task <ChainCodeInvokeResponse> ChaincodeQuery(TxRequest request)
{
request.Data.Type = TxType.Query;
var stub = GetChaincodeStub(request);
return(ChaincodeQuery(stub));
}
public Task <TxResponse> TranspondTx(TxRequest request)
{
//签名
request = _configProviders.SignatureForTx(request);
var peer = _configProviders.GetPeer(CurrentState.LeaderId);
return(peer.Transaction(request));
}
public Task <TxResponse> Transaction(TxRequest request)
{
var response = new TxResponse()
{
Msg = "follower拒绝服务", Status = false
};
return(Task.FromResult(response));
}
public async Task <List <TransactionExtendedDto> > GetTransListByHashList(TxRequest model)
{
var reqJson = new TxRequestByHash {
HashList = model.HashList
};
const string url = "/txs";
return(await Post <TxRequestByHash, List <TransactionExtendedDto> >(model.NetworkName, url, reqJson));
}
//交易 peer
public async Task <TxResponse> Transaction(TxRequest request)
{
var node = _nodePeer.GetNode(request.Data.Channel.ChannelId);
if (node == null)
{
throw new Exception($"节点未加入{request.Header.ChannelId} 通道");
}
return(await node.Transaction(request));
}
public async Task <IActionResult> Tx([FromBody] TxRequest request)
{
var tx = await m_ChainManager.GetTxAsync(request);
if (tx == null)
{
return(NotFound("tx not found"));
}
return(Json(tx));
}
public ChaincodeStub(
IChainCodeExecutor chainCodeExecutor,
IMongoDatabase mongoDB,
TxRequest txRequest,
PeerIdentity peerIdentity)
{
_mongoDB = mongoDB;
_chainCodeExecutor = chainCodeExecutor;
_txRequest = txRequest;
_identity = peerIdentity;
_txReadWriteSet = new TxReadWriteSet();
}
public static TxRequest ToTxRequest(TxHeader header)
{
var txRequest = new TxRequest();
txRequest.Header = header;
txRequest.Data.Channel.ChannelId = header.ChannelId;
txRequest.Data.TxId = Guid.NewGuid().ToString();
txRequest.Data.Type = header.Type;
txRequest.Data.Timestamp = DateTime.Now.Ticks;
txRequest.Data.Channel.Chaincode.FuncName = header.FuncName;
txRequest.Data.Channel.Chaincode.Args = header.Args;
txRequest.Data.Channel.Chaincode.Name = header.ChaincodeName;
return(txRequest);
}
public void Tx()
{
// Arrange
var request = new TxRequest();
request.Params.Add(new TxRequestParams
{
Transaction = "E08D6E9754025BA2534A78707605E0601F03ACE063687A0CA1BDDACFCD1698C7",
Binary = false
});
// Act
var response =
_client.Transactions.TxAsync(request).Result;
// Assert
Assert.AreEqual(Status.Success, response.Result.Status);
}
/// <summary>
/// 如果是查询交易 直接返回本地查询结果
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <TxResponse> TransactionCommit(TxRequest request)
{
///如果是查询获取本地的结果就行并且不用背书
if (request.Data.Type == TxType.Query)
{
var rs = await ChainCodeSubmit(request);
var response = new TxResponse();
response.Msg = rs.Message;
response.Status = rs.StatusCode == StatusCode.Successful;
if (!response.Status)
{
response.Msg += "||" + rs.StatusCode.ToString();
}
response.Data = rs.Data;
return(response);
}
//转发交易
return(await State.TranspondTx(request));
}
public async Task <JObject> GetTxAsync(TxRequest request)
{
var httpResponseMessage = await this.m_HttpClient.PostAsync("/v1/history/get_transaction", CreateStringContent(JsonConvert.SerializeObject((object)new
{
id = request.Id
})));
if (httpResponseMessage.IsSuccessStatusCode)
{
var contentStr = await httpResponseMessage.Content.ReadAsStringAsync();
var response = JsonConvert.DeserializeObject <JObject>(contentStr);
response.Remove("_id");
var lastIrreversibleBlock = (int)response["last_irreversible_block"];
var block_num = (int)response["block_num"];
response.Add("confirmations", lastIrreversibleBlock - block_num > 0 ? (lastIrreversibleBlock - block_num) : 0);
return(response);
}
return(null);
}
public async Task <TxResponse> Transaction(TxRequest request)
{
try
{
var client = _httpClientFactory.CreateClient(QMRaftCore.Config.VoteHttpClientName);
HttpContent content = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(request));
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var response = await client.PostAsync(this.Id + "/api/Tx/peersubmit", content); //改成自己的
response.EnsureSuccessStatusCode(); //用来抛异常的
var responseBody = await response.Content.ReadAsStringAsync();
var model = Newtonsoft.Json.JsonConvert.DeserializeObject <TxResponse>(responseBody);
return(model);
}
catch (Exception e)
{
return(new TxResponse {
Status = false, Msg = e.Message
});
}
}
public async Task <TxResponse> Transaction(TxRequest request)
{
try
{
var model = new NetRequest
{
Data = Newtonsoft.Json.JsonConvert.SerializeObject(request)
};
var rs = await GetClient().TransactionAsync(model);
return(Newtonsoft.Json.JsonConvert.DeserializeObject <TxResponse>(rs.Data));
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(new TxResponse()
{
Status = false,
Msg = ex.Message
});
}
}
/// <summary>
/// The tx method retrieves information on a single transaction.
/// </summary>
public async Task <TransactionResponse> Tx(TxRequest request, CancellationToken cancellationToken = default)
{
jsonBuffer.Clear();
jsonWriter.Reset();
jsonWriter.WriteStartObject();
var requestId = WriteHeader(jsonWriter, "tx");
jsonWriter.WriteString("transaction", request.Transaction.ToString());
if (request.MinLedger.HasValue)
{
jsonWriter.WriteNumber("min_ledger", request.MinLedger.Value);
}
if (request.MaxLedger.HasValue)
{
jsonWriter.WriteNumber("max_ledger", request.MaxLedger.Value);
}
WriteFooter(jsonWriter);
jsonWriter.WriteEndObject();
jsonWriter.Flush();
var response = await SendReceiveAsync(requestId, jsonBuffer.WrittenMemory, cancellationToken);
return(new TransactionResponse(response));
}
private IChaincodeStub GetChaincodeStub(TxRequest request)
{
//如果是初始化通道通道的config是null
var requestData = request.Data;
var identity = _identityProvider.GetPeerIdentity();
//如果是初始化化通道
if (request.Header.ChaincodeName == ConfigKey.SysNetConfigChaincode && request.Header.FuncName == ConfigKey.InitChannelFunc)
{
return(new ChaincodeStub(this, _dataManager.GetStatusDB(), request, identity));
}
//如果是其他链码 获取链码配置
var config = _dataManager.GetChannelConfig();
var chaincode = config.ChainCodeConfigs.Where(p => p.Name == requestData.Channel.Chaincode.Name).FirstOrDefault();
if (chaincode == null)
{
throw new Exception("链码不存在");
}
requestData.Channel.Chaincode.Version = chaincode.Version;
requestData.Channel.Chaincode.NameSpace = chaincode.Namespace;
return(new ChaincodeStub(this, _dataManager.GetStatusDB(), request, identity));
}
public async Task <ChainCodeInvokeResponse> ChainCodeSubmit(TxRequest request)
{
return(await _chainCodeExecutor.Submit(request));
}
public async Task <EndorseResponse> Endorse(TxRequest request)
{
var response = await State.Endorse(request);
return(response);
}
public async Task <TxResponse> Transaction(TxRequest request)
{
_logger.LogInformation($"节点转发交易 通道{_channelId}");
return(await State.Transaction(request));
}
/// <summary>
/// 转发交易
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Task <TxResponse> TranspondTx(TxRequest request)
{
//对交易进行签名
request = _configProviders.SignatureForTx(request);
return(_node.Transaction(request));
}
/** 根据交易类型 执行不同的函数
*
* Config --->Config的链码中
* Invoke ---> IChaincode 的 Invoke 返回 InvokeReponse
* Query ---> IChaincode 的 Query方法 返回读集和T 数据
*
**/
public Task <ChainCodeInvokeResponse> Submit(TxRequest request)
{
var stub = GetChaincodeStub(request);
return(Submit(stub));
}
/// <summary>
/// 将交易发给需要背书的背书节点
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <TxResponse> Transaction(TxRequest request)
{
var requestData = request.Data;
var txResponse = new TxResponse();
//获取链码配置中的背书节点,
var peers = _configProviders.GetEndorsePeer(requestData.Channel.Chaincode);
var taskList = new Dictionary <string, Task <EndorseResponse> >();
var endorseDir = new Dictionary <string, EndorseResponse>();
var endorseRequest = new EndorseRequest
{
ChannelId = request.Header.ChannelId,
Request = request
};
//添加背书task
foreach (var item in peers)
{
if (item.Id == CurrentState.Id)
{
taskList.Add(item.Id, Endorse(request));
}
else
{
taskList.Add(item.Id, item.Endorse(endorseRequest));
}
}
var txResult = false;
var count = 0;
while (true)
{
taskList = taskList.Where(p => !endorseDir.ContainsKey(p.Key)).ToDictionary(p => p.Key, p => p.Value);
//如果没有进行过背书 则返回false
if (taskList.Count() == 0)
{
txResponse.Msg = "不满足背书策略";
break;
}
foreach (var item in taskList)
{
if (item.Value.IsCompleted)
{
endorseDir.Add(item.Key, await item.Value);
}
}
///验证背书策略
var rs = _configProviders.ValidateEndorse(requestData.Channel.Chaincode, endorseDir);
if (rs)
{
txResult = true;
break;
}
Thread.Sleep(20);
if (count * 20 > _configProviders.GetEndorseTimeOut())
{
txResponse.Msg = "背书超时";
break;
}
}
//如果背书策略通过
if (txResult)
{
//交易封装对象 交易头 背书结果 背书签名
var envelopr = new Envelope
{
TxReqeust = request
};
var endorses = endorseDir.Select(p => p.Value).ToList();
foreach (var item in endorses)
{
//将背书结果赋值给交易信封 只需要赋值一次
if (envelopr.PayloadReponse.Status == false)
{
envelopr.PayloadReponse.Status = item.Status;
envelopr.PayloadReponse.Message = item.Msg;
envelopr.PayloadReponse.TxReadWriteSet = item.TxReadWriteSet;
}
envelopr.Endorsements.Add(item.Endorsement);
}
//交易加入交易池中
_node.TxPool.Add(envelopr);
return(new TxResponse()
{
Status = true, Msg = "等待上链", TxId = request.Data.TxId
});
/*
* //var statusRs = await _node.TxPool.TxStatus(envelopr.TxReqeust.Data.TxId);
* if (statusRs == "0")
* {
* txResponse.Status = true;
* txResponse.Msg = "上链成功";
* }
* if (statusRs == "1")
* {
* txResponse.Status = false;
* txResponse.Msg = "上链失败";
* }
* if (statusRs == "2")
* {
* txResponse.Status = true;
* txResponse.Msg = "服务器忙";
* }
*/
//return txResponse;
}
else
{
//失败的
var errorTx = endorseDir.Where(p => p.Value.Status == false).Select(p => p.Key + ":" + p.Value.Msg).ToList();
txResponse.Msg = "背书失败";
txResponse.Data = errorTx;
txResponse.Status = false;
txResponse.TxId = request.Data.TxId;
return(txResponse);
}
}
//peer级别
//[Authorize(Roles = "Peer")]
public async Task <JsonResult> Transaction(TxRequest model)
{
var rs = await _txService.Transaction(model);
return(new JsonResult(rs));
}
public static async Task <TxProcessInfo> PrepareTransaction(User from, User to, decimal amount, string platform, string txType, BitcornContext dbContext)
{
var request = new TxRequest(from, amount, platform, txType, $"userid|{to.UserId}");
return(await ProcessRequest(request, dbContext));
}
private static async Task <SubscriptionResponse> ProcessSubscription(BitcornContext dbContext, SubscriptionResponse output, SubRequest subRequest, Subscription subInfo, SubscriptionTier requestedTierInfo, User user)
{
decimal cost = 0;
//if tier usdt cost has been initialized, the corn cost has to be calculated
if (requestedTierInfo.CostUsdt != null && requestedTierInfo.CostUsdt > 0)
{
cost = await CalculateUsdtToCornCost(dbContext, requestedTierInfo);
}
// check if cost is initialized properly
else if (requestedTierInfo.CostCorn != null && requestedTierInfo.CostCorn > 0)
{
cost = requestedTierInfo.CostCorn.Value;
}
else
{
throw new ArgumentException($"Invalid cost setting on subscription tier id:{requestedTierInfo.SubscriptionId}");
}
//set the amount that will be removed from subscriber to the response object
output.Cost = cost;
//initialize array of existing subscriptions
UserSubcriptionTierInfo[] existingSubscriptions = new UserSubcriptionTierInfo[0];
if (user != null)
{
//set data to existing subscriptions array
existingSubscriptions = await GetUserSubscriptions(dbContext, user)
.Where(t => t.SubscriptionTier.SubscriptionId == subInfo.SubscriptionId).ToArrayAsync();
}
//initialize reference to existing subtierinfo
UserSubcriptionTierInfo existingSubscription = null;
//initialize current substate
var subState = SubscriptionState.None;
//if any subscriptions were found
if (existingSubscriptions.Any())
{
//set existing subtierinfo
existingSubscription = existingSubscriptions[0];
//if sub has expired, set substate to expired
if (subInfo.HasExpired(existingSubscription.UserSubscription))
{
subState = SubscriptionState.Expired;
}
//if existing sub has not expired, but the tier is below, set subState to TierDown
else if (existingSubscription.SubscriptionTier.Tier < requestedTierInfo.Tier)
{
subState = SubscriptionState.TierDown;
}
//else, the user is subscribed
else
{
subState = SubscriptionState.Subscribed;
}
}
//initialize reference to usersubscription & tx request
UserSubscription sub = null;
TxRequest txRequest = null;
//if current user sub state is not subscribed & the client confirmed the cost to be equal to the cost amount, attempt to subscribe
var costDiff = Math.Abs(subRequest.Amount - cost);
if (subState != SubscriptionState.Subscribed && costDiff <= 100000)//subRequest.Amount == cost)
{
//initialize recipient of the transaction
string[] to = new string[1];
//default to bitcornhub if no subscription owner has been set
int recipientId = TxUtils.BitcornHubPK;
//if subscription owner is set, overwrite bitcornhub
if (subInfo.OwnerUserId != null && subInfo.OwnerUserId > 0)
{
recipientId = subInfo.OwnerUserId.Value;
}
to[0] = $"userid|{recipientId}";
//initialize tx request
txRequest = new TxRequest(user, cost, subRequest.Platform, "$sub", to);
//prepare transaction for saving
var processInfo = await TxUtils.ProcessRequest(txRequest, dbContext);
var transactions = processInfo.Transactions;
if (transactions != null && transactions.Length > 0)
{
StringBuilder sql = new StringBuilder();
//check if transaction can be executed
if (processInfo.WriteTransactionOutput(sql))
{
//transaction is ready to be saved
switch (subState)
{
case SubscriptionState.None:
//user was previously not subscribed, create instance of usersubscription and point it to the user
sub = new UserSubscription();
sub.SubscriptionId = subInfo.SubscriptionId;
sub.SubscriptionTierId = requestedTierInfo.SubscriptionTierId;
sub.UserId = user.UserId;
sub.FirstSubDate = DateTime.Now;
sub.SubCount = 1;
dbContext.UserSubscription.Add(sub);
break;
case SubscriptionState.TierDown:
case SubscriptionState.Expired:
//previous subscription was found, update subscription tier
existingSubscription.UserSubscription.SubscriptionTierId = requestedTierInfo.SubscriptionTierId;
existingSubscription.UserSubscription.SubCount += 1;
sub = existingSubscription.UserSubscription;
break;
default:
break;
}
//set subscription date to now
sub.LastSubDate = DateTime.Now;
await DbOperations.ExecuteSqlRawAsync(dbContext, sql.ToString());
await dbContext.SaveAsync(IsolationLevel.RepeatableRead);
//create subtx that will link user, corntx and usersubscription together
var subTx = new SubTx();
subTx.UserId = user.UserId;
subTx.SubTxId = transactions[0].TxId.Value;
subTx.UserSubscriptionId = sub.UserSubscriptionId;
dbContext.SubTx.Add(subTx);
//if user was not subscribed before, attempt to share the payment with a referrer
if (!await TrySharePaymentWithReferrer(dbContext, output, subRequest, subInfo, requestedTierInfo, user, recipientId, cost, subState, subTx))
{
await dbContext.SaveAsync();
}
subState = SubscriptionState.Subscribed;
}
//append receipt object with what client requested
await TxUtils.AppendTxs(transactions, dbContext, subRequest.Columns);
var tx = transactions[0];
output.TxId = tx.TxId;
output.User = tx.From;
}
}
//couldn't process transaction
if (txRequest == null)
{
//fill out response object
await PopuplateUserResponse(dbContext, subRequest, output, user);
if (existingSubscription != null)
{
sub = existingSubscription.UserSubscription;
}
}
if (subState == SubscriptionState.Subscribed && sub != null)
{
var end = output.SubscriptionEndTime = sub.LastSubDate.Value.AddDays(subInfo.Duration);
//calculate days left
output.DaysLeft = Math.Ceiling((end.Value - DateTime.Now).TotalDays);
//setup sub info
output.UserSubscriptionInfo = await GetUserSubscriptions(dbContext, user)
.Where(t => t.SubscriptionTier.SubscriptionId == subInfo.SubscriptionId).FirstOrDefaultAsync();
}
return(output);
}
public async Task <RpcJsonResponse <TransactionEntryResult> > TxAsync(TxRequest request)
{
return(await PostAsync <RpcJsonResponse <TransactionEntryResult>, TransactionEntryResult>(request));
}
public Envelope()
{
TxReqeust = new TxRequest();
PayloadReponse = new ProposaResponsePayload();
Endorsements = new List <Signer>();
}
public TxRequest SignatureForTx(TxRequest tx)
{
return(tx);
}
