feat: EVM chain swaps

lib/Core.ts

@@ -165,13 +165,12 @@ export const getOutputValue = (
 export const constructClaimDetails = (
   swapOutputType: SwapOutputType,
   wallet: Wallet,
-  swapType: SwapType,
   swap: Swap | ChainSwapData,
   transaction: Transaction | LiquidTransaction,
   preimage?: Buffer,
   cooperative: boolean = false,
 ): ClaimDetails | LiquidClaimDetails => {
-  const isSubmarine = swapType === SwapType.Submarine;
+  const isSubmarine = swap.type === SwapType.Submarine;
 
   let lockupVout = isSubmarine
     ? (swap as Swap).lockupTransactionVout

lib/cli/ethereum/EthereumUtils.ts

@@ -84,5 +84,5 @@ export const getLogsQueryStartHeight = async (
   delta: number,
 ): Promise<number> => {
   const blockHeight = await provider.getBlockNumber();
-  return blockHeight - delta;
+  return Math.max(blockHeight - delta, 0);
 };

lib/cli/ethereum/commands/Address.ts

@@ -0,0 +1,14 @@
+import { Arguments } from 'yargs';
+import { stringify } from '../../../Utils';
+import { connectEthereum } from '../EthereumUtils';
+
+export const command = 'address';
+
+export const describe = 'prints the address of the signer';
+
+export const builder = {};
+
+export const handler = async (argv: Arguments<any>): Promise<void> => {
+  const signer = await connectEthereum(argv.provider);
+  console.log(stringify({ address: await signer.getAddress() }));
+};

lib/db/models/ChainSwapData.ts

@@ -1,4 +1,5 @@
 import { DataTypes, Model, Sequelize } from 'sequelize';
+import { SwapType } from '../../consts/Enums';
 import ChainSwap from './ChainSwap';
 
 type ChainSwapDataType = {
@@ -97,9 +98,17 @@ class ChainSwapData extends Model implements ChainSwapDataType {
     });
   };
 
+  get type() {
+    return SwapType.Chain;
+  }
+
   get lockupTransactionId() {
     return this.transactionId;
   }
+
+  get redeemScript() {
+    return this.swapTree;
+  }
 }
 
 export default ChainSwapData;

lib/db/models/ReverseSwap.ts

@@ -213,6 +213,14 @@ class ReverseSwap extends Model implements ReverseSwapType {
   get type() {
     return SwapType.ReverseSubmarine;
   }
+
+  get theirPublicKey() {
+    return this.claimPublicKey;
+  }
+
+  get expectedAmount() {
+    return this.onchainAmount;
+  }
 }
 
 export default ReverseSwap;

lib/db/repositories/ChainSwapRepository.ts

@@ -4,7 +4,12 @@ import {
   getSendingReceivingCurrency,
   splitPairId,
 } from '../../Utils';
-import { SwapType, SwapUpdateEvent } from '../../consts/Enums';
+import {
+  NotPendingChainSwapEvents,
+  SwapType,
+  SwapUpdateEvent,
+  SwapVersion,
+} from '../../consts/Enums';
 import Database from '../Database';
 import ChainSwap, { ChainSwapType } from '../models/ChainSwap';
 import ChainSwapData, { ChainSwapDataType } from '../models/ChainSwapData';
@@ -20,6 +25,10 @@ class ChainSwapInfo {
     return SwapType.Chain;
   }
 
+  get version() {
+    return SwapVersion.Taproot;
+  }
+
   get id() {
     return this.chainSwap.id;
   }
@@ -28,6 +37,10 @@ class ChainSwapInfo {
     return this.chainSwap.status as SwapUpdateEvent;
   }
 
+  get failureReason() {
+    return this.chainSwap.failureReason;
+  }
+
   get isSettled() {
     return this.chainSwap.status === SwapUpdateEvent.TransactionClaimed;
   }
@@ -125,6 +138,29 @@ class ChainSwapRepository {
     return swaps.concat(await this.getChainSwaps(swapOptions));
   };
 
