public void Serialize(ref MessagePackWriter writer, IAccountStateDelta value,
MessagePackSerializerOptions options)
{
var state = new Dictionary(
value.UpdatedAddresses.Select(addr => new KeyValuePair <IKey, IValue>(
(Binary)addr.ToByteArray(),
value.GetState(addr) ?? new Bencodex.Types.Null()
))
);
var balance = new Bencodex.Types.List(
#pragma warning disable LAA1002
value.UpdatedFungibleAssets.SelectMany(ua =>
#pragma warning restore LAA1002
ua.Value.Select(c =>
{
FungibleAssetValue b = value.GetBalance(ua.Key, c);
return(new Bencodex.Types.Dictionary(new[]
{
new KeyValuePair <IKey, IValue>((Text)"address", (Binary)ua.Key.ToByteArray()),
new KeyValuePair <IKey, IValue>((Text)"currency", CurrencyExtensions.Serialize(c)),
new KeyValuePair <IKey, IValue>((Text)"amount", (Integer)b.RawValue),
}));
}
)
).Cast <IValue>()
);
var bdict = new Dictionary(new[]
{
new KeyValuePair <IKey, IValue>((Text)"states", state),
new KeyValuePair <IKey, IValue>((Text)"balances", balance),
});
writer.Write(new Codec().Encode(bdict));
}
public override void LoadPlainValue(IValue plainValue)
{
var asDict = (Dictionary)plainValue;
Sender = asDict["sender"].ToAddress();
Recipient = asDict["recipient"].ToAddress();
Amount = asDict["amount"].ToBigInteger();
Currency = CurrencyExtensions.Deserialize((Dictionary)asDict["currency"]);
}
public UnaryResult <byte[]> GetBalance(byte[] addressBytes, byte[] currencyBytes)
{
var address = new Address(addressBytes);
var serializedCurrency = (Bencodex.Types.Dictionary)_codec.Decode(currencyBytes);
Currency currency = CurrencyExtensions.Deserialize(serializedCurrency);
BigInteger balance = _blockChain.GetBalance(address, currency);
byte[] encoded = _codec.Encode((Bencodex.Types.Integer)balance);
return(UnaryResult(encoded));
}
public override IValue Serialize()
{
var values = new Dictionary <IKey, IValue>
{
[(Text)"currency"] = CurrencyExtensions.Serialize(Currency)
};
#pragma warning disable LAA1002
return(new Dictionary(values.Union((Dictionary)base.Serialize())));
#pragma warning restore LAA1002
}
public async Task <IWriterResult> CreateAddressBook(string userId, AddressBookModel model)
{
try
{
var address = model.Address;
if (model.AddressType == AddressType.Message || model.AddressType == AddressType.PayloadId || model.AddressType == AddressType.PaymentId)
{
address = $"{model.Address}:{model.PaymentId ?? string.Empty}";
}
if (model.CurrencyId == Constant.NZDT_ID && !string.IsNullOrEmpty(model.BankAccount))
{
address = $"{model.BankAccount}:{model.BankReference ?? string.Empty}";
if (!Constant.NZDT_BANK_REGEX.IsMatch(address))
{
return(new WriterResult(false, "Invalid Bank Account Number"));
}
}
if (model.AddressType == AddressType.PaymentId && !CurrencyExtensions.IsValidPaymentId(model.PaymentId))
{
return(new WriterResult(false, "Invalid {0} PaymentId", model.Symbol));
}
if (!await DepositService.ValidateAddress(model.CurrencyId, address).ConfigureAwait(false))
{
return(new WriterResult(false, "Invalid {0} Address", model.Symbol));
}
using (var context = ExchangeDataContextFactory.CreateContext())
{
var currentUser = new Guid(userId);
var addressBook = new Entity.AddressBook
{
Address = address,
CurrencyId = model.CurrencyId,
IsEnabled = true,
Label = model.Label,
UserId = currentUser,
};
context.AddressBook.Add(addressBook);
await context.SaveChangesAsync().ConfigureAwait(false);
return(new WriterResult(true));
}
}
catch (Exception)
{
return(new WriterResult(false, "Failed to validate {0} Address", model.Symbol));
}
}
public FungibleAssetValue GetBalance(Address address, Currency currency)
{
var result = _service.GetBalance(
address.ToByteArray(),
_codec.Encode(currency.Serialize())
);
byte[] raw = result.ResponseAsync.Result;
var serialized = (Bencodex.Types.List)_codec.Decode(raw);
return(FungibleAssetValue.FromRawValue(
CurrencyExtensions.Deserialize((Bencodex.Types.Dictionary)serialized.ElementAt(0)),
serialized.ElementAt(1).ToBigInteger()));
}
public UnaryResult <byte[]> GetBalance(byte[] addressBytes, byte[] currencyBytes)
{
var address = new Address(addressBytes);
var serializedCurrency = (Bencodex.Types.Dictionary)_codec.Decode(currencyBytes);
Currency currency = CurrencyExtensions.Deserialize(serializedCurrency);
FungibleAssetValue balance = _blockChain.GetBalance(address, currency);
byte[] encoded = _codec.Encode(
new Bencodex.Types.List(
new IValue[]
{
balance.Currency.Serialize(),
(Integer)balance.RawValue,
}
)
);
return(UnaryResult(encoded));
}
public IActionResult ConvertCurrency([FromBody] ConversionDto requestedConversion)
{
if (requestedConversion == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
var exchangeRate = _currencyConverterRepo
.GetRate(requestedConversion.FromCurrencyId, requestedConversion.ToCurrencyId);
var result = CurrencyExtensions.Convert(exchangeRate.Ratio, requestedConversion.Amount);
return(Ok(result));
}
public async Task <ActionResult> Create(WithdrawCurrencyModel model)
{
var currencyData = await CurrencyReader.GetCurrency(model.Symbol);
var user = await UserManager.FindValidByIdAsync(User.Identity.GetUserId());
if (currencyData == null || user == null)
{
ViewBag.Message = $"Currency {model.Symbol} not found.";
return(View("Error"));
}
if (currencyData.CurrencyId == Constant.NZDT_ID && !UserVerificationReader.IsVerified(user.VerificationLevel))
{
return(View("NotVerified"));
}
// Verify Address
var address = model.AddressData?.Trim();
if (string.IsNullOrEmpty(address))
{
address = model.SelectedAddress;
}
else if (currencyData.AddressType != AddressType.Standard)
{
if (currencyData.AddressType == AddressType.PaymentId && !CurrencyExtensions.IsValidPaymentId(model.AddressData2?.Trim()))
{
ModelState.AddModelError("AddressData2", $"Please enter a valid Cryptonote PaymentId.");
return(View(await CreateWithdrawModel(user, model)));
}
address = $"{model.AddressData?.Trim()}:{model.AddressData2?.Trim()}";
if (currencyData.Type == CurrencyType.Fiat)
{
address = address.TrimEnd(':');
}
}
if (string.IsNullOrEmpty(address))
{
ModelState.AddModelError(user.IsUnsafeWithdrawEnabled ? "AddressData" : "AddressBookError", $"Please enter a valid {model.Symbol} address");
return(View(await CreateWithdrawModel(user, model)));
}
// Verify Amount
var withdrawAmount = decimal.Round(model.Amount, currencyData.CurrencyDecimals);
if (withdrawAmount < currencyData.WithdrawMin || withdrawAmount >= currencyData.WithdrawMax)
{
ModelState.AddModelError("Amount", $"Withdrawal amount must be between {currencyData.WithdrawMin} {currencyData.Symbol} and {currencyData.WithdrawMax} {currencyData.Symbol}");
return(View(await CreateWithdrawModel(user, model)));
}
// Verify Two Factor
if (!await UserManager.VerifyUserTwoFactorCodeAsync(TwoFactorComponent.Withdraw, user.Id, model.Code1, model.Code2))
{
ModelState.AddModelError("TwoFactorError", "The TFA code entered was incorrect or has expired, please try again.");
return(View(await CreateWithdrawModel(user, model)));
}
// Create withdraw
var twoFactortoken = await GenerateUserTwoFactorTokenAsync(TwoFactorTokenType.WithdrawConfirm, user.Id);
var result = await WithdrawWriter.CreateWithdraw(User.Identity.GetUserId(), new CreateWithdrawModel
{
Address = address,
Amount = withdrawAmount,
CurrencyId = model.CurrencyId,
TwoFactorToken = twoFactortoken,
Type = WithdrawType.Normal,
});
if (!result.Success)
{
ModelState.AddModelError("Error", result.Message);
return(View(await CreateWithdrawModel(user, model)));
}
// Send Confirmation email
if (!user.DisableWithdrawEmailConfirmation)
{
await SendConfirmationEmail(user, model.Symbol, withdrawAmount - model.Fee, address, result.Result, twoFactortoken, currencyData.AddressType);
}
return(RedirectToAction("Summary", new { withdrawId = result.Result, returnUrl = GetLocalReturnUrl(model.ReturnUrl) }));
}
public static IValue Serialize(this FungibleAssetValue value) =>
new Bencodex.Types.List(new IValue[]
{
CurrencyExtensions.Serialize(value.Currency),
value.RawValue.Serialize(),
});
public GoldCurrencyState(Dictionary serialized)
: base(serialized)
{
Currency = CurrencyExtensions.Deserialize((Dictionary)serialized["currency"]);
}
