///<param name="asset">Asset to check balance of</param>
///<returns>Promise returns balance of given asset - default Client.StellarAsset()</returns>
async public Task <decimal> Balance(StellarResponses.AssetResponse asset = null)
{
if (asset == null)
{
asset = await new Client().StellarAsset();
}
var balance = this.FindBalance(asset);
return(decimal.Parse(balance.BalanceString));
}
///<param name="asset">Asset to check for trustline of</param>
///<returns>Promise returns true if trustline exists for given asset and limit is positive.</returns>
async public Task <Boolean> TrustlineExists(StellarResponses.AssetResponse asset = null)
{
if (asset == null)
{
asset = await new Client().StellarAsset();
}
var balance = this.FindBalance(asset);
decimal limit = decimal.Parse(balance.Limit);
return(limit > 0);
}
async private Task <Stellar.Transaction> GenerateSignedTransaction(Stellar.KeyPair keypair)
{
long randomSequence = (long)(99999999 - Math.Floor((decimal) new Random().Next() * 65536));
Stellar.Account account = new Stellar.Account(keypair, randomSequence);
Stellar.Transaction.Builder txBuilder = new Stellar.Transaction.Builder(account);
StellarResponses.AssetResponse asset = await new Library.Client().StellarAsset();
Stellar.Operation op = new Stellar.PaymentOperation.Builder(keypair, asset.Asset, "0.000001").Build();
Stellar.Transaction tx = txBuilder.AddOperation(op).Build();
tx.Sign(keypair);
return(Stellar.Transaction.FromEnvelopeXdr(tx.ToEnvelopeXdr()));
}
///<summary>Get Stellar Asset instance of asset used for payments</summary>
///<returns>Returns StellarSDK Asset instance of asset used for payments</returns>
async public Task <StellarResponses.AssetResponse> StellarAsset(string assetIssuer = null, string assetCode = AssetCode)
{
if (InnerStellarAsset != null)
{
return(InnerStellarAsset);
}
if (assetIssuer == null)
{
assetIssuer = GetAssetIssuer();
}
var responses = await HorizonClient.Assets.AssetIssuer(assetIssuer).AssetCode(assetCode).Execute();
InnerStellarAsset = responses.Records.FirstOrDefault();
return(InnerStellarAsset);
}
///<summary>Private: check if balance matches a given asset.</summary>
///<param name="asset">Asset to compare</param>
///<param name="balance">Balance entry to compare</param>
///<returns>Returns true if balance matches with given asset.</returns>
private Boolean BalanceMatches(StellarResponses.AssetResponse asset, StellarResponses.Balance balance)
{
string assetType = balance.AssetType;
string assetCode = balance.AssetCode;
string assetIssuer = balance.AssetIssuer.AccountId;
if (asset.Asset.GetType() == "native")
{
return(assetType == "native");
}
if (this.AssetIssuers.ContainsKey(assetCode) == false)
{
this.AssetIssuers[assetCode] = asset.AssetIssuer;
}
return(
assetCode == asset.AssetCode &&
assetIssuer == this.AssetIssuers[assetCode]
);
}
///<summary>Creates unlimited trustline for given asset.</summary>
///<param name="keypair">Account keypair</para>
///<param name="asset">(optional) - default to Client.StellarAsset()</param>
///<returns>Promise returns submitted transaction response.</returns>
async public Task <StellarResponses.SubmitTransactionResponse> Call(Stellar.KeyPair keypair, StellarResponses.AssetResponse asset = null)
{
Client client = new Client();
if (asset == null)
{
asset = await client.StellarAsset();
}
var account = await AccountBuilder.Build(keypair);
var _account = client.GetStellarAccount(account);
var tx = this.Tx(_account, asset.Asset);
tx.Sign(account.KeyPair().PrivateKey);
return(await client.HorizonClient.SubmitTransaction(tx));
}
///<summary>Private: find balance of asset.</summary>
///<param name="asset">Asset to find balance of</param>
///<returns>Returns matched balance.</returns>
private StellarResponses.Balance FindBalance(StellarResponses.AssetResponse asset)
{
return(this.InnerAccount.Balances.Where(b => this.BalanceMatches(asset, b)).FirstOrDefault());
}
