public ActionResult <ResponseApiModel> GetContractByAddress(RequestKeyApiModel model)
{
InitAuthKey(model);
SmartSourceCode res;
try
{
res = ServiceProvider.GetService <MonitorService>().GetContractByAddress(model);
if (res.SourceString != null /* && model.CompressString*/)
{
if (model.Compressed)
{
res.gZipped = Utils.Compress(res.SourceString);
}
res.SourceString = res.SourceString;
}
res.Success = true;
}
catch (Exception ex)
{
res = new SmartSourceCode();
res.Success = false;
res.Message = ex.Message;
}
return(Ok(res));
}
public void GetBalanceTest()
{
var service = new MonitorService(Configuration);
var model = new RequestKeyApiModel();
model.PublicKey =
//"CpXgMszs74C8ncSAyMiBEfZUhXtM6hyGBXRdXtG8aUUU";
"H5ptdUUfjJBGiK2X3gN2EzNYxituCUUnXv2tiMdQKP3b";
//"FeFjpcsfHErXPk5HkfVcwH6zYaRT2xNytDTeSjfuVywt";
model.NetworkIp = "68.183.230.109";
model.NetworkPort = "9090";
model.MethodApi = ApiMethodConstant.GetBalance;
model.NetworkAlias = /*"MainNet";*/ "TestNet";
//model.AuthKey = "87cbdd85-b2e0-4cb9-aebf-1fe87bf3afdd";
var response = service.GetBalance(model);
if (response.Tokens.Count > 1)
{
Debug.WriteLine(response.Tokens.ToList()[0].Amount);
}
Assert.IsNotNull(response);
Debug.WriteLine(JsonConvert.SerializeObject(response));
}
public ActionResult <ResponseApiModel> GetWalletInfo(RequestKeyApiModel model)
{
try
{
if (IsModelValid <ResponseApiModel>(model) is var valid && valid != null)
{
return(valid);
}
InitAuthKey(model);
var res = serviceProvider.GetService <MonitorService>().GetWalletData(model);
res.Success = true;
return(Ok(res));
}
catch (Exception ex)
{
return(BadRequest(new WalletDataResponseApiModel()
{
Success = false,
Message = ex.Message
}));
}
}
//public ResponseFeeModel GetActualFee(RequestFeeModel)
//{
// var res = new ResponseFeeModel();
// res.fee = 0.008740M;
//}
public ResponseApiModel GetContract(RequestKeyApiModel model)
{
var response = new ResponseApiModel();
using (var client = GetClientByModel(model))
{
var address = SimpleBase.Base58.Bitcoin.Decode(model.PublicKey).ToArray();
SmartContractGetResult smartContractGetResult = client.SmartContractGet(null);
var smartContractDataResult = client.SmartContractDataGet(address);
var contractInfo = ToContractInfo(smartContractGetResult.SmartContract, smartContractDataResult);
contractInfo.Found = smartContractGetResult.Status.Code == 0;
if (contractInfo.Found && contractInfo.IsToken)
{
var tokenInfo = client.TokenInfoGet(address);
if (tokenInfo?.Token != null)
{
contractInfo.Token = $"{tokenInfo.Token.Name} ({tokenInfo.Token.Code})";
}
}
foreach (var item in contractInfo.Methods.Split('\n'))
{
response.ListItem.Add(new ItemListApiModel()
{
Name = item,
});
}
}
return(response);
}
public void GetContractTest()
{
var service = new MonitorService(Configuration);
var model = new RequestKeyApiModel();
model.PublicKey = "12GfsQD7peXrxTsjyNVCJmpWWBJAYA9oKy9dGZHb5mJt";
model.NetworkIp = "68.183.230.109";
model.NetworkPort = "9090";
var response = service.GetContract(model);
Assert.IsNotNull(response);
Console.WriteLine(JsonConvert.SerializeObject(response));
}
public SmartSourceCode GetContractByAddress(RequestKeyApiModel model)
{
var response = new SmartSourceCode();
using (var client = GetClientByModel(model))
{
var publicKeyByte = SimpleBase.Base58.Bitcoin.Decode(model.PublicKey);
var result = client.SmartContractGet(publicKeyByte.ToArray());
if (result.SmartContract != null && result.SmartContract.SmartContractDeploy != null)
{
response.SourceString = result.SmartContract.SmartContractDeploy.SourceCode;
}
}
return(response);
}
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 SmartContractMethodsModel GetContractMethods(RequestKeyApiModel model)
{
var response = new SmartContractMethodsModel();
using (var client = GetClientByModel(model))
{
var publicKeyByte = SimpleBase.Base58.Bitcoin.Decode(model.PublicKey);
var preResult = client.SmartContractGet(publicKeyByte.ToArray());
if (preResult.SmartContract != null && preResult.SmartContract.SmartContractDeploy != null)
{
//response.SourceString = result.SmartContract.SmartContractDeploy.SourceCode;
var finalResult = client.ContractAllMethodsGet(preResult.SmartContract.SmartContractDeploy.ByteCodeObjects);
foreach (var met in finalResult.Methods)
{
var method = new ContractMethod();
method.Name = met.Name;
method.ReturnType = met.ReturnType;
foreach (var arg in met.Arguments)
{
var ar = new ModelMethodArgument();
ar.Name = arg.Name;
ar.Type = arg.Type;
foreach (var ann in arg.Annotations)
{
var an = new ModelAnnotation();
an.Name = ann.Name;
an.Arguments = ann.Arguments;
ar.Annotations.Add(an);
}
method.Arguments.Add(ar);
}
foreach (var ann in met.Annotations)
{
var an = new ModelAnnotation();
an.Name = ann.Name;
an.Arguments = ann.Arguments;
method.Annotations.Add(an);
}
response.Methods.Add(method);
}
}
}
return(response);
}
public IActionResult GetContract(RequestKeyApiModel model)
{
ResponseApiModel res;
try
{
res = ServiceProvider.GetService <MonitorService>().GetContract(model);
res.Success = true;
}
catch (Exception ex)
{
res = new ResponseApiModel();
res.Success = false;
res.Message = ex.Message;
}
return(Ok(res));
}
public ActionResult <ResponseApiModel> GetBalance(RequestKeyApiModel model)
{
BalanceResponseApiModel res;
try
{
res = ServiceProvider.GetService <MonitorService>().GetBalance(model);
res.Success = true;
}
catch (Exception ex)
{
res = new BalanceResponseApiModel();
res.Success = false;
res.Message = ex.Message;
}
return(Ok(res));
}
private BadRequestObjectResult IsModelValid <TResult>(RequestKeyApiModel model) where TResult : AbstractResponseApiModel, new()
{
string msg = "";
if (model == null || !ModelState.IsValid)
{
msg = "Model is not valid";
}
if (string.IsNullOrWhiteSpace(model.PublicKey))
{
msg = "Public Key is empty or not valid";
}
return(msg.Length != 0 ? BadRequest(new TResult
{
Success = false,
Message = msg
}) : null);
}
public ActionResult <SmartContractMethodsModel> GetContractMethods(RequestKeyApiModel model)
{
InitAuthKey(model);
SmartContractMethodsModel res;
try
{
res = ServiceProvider.GetService <MonitorService>().GetContractMethods(model);
res.Success = true;
}
catch (Exception ex)
{
res = new SmartContractMethodsModel();
res.Success = false;
res.Message = ex.Message;
}
return(Ok(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);
}
