public WalletDataResponseApiModel GetWalletData(RequestKeyApiModel model)
{
var response = new WalletDataResponseApiModel();
using (var client = GetClientByModel(model))
{
var publicKeyByte = SimpleBase.Base58.Bitcoin.Decode(model.PublicKey);
var result = client.WalletDataGet(publicKeyByte.ToArray());
response.Balance = BCTransactionTools.GetDecimalByAmount(result.WalletData.Balance);
response.LastTransaction = result.WalletData.LastTransactionId;
var dStr = new DelegatedStructure();
if (result.WalletData.Delegated != null)
{
dStr.Incoming = BCTransactionTools.GetDecimalByAmount(result.WalletData.Delegated.Incoming);
dStr.Outgoing = BCTransactionTools.GetDecimalByAmount(result.WalletData.Delegated.Outgoing);
if (result.WalletData.Delegated.Donors != null)
{
foreach (var it in result.WalletData.Delegated.Donors)
{
var item = new DelegatedInfo();
item.PublicKey = SimpleBase.Base58.Bitcoin.Encode(it.Wallet);
item.Sum = BCTransactionTools.GetDecimalByAmount(it.Sum);
item.ValidUntil = it.ValidUntil;
dStr.Donors.Add(item);
}
}
if (result.WalletData.Delegated.Recipients != null)
{
foreach (var it in result.WalletData.Delegated.Recipients)
{
var item = new DelegatedInfo();
item.PublicKey = SimpleBase.Base58.Bitcoin.Encode(it.Wallet);
item.Sum = BCTransactionTools.GetDecimalByAmount(it.Sum);
item.ValidUntil = it.ValidUntil;
dStr.Recipients.Add(item);
}
}
}
response.Delegated = dStr;
}
return(response);
}
public FilteredTransactionsResponseModel GetFilteredTransactions(RequestFilteredListModel model)
{
var res = new FilteredTransactionsResponseModel();
using (var client = GetClientByModel(model))
{
var args = new API.FilteredTransactionsListGet_args();
args.GeneralQuery = new TransactionsQuery();
args.GeneralQuery.Flag = Convert.ToInt16((model.Flagg == "in") ? 1 : (model.Flagg == "out" ? 2 : 3));
args.GeneralQuery.Queries = new List <SingleQuery>();
foreach (var qry in model.Queries)
{
//var nq = new SingleQuery();
var sq = new SingleQuery();
sq.FromId = BCTransactionTools.GetTransactionIdByStr(qry.FromId == null ? "0.0" : qry.FromId);
sq.RequestedAddress = SimpleBase.Base58.Bitcoin.Decode(qry.Address).ToArray();
if (qry.TokenQueries != null)
{
sq.TokensList = new List <SingleTokenQuery>();
foreach (var tokenReq in qry.TokenQueries)
{
var sqt = new SingleTokenQuery();
sqt.FromId = BCTransactionTools.GetTransactionIdByStr(tokenReq.FromId);
sqt.TokenAddress = SimpleBase.Base58.Bitcoin.Decode(tokenReq.TokenAddress).ToArray();
sq.TokensList.Add(sqt);
}
}
args.GeneralQuery.Queries.Add(sq);
}
var qResult = client.FilteredTransactionsListGet(args.GeneralQuery);
if (model.Queries.Count() < qResult.QueryResponse.Count)
{
throw new Exception("Query and response lists are not syncronized");
}
foreach (var qRep in qResult.QueryResponse)
{
var qRes = new QueryResponseItem();
qRes.QueryAddress = SimpleBase.Base58.Bitcoin.Encode(qRep.RequestedAddress);
foreach (var tr in qRep.Transactions)
{
var newTr = new ShortTransactionInfo();
newTr.Amount = BCTransactionTools.GetDecimalByAmount(tr.Amount);
newTr.Currency = Convert.ToUInt16(tr.Currency);
var feeStr = Utils.ConvertCommission(tr.Fee.Commission).Replace(",", ".");
var style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
newTr.Fee = Decimal.Parse(feeStr, style, CultureInfo.InvariantCulture);
if (model.Flagg == "in")
{
newTr.Source = SimpleBase.Base58.Bitcoin.Encode(tr.Source);
}
else if (model.Flagg == "out")
{
newTr.Target = SimpleBase.Base58.Bitcoin.Encode(tr.Target);
}
else
{
newTr.Source = SimpleBase.Base58.Bitcoin.Encode(tr.Source);
newTr.Target = SimpleBase.Base58.Bitcoin.Encode(tr.Target);
}
newTr.TimeCreation = (new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).AddSeconds(tr.TimeCreation / 1000);
newTr.TransactionId = Convert.ToString(tr.Id.PoolSeq) + "." + Convert.ToString(tr.Id.Index);
newTr.Type = Convert.ToByte(tr.Type);
newTr.UserData = SimpleBase.Base58.Bitcoin.Encode(tr.UserFields);
qRes.Transactions.Add(newTr);
}
if (qRep.TransfersList != null)
{
foreach (var tokenResp in qRep.TransfersList)
{
var SingleTokenResponse = new QueryTokenResponseItem();
SingleTokenResponse.TokenAddress = SimpleBase.Base58.Bitcoin.Encode(tokenResp.TokenAddress);
SingleTokenResponse.TokenName = tokenResp.TokenName;
SingleTokenResponse.TokenTiker = tokenResp.TokenTiker;
if (tokenResp.Transfers != null)
{
foreach (var singleTokenTransfer in tokenResp.Transfers)
{
var singleTokenTransferResult = new TokenTransferInfo();
singleTokenTransferResult.TokenAddress = SimpleBase.Base58.Bitcoin.Encode(singleTokenTransfer.Token);
singleTokenTransferResult.Sender = SimpleBase.Base58.Bitcoin.Encode(singleTokenTransfer.Sender);
singleTokenTransferResult.Receiver = SimpleBase.Base58.Bitcoin.Encode(singleTokenTransfer.Receiver);
singleTokenTransferResult.TransferInitiator = SimpleBase.Base58.Bitcoin.Encode(singleTokenTransfer.Initiator);
singleTokenTransferResult.TokenCode = singleTokenTransfer.Code;
singleTokenTransferResult.TokenAmount = Convert.ToDecimal(singleTokenTransfer.Amount, CultureInfo.InvariantCulture);
singleTokenTransferResult.TransactionID = Convert.ToString(singleTokenTransfer.Transaction.PoolSeq) + "." + Convert.ToString(singleTokenTransfer.Transaction.Index);
singleTokenTransferResult.TimeCreation = (new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).AddSeconds(singleTokenTransfer.Time / 1000);
singleTokenTransferResult.UserData = SimpleBase.Base58.Bitcoin.Encode(singleTokenTransfer.UserFields);
if (singleTokenTransfer.Fee != null)
{
singleTokenTransferResult.Fee = Convert.ToDecimal(Utils.FeeByIndex(singleTokenTransfer.Fee.Commission), CultureInfo.InvariantCulture);
}
if (singleTokenTransfer.ExtraFee != null)
{
foreach (var it in singleTokenTransfer.ExtraFee)
{
var item = new EFeeItem();
item.Fee = Convert.ToDecimal(FormatAmount(it.Sum), CultureInfo.InvariantCulture);
item.Comment = it.Comment;
singleTokenTransferResult.ExtraFee.Add(item);
}
}
SingleTokenResponse.Transfers.Add(singleTokenTransferResult);
}
qRes.TransfersList.Add(SingleTokenResponse);
}
}
}
res.QuerieResponses.Add(qRes);
}
}
return(res);
}
public BalanceResponseApiModel GetBalance(RequestKeyApiModel model)
{
var response = new BalanceResponseApiModel();
using (var client = GetClientByModel(model))
{
var publicKeyByte = SimpleBase.Base58.Bitcoin.Decode(model.PublicKey);
var balanceCS = client.WalletBalanceGet(publicKeyByte.ToArray());
var amount = BCTransactionTools.GetDecimalByAmount(balanceCS.Balance);
decimal delOut = 0;
decimal delIn = 0;
if (balanceCS.Delegated != null)
{
if (balanceCS.Delegated.Outgoing != null)
{
delOut = BCTransactionTools.GetDecimalByAmount(balanceCS.Delegated.Outgoing);
}
if (balanceCS.Delegated.Outgoing != null)
{
delIn = BCTransactionTools.GetDecimalByAmount(balanceCS.Delegated.Incoming);
}
}
response.Balance = amount;
response.DelegatedOut = delOut;
response.DelegatedIn = delIn;
if (balanceCS.Status.Code > 0)
{
throw new Exception(balanceCS.Status.Message);
}
var balanceToken = client.TokenBalancesGet(publicKeyByte.ToArray());
if (balanceToken.Status.Code > 0)
{
throw new Exception(balanceToken.Status.Message);
}
foreach (var item in balanceToken.Balances)
{
if (String.IsNullOrEmpty(item.Balance))
{
continue;
}
var item1 = new Token();
item1.Alias = item.Code;
item1.Amount = Decimal.Parse(item.Balance, CultureInfo.InvariantCulture);
item1.PublicKey = SimpleBase.Base58.Bitcoin.Encode(item.Token);
item1.Name = item.Name;
response.Tokens.Add(
item1
);
}
}
response.Success = true;
return(response);
}
public ResponseApiModel ExecuteTransaction(RequestApiModel request, int isDelegate = 0)
{
ResponseApiModel response = null;
using (var client = GetClientByModel(request))
{
//снова инициируем транзакцию
var transac = InitTransaction(request);
transac.Signature = SimpleBase.Base58.Bitcoin.Decode(request.TransactionSignature).ToArray();
if (request.DelegateEnable && !request.DelegateDisable)
{
transac.UserFields = new byte[15] {
0, 1, 5, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0
}
}
;
else if (request.DelegateDisable && !request.DelegateEnable)
{
transac.UserFields = new byte[15] {
0, 1, 5, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0
}
}
;
TransactionFlowResult result = client.TransactionFlow(transac);
response = new ResponseApiModel();
response.FlowResult = result;
if (request.MethodApi == ApiMethodConstant.SmartDeploy)
{
response.DataResponse.PublicKey = SimpleBase.Base58.Bitcoin.Encode(transac.Target);
}
if (result.Status.Code > 0)
{
response.Success = false;
response.Message = result.Status.Message;
}
else
{
response.Success = true;
response.TransactionInnerId = transac.Id;
if (result.Id != null)
{
response.TransactionId = $"{result.Id.PoolSeq}.{result.Id.Index + 1}";
}
response.DataResponse.RecommendedFee = BCTransactionTools.GetDecimalByAmount(response.FlowResult.Fee);
if (response.DataResponse.RecommendedFee == 0)
{
response.DataResponse.RecommendedFee = MinTransactionFee;
}
var sum = BCTransactionTools.GetDecimalByAmount(transac.Amount);
if (sum > 0)
{
if (response.Amount == 0)
{
response.Amount = sum;
}
if (response.ActualSum == 0)
{
response.ActualSum = sum;
}
}
//TODO: extract fee from node
if (result.Fee != null)
{
response.ActualFee = BCTransactionTools.GetDecimalByAmount(result.Fee);
if (response.ActualFee == 0M)
{
response.ActualFee = MinTransactionFee;
}
}
if (result.ExtraFee != null)
{
response.ExtraFee = new List <EFeeItem>();
foreach (var eFee in result.ExtraFee)
{
var feeSum = BCTransactionTools.GetDecimalByAmount(eFee.Sum);
response.ExtraFee.Add(new EFeeItem()
{
Fee = feeSum,
Comment = eFee.Comment
});
}
}
if (request.MethodApi == ApiMethodConstant.SmartMethodExecute)
{
if (result.Smart_contract_result != null)
{
try
{
response.DataResponse.SmartContractResult = result.Smart_contract_result.ToString();
}
catch (Exception ex)
{
response.DataResponse.SmartContractResult = "";
}
}
}
}
}
return(response);
}
}
