public static void SwithShowMe(int id, BuyHandler bCallback = null, CancelHandler cCallback = null)
{
itemId_ = id;
buyCallback_ = bCallback;
cancelCallback_ = cCallback;
UIBase.SwitchShowPanelByName(UIASSETS_ID.UIASSETS_QuickBuyPanel);
}
public static void ShowMe(int id, BuyHandler bCallback = null, CancelHandler cCallback = null)
{
itemId_ = id;
buyCallback_ = bCallback;
cancelCallback_ = cCallback;
UIBase.AsyncLoad(UIASSETS_ID.UIASSETS_QuickBuyPanel);
}
public override async Task <bool> CheckCompletion()
{
try
{
Log.Debug("Ethereum: check refund event");
var wsUri = Web3BlockchainApi.WsUriByChain(Eth.Chain);
var web3 = new Web3(new WebSocketClient(wsUri));
var refundEventHandler = web3.Eth
.GetEvent <RefundedEventDTO>(Eth.SwapContractAddress);
var filter = refundEventHandler
.CreateFilterInput <byte[]>(Swap.SecretHash);
var events = await refundEventHandler
.GetAllChanges(filter)
.ConfigureAwait(false);
if (events.Count > 0)
{
Log.Debug("Refund event received");
CompleteHandler?.Invoke(this);
return(true);
}
}
catch (Exception e)
{
Log.Error(e, "Ethereum refund control task error");
}
CancelHandler?.Invoke(this);
return(true);
}
public void CancelCall(object sender)
{
closeTimer.Stop();
Confirmed = false;
Dismissed = true;
CancelHandler?.Invoke(this, null);
Close();
}
public override async Task <bool> CheckCompletion()
{
try
{
Log.Debug("Tezos: check refund event");
var contractAddress = Xtz.SwapContractAddress;
var api = (ITezosBlockchainApi)Xtz.BlockchainApi;
for (var page = 0; ; page++)
{
var txs = (await api
.GetTransactionsAsync(contractAddress, page)
.ConfigureAwait(false))
.Cast <TezosTransaction>()
.ToList();
if (txs.Count == 0)
{
break;
}
var swapTimeReached = false;
foreach (var tx in txs)
{
if (tx.To == contractAddress && tx.IsSwapRefund(Swap.SecretHash))
{
CompleteHandler?.Invoke(this);
return(true);
}
var blockTimeUtc = tx.BlockInfo.BlockTime.ToUniversalTime();
var swapTimeUtc = Swap.TimeStamp.ToUniversalTime();
if (blockTimeUtc < swapTimeUtc)
{
swapTimeReached = true;
break;
}
}
if (swapTimeReached)
{
break;
}
}
}
catch (Exception e)
{
Log.Error(e, "Tezos refund control task error");
}
CancelHandler?.Invoke(this);
return(true);
}
public override async Task <bool> CheckCompletion()
{
try
{
Log.Debug("Ethereum: check redeem event");
var wsUri = Web3BlockchainApi.WsUriByChain(Eth.Chain);
var web3 = new Web3(new WebSocketClient(wsUri));
var redeemEventHandler = web3.Eth
.GetEvent <RedeemedEventDTO>(Eth.SwapContractAddress);
var filter = redeemEventHandler
.CreateFilterInput <byte[]>(Swap.SecretHash);
var events = await redeemEventHandler
.GetAllChanges(filter)
.ConfigureAwait(false);
if (events.Count > 0)
{
Secret = events.First().Event.Secret;
Log.Debug("Redeem event received with secret {@secret}", Convert.ToBase64String(Secret));
CompleteHandler?.Invoke(this);
return(true);
}
}
catch (Exception e)
{
Log.Error(e, "Ethereum redeem control task error");
}
if (DateTime.UtcNow >= RefundTimeUtc)
{
Log.Debug("Time for refund reached");
CancelHandler?.Invoke(this);
return(true);
}
return(false);
}
/// <summary>
/// Wait for the table to get received.
/// </summary>
/// <param name="milliSeconds">Number of milliseconds to wait at most.</param>
/// <param name="cancelTest">Callback to allow a client to abort a scan.</param>
/// <param name="cancel">Set if client requests a cancel.</param>
/// <returns>Set if the table is fully available.</returns>
public bool Wait(int milliSeconds, CancelHandler cancelTest, ref bool cancel)
{
// Short cut
if (0 == milliSeconds) return HasFinished;
// With cleanup
try
{
// Wait in pieces
for (DateTime end = DateTime.UtcNow.AddMilliseconds(milliSeconds); DateTime.UtcNow <= end; Thread.Sleep(100))
{
// Process
if (HasFinished) return true;
// Ask user
if ((null == cancelTest) || !cancelTest()) continue;
// Mark
cancel = true;
// Done
return false;
}
// Done
return false;
}
finally
{
// Can stop filter
Dispose();
}
}
public CorutineCancelledBinder(Control context, CancelHandler handle)
: base(context)
{
handler = handle;
}
public override async Task <bool> CheckCompletion()
{
try
{
Log.Debug("Ethereum: check initiated event");
AttemptsCount++;
if (AttemptsCount == MaxAttemptsCount)
{
Log.Warning("Ethereum: maximum number of attempts to check initiated event reached");
CancelHandler?.Invoke(this);
return(true);
}
var side = Swap.Symbol
.OrderSideForBuyCurrency(Swap.PurchasedCurrency)
.Opposite();
var requiredAmountInEth = AmountHelper.QtyToAmount(side, Swap.Qty, Swap.Price);
var requiredAmountInWei = Atomix.Ethereum.EthToWei(requiredAmountInEth);
var requiredRewardForRedeemInWei = Atomix.Ethereum.EthToWei(Swap.RewardForRedeem);
var wsUri = Web3BlockchainApi.WsUriByChain(Eth.Chain);
var web3 = new Web3(new WebSocketClient(wsUri));
var contractAddress = Eth.SwapContractAddress;
if (!Initiated)
{
var eventHandlerInitiated = web3.Eth.GetEvent <InitiatedEventDTO>(contractAddress);
var filterIdInitiated = await eventHandlerInitiated
.CreateFilterAsync(
Swap.SecretHash,
Swap.ToAddress)
.ConfigureAwait(false);
var eventInitiated = await eventHandlerInitiated
//.GetFilterChanges(filterId)
.GetAllChanges(filterIdInitiated)
.ConfigureAwait(false);
if (eventInitiated.Count == 0)
{
return(false);
}
Initiated = true;
if (eventInitiated[0].Event.Value >= requiredAmountInWei - requiredRewardForRedeemInWei)
{
if (Swap.IsAcceptor)
{
if (eventInitiated[0].Event.RedeemFee != requiredRewardForRedeemInWei)
{
Log.Debug(
"Invalid redeem fee in initiated event. Expected value is {@expected}, actual is {@actual}",
requiredRewardForRedeemInWei,
(long)eventInitiated[0].Event.RedeemFee);
CancelHandler?.Invoke(this);
return(true);
}
if (eventInitiated[0].Event.RefundTimestamp != RefundTimestamp)
{
Log.Debug(
"Invalid refund time in initiated event. Expected value is {@expected}, actual is {@actual}",
RefundTimestamp,
eventInitiated[0].Event.RefundTimestamp);
CancelHandler?.Invoke(this);
return(true);
}
}
CompleteHandler?.Invoke(this);
return(true);
}
Log.Debug(
"Eth value is not enough. Expected value is {@expected}. Actual value is {@actual}",
requiredAmountInWei - requiredRewardForRedeemInWei,
(long)eventInitiated[0].Event.Value);
}
if (Initiated)
{
var eventHandlerAdded = web3.Eth.GetEvent <AddedEventDTO>(contractAddress);
var filterIdAdded = await eventHandlerAdded
.CreateFilterAsync <byte[]>(Swap.SecretHash)
.ConfigureAwait(false);
var eventsAdded = await eventHandlerAdded
//.GetFilterChanges(filterId)
.GetAllChanges(filterIdAdded)
.ConfigureAwait(false);
if (eventsAdded.Count == 0)
{
return(false);
}
foreach (var @event in eventsAdded)
{
if (@event.Event.Value >= requiredAmountInWei - requiredRewardForRedeemInWei)
{
CompleteHandler?.Invoke(this);
return(true);
}
Log.Debug(
"Eth value is not enough. Expected value is {@expected}. Actual value is {@actual}",
requiredAmountInWei - requiredRewardForRedeemInWei,
(long)@event.Event.Value);
}
}
}
catch (Exception e)
{
Log.Error(e, "Ethereum swap initiated control task error");
}
return(false);
}
public override async Task <bool> CheckCompletion()
{
try
{
Log.Debug("Tezos: check initiated event");
AttemptsCount++;
if (AttemptsCount == MaxAttemptsCount)
{
Log.Warning("Tezos: maximum number of attempts to check initiated event reached");
CancelHandler?.Invoke(this);
return(true);
}
var side = Swap.Symbol
.OrderSideForBuyCurrency(Swap.PurchasedCurrency)
.Opposite();
var requiredAmountInTz = AmountHelper.QtyToAmount(side, Swap.Qty, Swap.Price);
var requiredAmountInMtz = requiredAmountInTz.ToMicroTez();
var requiredRewardForRedeemInMtz = Swap.RewardForRedeem.ToMicroTez();
var contractAddress = Xtz.SwapContractAddress;
var api = (ITezosBlockchainApi)Xtz.BlockchainApi;
var detectedAmountInMtz = 0m;
var detectedRedeemFeeAmountInMtz = 0m;
for (var page = 0;; page++)
{
var txs = (await api
.GetTransactionsAsync(contractAddress, page)
.ConfigureAwait(false))
.Cast <TezosTransaction>()
.ToList();
if (txs.Count == 0)
{
break;
}
foreach (var tx in txs)
{
if (tx.IsConfirmed() && tx.To == contractAddress)
{
var detectedPayment = false;
if (tx.IsSwapInit(RefundTimestamp, Swap.SecretHash, Swap.ToAddress))
{
// init payment to secret hash!
detectedPayment = true;
detectedAmountInMtz += tx.Amount;
detectedRedeemFeeAmountInMtz = tx.GetRedeemFee();
}
else if (tx.IsSwapAdd(Swap.SecretHash))
{
detectedPayment = true;
detectedAmountInMtz += tx.Amount;
}
if (detectedPayment && detectedAmountInMtz >= requiredAmountInMtz)
{
if (Swap.IsAcceptor && detectedRedeemFeeAmountInMtz != requiredRewardForRedeemInMtz)
{
CancelHandler?.Invoke(this);
return(true);
}
CompleteHandler?.Invoke(this);
return(true);
}
}
var blockTimeUtc = tx.BlockInfo.BlockTime.ToUniversalTime();
var swapTimeUtc = Swap.TimeStamp.ToUniversalTime();
if (blockTimeUtc < swapTimeUtc)
{
return(false);
}
}
}
}
catch (Exception e)
{
Log.Error(e, "Tezos swap initiated control task error");
}
return(false);
}
