public override Task StartPartyPaymentControlAsync( Swap swap, CancellationToken cancellationToken = default) { Log.Debug("Start party payment control for swap {@swap}.", swap.Id); // initiator waits "accepted" event, acceptor waits "initiated" event var initiatedHandler = swap.IsInitiator ? new Func <Swap, CancellationToken, Task>(SwapAcceptedHandler) : new Func <Swap, CancellationToken, Task>(SwapInitiatedHandler); var lockTimeInSeconds = swap.IsInitiator ? DefaultAcceptorLockTimeInSeconds : DefaultInitiatorLockTimeInSeconds; var refundTimeUtcInSec = new DateTimeOffset(swap.TimeStamp.ToUniversalTime().AddSeconds(lockTimeInSeconds)).ToUnixTimeSeconds(); _ = EthereumSwapInitiatedHelper.StartSwapInitiatedControlAsync( swap: swap, currency: EthConfig, refundTimeStamp: refundTimeUtcInSec, interval: ConfirmationCheckInterval, initiatedHandler: initiatedHandler, canceledHandler: SwapCanceledHandler, cancellationToken: cancellationToken); return(Task.CompletedTask); }
public override async Task <Result <IBlockchainTransaction> > TryToFindPaymentAsync( Swap swap, CancellationToken cancellationToken = default) { var currency = Currencies .GetByName(swap.SoldCurrency); return(await EthereumSwapInitiatedHelper .TryToFindPaymentAsync( swap : swap, currency : currency, cancellationToken : cancellationToken) .ConfigureAwait(false)); }
public override async Task RefundAsync( Swap swap, CancellationToken cancellationToken = default) { var ethConfig = EthConfig; if (swap.StateFlags.HasFlag(SwapStateFlags.IsRefundBroadcast) && swap.RefundTx != null && swap.RefundTx.CreationTime != null && swap.RefundTx.CreationTime.Value.ToUniversalTime() + TimeSpan.FromMinutes(20) > DateTime.UtcNow) { _ = TrackTransactionConfirmationAsync( swap: swap, currency: ethConfig, dataRepository: _account.DataRepository, txId: swap.RefundTx.Id, confirmationHandler: RefundConfirmedEventHandler, cancellationToken: cancellationToken); return; } var lockTimeInSeconds = swap.IsInitiator ? DefaultInitiatorLockTimeInSeconds : DefaultAcceptorLockTimeInSeconds; var lockTime = swap.TimeStamp.ToUniversalTime() + TimeSpan.FromSeconds(lockTimeInSeconds); await RefundTimeDelayAsync(lockTime, cancellationToken) .ConfigureAwait(false); // check swap initiation try { var txResult = await EthereumSwapInitiatedHelper .TryToFindPaymentAsync(swap, ethConfig, cancellationToken) .ConfigureAwait(false); if (!txResult.HasError && txResult.Value == null) { // swap not initiated and must be canceled swap.StateFlags |= SwapStateFlags.IsCanceled; await UpdateSwapAsync(swap, SwapStateFlags.IsCanceled, cancellationToken) .ConfigureAwait(false); return; } } catch (Exception e) { Log.Error(e, $"Can't check {swap.Id} swap initiation for ETH"); } Log.Debug("Create refund for swap {@swap}", swap.Id); var gasPrice = await ethConfig .GetGasPriceAsync(cancellationToken) .ConfigureAwait(false); var walletAddress = await _account .GetAddressAsync(swap.FromAddress, cancellationToken) .ConfigureAwait(false); if (walletAddress == null) { Log.Error("Can't get address {@address} for refund from local db", swap.FromAddress); return; } var feeInEth = ethConfig.GetFeeAmount(ethConfig.RefundGasLimit, gasPrice); if (walletAddress.Balance < feeInEth) { Log.Error("Insufficient funds for refund"); return; } EthereumTransaction refundTx; try { await EthereumAccount.AddressLocker .LockAsync(walletAddress.Address, cancellationToken) .ConfigureAwait(false); var nonceResult = await EthereumNonceManager.Instance .GetNonceAsync(ethConfig, walletAddress.Address, pending : true, cancellationToken) .ConfigureAwait(false); if (nonceResult.HasError) { Log.Error("Nonce getting error with code {@code} and description {@description}", nonceResult.Error.Code, nonceResult.Error.Description); return; } var message = new RefundFunctionMessage { FromAddress = walletAddress.Address, HashedSecret = swap.SecretHash, GasPrice = EthereumConfig.GweiToWei(gasPrice), Nonce = nonceResult.Value, }; message.Gas = await EstimateGasAsync(message, new BigInteger(ethConfig.RefundGasLimit)) .ConfigureAwait(false); var txInput = message.CreateTransactionInput(ethConfig.SwapContractAddress); refundTx = new EthereumTransaction(ethConfig.Name, txInput) { Type = BlockchainTransactionType.Output | BlockchainTransactionType.SwapRefund }; var signResult = await SignTransactionAsync(refundTx, cancellationToken) .ConfigureAwait(false); if (!signResult) { Log.Error("Transaction signing error"); return; } swap.RefundTx = refundTx; swap.StateFlags |= SwapStateFlags.IsRefundSigned; await UpdateSwapAsync(swap, SwapStateFlags.IsRefundSigned, cancellationToken) .ConfigureAwait(false); await BroadcastTxAsync(swap, refundTx, cancellationToken) .ConfigureAwait(false); } catch { throw; } finally { EthereumAccount.AddressLocker.Unlock(walletAddress.Address); } swap.RefundTx = refundTx; swap.StateFlags |= SwapStateFlags.IsRefundBroadcast; await UpdateSwapAsync(swap, SwapStateFlags.IsRefundBroadcast, cancellationToken) .ConfigureAwait(false); _ = TrackTransactionConfirmationAsync( swap: swap, currency: ethConfig, dataRepository: _account.DataRepository, txId: refundTx.Id, confirmationHandler: RefundConfirmedEventHandler, cancellationToken: cancellationToken); }