public override Task StartWaitForRedeemBySomeoneAsync(
Swap swap,
CancellationToken cancellationToken = default)
{
Log.Debug("Wait redeem for swap {@swapId}", swap.Id);
// start redeem control async
FA2SwapRedeemedHelper.StartSwapRedeemedControlAsync(
swap: swap,
currency: FA2,
tezos: Xtz,
refundTimeUtc: swap.TimeStamp.ToUniversalTime().AddSeconds(DefaultAcceptorLockTimeInSeconds),
interval: TimeSpan.FromSeconds(30),
cancelOnlyIfRefundTimeReached: true,
redeemedHandler: RedeemBySomeoneCompletedEventHandler,
canceledHandler: RedeemBySomeoneCanceledEventHandler,
cancellationToken: cancellationToken)
.FireAndForget();
return(Task.CompletedTask);
}
public override Task StartWaitForRedeemAsync(
Swap swap,
CancellationToken cancellationToken = default)
{
var lockTimeInSeconds = swap.IsInitiator
? DefaultInitiatorLockTimeInSeconds
: DefaultAcceptorLockTimeInSeconds;
// start redeem control async
FA2SwapRedeemedHelper.StartSwapRedeemedControlAsync(
swap: swap,
currency: FA2,
tezos: Xtz,
refundTimeUtc: swap.TimeStamp.ToUniversalTime().AddSeconds(lockTimeInSeconds),
interval: TimeSpan.FromSeconds(30),
cancelOnlyIfRefundTimeReached: true,
redeemedHandler: RedeemCompletedEventHandler,
canceledHandler: RedeemCanceledEventHandler,
cancellationToken: cancellationToken)
.FireAndForget();
return(Task.CompletedTask);
}
public override async Task RedeemAsync(
Swap swap,
CancellationToken cancellationToken = default)
{
var fa2 = FA2;
var secretResult = await FA2SwapRedeemedHelper
.IsRedeemedAsync(
swap : swap,
currency : fa2,
tezos : Xtz,
attempts : MaxRedeemCheckAttempts,
attemptIntervalInSec : RedeemCheckAttemptIntervalInSec,
cancellationToken : cancellationToken)
.ConfigureAwait(false);
if (!secretResult.HasError && secretResult.Value != null)
{
RedeemConfirmedEventHandler(swap, null, cancellationToken);
return;
}
if (swap.StateFlags.HasFlag(SwapStateFlags.IsRedeemBroadcast) &&
swap.RedeemTx != null &&
swap.RedeemTx.CreationTime != null &&
swap.RedeemTx.CreationTime.Value.ToUniversalTime() + TimeSpan.FromMinutes(5) > DateTime.UtcNow)
{
// redeem already broadcast
TrackTransactionConfirmationAsync(
swap: swap,
currency: fa2,
txId: swap.RedeemTx.Id,
confirmationHandler: RedeemConfirmedEventHandler,
cancellationToken: cancellationToken)
.FireAndForget();
return;
}
// check already refunded by initiator
if (swap.IsAcceptor &&
swap.TimeStamp.ToUniversalTime().AddSeconds(DefaultInitiatorLockTimeInSeconds) < DateTime.UtcNow)
{
var isRefundedByParty = await FA2SwapRefundedHelper
.IsRefundedAsync(swap, fa2, Xtz, cancellationToken)
.ConfigureAwait(false);
if (isRefundedByParty != null &&
!isRefundedByParty.HasError &&
isRefundedByParty.Value)
{
swap.StateFlags |= SwapStateFlags.IsUnsettled;
RaiseSwapUpdated(swap, SwapStateFlags.IsUnsettled);
return;
}
}
if (swap.IsInitiator)
{
var redeemDeadline = swap.TimeStamp.ToUniversalTime().AddSeconds(DefaultAcceptorLockTimeInSeconds) - RedeemTimeReserve;
if (DateTime.UtcNow > redeemDeadline)
{
Log.Error("Redeem dedline reached for swap {@swap}", swap.Id);
return;
}
}
Log.Debug("Create redeem for swap {@swapId}", swap.Id);
var walletAddress = (await FA2Account
.GetUnspentAddressesAsync(
toAddress: swap.ToAddress,
amount: 0,
fee: 0,
feePrice: 0,
feeUsagePolicy: FeeUsagePolicy.EstimatedFee,
addressUsagePolicy: AddressUsagePolicy.UseOnlyOneAddress,
transactionType: BlockchainTransactionType.SwapRedeem,
cancellationToken: cancellationToken)
.ConfigureAwait(false))
.FirstOrDefault();
if (walletAddress == null)
{
Log.Error("Insufficient funds for redeem");
return;
}
var redeemTx = new TezosTransaction
{
Currency = fa2,
CreationTime = DateTime.UtcNow,
From = walletAddress.Address,
To = fa2.SwapContractAddress,
Amount = 0,
Fee = fa2.RedeemFee + fa2.RevealFee,
GasLimit = fa2.RedeemGasLimit,
StorageLimit = fa2.RedeemStorageLimit,
Params = RedeemParams(swap),
UseDefaultFee = true,
Type = BlockchainTransactionType.Output | BlockchainTransactionType.SwapRedeem
};
var signResult = await SignTransactionAsync(redeemTx, cancellationToken)
.ConfigureAwait(false);
if (!signResult)
{
Log.Error("Transaction signing error");
return;
}
swap.RedeemTx = redeemTx;
swap.StateFlags |= SwapStateFlags.IsRedeemSigned;
RaiseSwapUpdated(swap, SwapStateFlags.IsRedeemSigned);
await BroadcastTxAsync(swap, redeemTx, cancellationToken)
.ConfigureAwait(false);
swap.RedeemTx = redeemTx;
swap.StateFlags |= SwapStateFlags.IsRedeemBroadcast;
RaiseSwapUpdated(swap, SwapStateFlags.IsRedeemBroadcast);
TrackTransactionConfirmationAsync(
swap: swap,
currency: fa2,
txId: redeemTx.Id,
confirmationHandler: RedeemConfirmedEventHandler,
cancellationToken: cancellationToken)
.FireAndForget();
}
