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);
}