+  public static getChainSwapsExpirable = async (
+    symbols: string[],
+    blockHeight: number,
+  ) => {
+    const data = await ChainSwapData.findAll({
+      where: {
+        symbol: symbols,
+        timeoutBlockHeight: {
+          [Op.lte]: blockHeight,
+        },
+      },
+    });
+
+    const swaps = await this.getChainSwaps({
+      id: data.map((d) => d.swapId),
+      status: {
+        [Op.notIn]: NotPendingChainSwapEvents,
+      },
+    });
+
+    return swaps.filter((s) => symbols.includes(s.sendingData.symbol));
+  };
+
   public static addChainSwap = (args: {
     chainSwap: ChainSwapType;
     sendingData: ChainSwapDataType;
@@ -172,7 +208,7 @@ class ChainSwapRepository {
     transactionId: string,
     onchainAmount: number,
     fee: number,
-    vout: number,
+    vout?: number,
   ): Promise<ChainSwapInfo> =>
     Database.sequelize.transaction(async (transaction) => {
       swap.chainSwap = await swap.chainSwap.update(
@@ -224,14 +260,37 @@ class ChainSwapRepository {
       return swap;
     });
 
+  public static setTransactionRefunded = (
+    swap: ChainSwapInfo,
+    minerFee: number,
+    failureReason: string,
+  ): Promise<ChainSwapInfo> =>
+    Database.sequelize.transaction(async (transaction) => {
+      swap.chainSwap = await swap.chainSwap.update(
+        {
+          failureReason,
+          status: SwapUpdateEvent.TransactionRefunded,
+        },
+        { transaction },
+      );
+      swap.sendingData = await swap.receivingData.update(
+        {
+          fee: swap.sendingData.fee! + minerFee,
+        },
+        { transaction },
+      );
+
+      return swap;
+    });
+
   public static setSwapStatus = async (
     swap: ChainSwapInfo,
     status: SwapUpdateEvent,
     reason?: string,
   ) => {
     swap.chainSwap = await swap.chainSwap.update({
       status,
-      reason,
+      failureReason: reason,
     });
     return swap;
   };

lib/service/EventHandler.ts

@@ -234,17 +234,29 @@ class EventHandler extends TypedEventEmitter<{
       });
     });
 
-    this.nursery.on('expiration', ({ swap, isReverse }) => {
+    this.nursery.on('expiration', (swap) => {
       const newStatus = SwapUpdateEvent.SwapExpired;
 
-      if (isReverse) {
-        this.handleFailedReverseSwap(
-          swap as ReverseSwap,
-          newStatus,
-          swap.failureReason!,
-        );
-      } else {
-        this.handleFailedSwap(swap as Swap, newStatus, swap.failureReason!);
+      switch (swap.type) {
+        case SwapType.Submarine:
+          this.handleFailedSwap(swap as Swap, newStatus, swap.failureReason!);
+          break;
+
+        case SwapType.ReverseSubmarine:
+          this.handleFailedReverseSwap(
+            swap as ReverseSwap,
+            newStatus,
+            swap.failureReason!,
+          );
+          break;
+
+        case SwapType.Chain:
+          this.handleFailedChainSwap(
+            swap as ChainSwapInfo,
+            newStatus,
+            swap.failureReason!,
+          );
+          break;
       }
     });
 
@@ -286,8 +298,8 @@ class EventHandler extends TypedEventEmitter<{
       }
     });
 
-    this.nursery.on('coins.failedToSend', ({ type, swap }) => {
-      if (type === SwapType.ReverseSubmarine) {
+    this.nursery.on('coins.failedToSend', (swap) => {
+      if (swap.type === SwapType.ReverseSubmarine) {
         this.handleFailedReverseSwap(
           swap as ReverseSwap,
           SwapUpdateEvent.TransactionFailed,
@@ -302,12 +314,20 @@ class EventHandler extends TypedEventEmitter<{
       }
     });
 
-    this.nursery.on('refund', ({ reverseSwap }) => {
-      this.handleFailedReverseSwap(
-        reverseSwap,
-        SwapUpdateEvent.TransactionRefunded,
-        reverseSwap.failureReason!,
-      );
+    this.nursery.on('refund', ({ swap }) => {
+      if (swap.type === SwapType.ReverseSubmarine) {
+        this.handleFailedReverseSwap(
+          swap as ReverseSwap,
+          SwapUpdateEvent.TransactionRefunded,
+          swap.failureReason!,
+        );
+      } else {
+        this.handleFailedChainSwap(
+          swap as ChainSwapInfo,
+          SwapUpdateEvent.TransactionRefunded,
+          swap.failureReason!,
+        );
+      }
     });
 
     this.nursery.channelNursery.on(

lib/service/cooperative/CoopSignerBase.ts

@@ -125,7 +125,6 @@ abstract class CoopSignerBase<
     return constructClaimDetails(
       this.swapOutputType,
       wallet,
-      swap.type,
       details,
       tx,
       preimage,