public static bool TryFindAssetSettings(this ConstellationSettings constellationSettings, int assetId, out AssetSettings assetSettings)
{
assetSettings = null;
if (constellationSettings == null)
{
return(false);
}
assetSettings = constellationSettings.Assets.FirstOrDefault(a => a.Id == assetId);
return(assetSettings != null);
}
public static bool TryFindAssetSettings(this ConstellationSettings constellationSettings, Asset asset, out AssetSettings assetSettings)
{
assetSettings = null;
if (constellationSettings == null || asset == null)
{
return(false);
}
if (asset is AssetTypeNative)
{
assetSettings = constellationSettings.Assets.First(a => a.IsXlm);
}
else
{
var nonNativeAsset = (AssetTypeCreditAlphaNum)asset;
if (!(string.IsNullOrWhiteSpace(nonNativeAsset.Code) || string.IsNullOrWhiteSpace(nonNativeAsset.Issuer)))
{
assetSettings = constellationSettings.Assets.FirstOrDefault(a => a.Code == nonNativeAsset.Code && a.Issuer?.ToString() == nonNativeAsset.Issuer);
}
}
return(assetSettings != null);
}
public static ConstellationSettings ToSettings(this SettingsModel settings)
{
var assets = new List <AssetSettings>();
assets.Add(new AssetSettings());//add XLM
assets.AddRange(settings.Assets.Select(a => a.ToAssetSettings()).OrderBy(a => a.Id));
var resultSettings = new ConstellationSettings
{
Apex = settings.Apex,
Auditors = settings.Auditors.Select(a => (RawPubKey)a).OrderBy(a => a.ToString()).ToList(),
MinAccountBalance = settings.MinAccountBalance,
MinAllowedLotSize = settings.MinAllowedLotSize,
Vault = settings.Vault,
Assets = assets,
RequestRateLimits = new RequestRateLimits
{
HourLimit = settings.RequestRateLimits.HourLimit,
MinuteLimit = settings.RequestRateLimits.MinuteLimit
}
};
return(resultSettings);
}
public static WithdrawalWrapper GetWithdrawal(MessageEnvelope messageEnvelope, ConstellationSettings constellationSettings)
{
var withdrawalRequest = ((WithdrawalRequest)((RequestQuantum)messageEnvelope.Message).RequestMessage);
var transaction = withdrawalRequest.DeserializeTransaction();
var transactionHash = transaction.Hash();
var withdrawal = new WithdrawalWrapper
{
Hash = transactionHash,
Envelope = messageEnvelope
};
withdrawal.Withdrawals = transaction.GetWithdrawals(withdrawal.Source.Account, constellationSettings);
return(withdrawal);
}
private async Task <List <WithdrawalWrapper> > GetWithdrawals(AccountStorage accountStorage, ConstellationSettings constellationSettings)
{
var withdrawalApexes = accountStorage.GetAll().Where(a => a.Account.Withdrawal != default).Select(a => a.Account.Withdrawal).ToArray();
if (withdrawalApexes.Length < 1)
{
return(new List <WithdrawalWrapper>());
}
var withdrawalQuanta = await storage.LoadQuanta(withdrawalApexes);
var withdrawals = withdrawalQuanta
.Select(w =>
{
var withdrawalQuantum = XdrConverter.Deserialize <MessageEnvelope>(w.Bin);
var withdrawalRequest = ((WithdrawalRequest)((RequestQuantum)withdrawalQuantum.Message).RequestMessage);
withdrawalQuantum.TryAssignAccountWrapper(accountStorage);
return(WithdrawalWrapperExtensions.GetWithdrawal(withdrawalQuantum, constellationSettings));
});
return(withdrawals.OrderBy(w => w.Apex).ToList());
}
public static List <WithdrawalWrapperItem> GetWithdrawals(this stellar_dotnet_sdk.Transaction transaction, Account sourceAccount, ConstellationSettings constellationSettings)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
if (sourceAccount == null)
{
throw new ArgumentNullException(nameof(sourceAccount));
}
var payments = transaction.Operations
.Where(o => o is stellar_dotnet_sdk.PaymentOperation)
.Cast <stellar_dotnet_sdk.PaymentOperation>();
var withdrawals = new List <WithdrawalWrapperItem>();
foreach (var payment in payments)
{
if (!constellationSettings.TryFindAssetSettings(payment.Asset, out var asset))
{
throw new BadRequestException("Asset is not allowed by constellation.");
}
if (!ByteArrayPrimitives.Equals(payment.SourceAccount?.PublicKey, constellationSettings.Vault.Data))
{
throw new BadRequestException("Only vault account can be used as payment source.");
}
var amount = stellar_dotnet_sdk.Amount.ToXdr(payment.Amount);
if (amount < constellationSettings.MinAllowedLotSize)
{
throw new BadRequestException($"Min withdrawal amount is {constellationSettings.MinAllowedLotSize} stroops.");
}
if (!(sourceAccount.GetBalance(asset.Id)?.HasSufficientBalance(amount) ?? false))
{
throw new BadRequestException($"Insufficient balance.");
}
withdrawals.Add(new WithdrawalWrapperItem
{
Asset = asset.Id,
Amount = amount,
Destination = payment.Destination.PublicKey
});
}
if (withdrawals.GroupBy(w => w.Asset).Any(g => g.Count() > 1))
{
throw new BadRequestException("Multiple payments for the same asset.");
}
return(withdrawals);
}
