Feat: Extend Evm Vault swaps functionality

bouncer/package.json

@@ -30,6 +30,7 @@
     "md5": "^2.3.0",
     "minimist": "^1.2.8",
     "rxjs": "^7.8.1",
+    "scale-ts": "1.6.0",
     "tiny-secp256k1": "^2.2.1",
     "toml": "^3.0.0",
     "web3": "^1.9.0",

bouncer/shared/contract_swap.ts

@@ -5,64 +5,135 @@ import {
   approveVault,
   Asset as SCAsset,
   Chains,
-  InternalAsset,
   Chain,
 } from '@chainflip/cli';
-import { HDNodeWallet, Wallet, getDefaultProvider } from 'ethers';
+import { u32, Struct, Option, u16, u256, Bytes as TsBytes, Enum } from 'scale-ts';
+import { u8aToHex, hexToU8a } from '@polkadot/util';
+import { HDNodeWallet, Wallet } from 'ethers';
 import {
   observeBalanceIncrease,
   getContractAddress,
   observeCcmReceived,
   amountToFineAmount,
   defaultAssetAmounts,
   chainFromAsset,
-  getEvmEndpoint,
   assetDecimals,
   stateChainAssetFromAsset,
-  chainGasAsset,
+  shortChainFromAsset,
+  createEvmWalletAndFund,
 } from './utils';
 import { getBalance } from './get_balance';
-import { CcmDepositMetadata } from '../shared/new_swap';
-import { send } from './send';
+import { CcmDepositMetadata, DcaParams, FillOrKillParamsX128 } from '../shared/new_swap';
 import { SwapContext, SwapStatus } from './swap_context';
 
 const erc20Assets: Asset[] = ['Flip', 'Usdc', 'Usdt', 'ArbUsdc'];
 
+export const vaultSwapCfParametersCodec = Struct({
+  ccmAdditionalData: Option(TsBytes()),
+  vaultSwapParameters: Option(
+    Struct({
+      refundParams: Option(
+        Struct({
+          retryDurationBlocks: u32,
+          refundAddress: Enum({
+            Eth: TsBytes(20),
+            Dot: TsBytes(32),
+            Btc: TsBytes(),
+            Arb: TsBytes(20),
+            Sol: TsBytes(32),
+          }),
+          minPriceX128: u256,
+        }),
+      ),
+      dcaParams: Option(Struct({ numberOfChunks: u32, chunkIntervalBlocks: u32 })),
+      boostFee: Option(u16),
+    }),
+  ),
+});
+
+export function encodeCfParameters(
+  sourceAsset: Asset,
+  ccmAdditionalData?: string | undefined,
+  boostFeeBps?: number,
+  fillOrKillParams?: FillOrKillParamsX128,
+  dcaParams?: DcaParams,
+): string | undefined {
+  return ccmAdditionalData || fillOrKillParams || dcaParams || boostFeeBps
+    ? u8aToHex(
+        vaultSwapCfParametersCodec.enc({
+          ccmAdditionalData: ccmAdditionalData ? hexToU8a(ccmAdditionalData) : undefined,
+          vaultSwapParameters:
+            fillOrKillParams || dcaParams || boostFeeBps
+              ? {
+                  refundParams: fillOrKillParams && {
+                    retryDurationBlocks: fillOrKillParams.retryDurationBlocks,
+                    refundAddress: {
+                      tag: shortChainFromAsset(sourceAsset),
+                      value: hexToU8a(fillOrKillParams.refundAddress),
+                    },
+                    minPriceX128: BigInt(fillOrKillParams.minPriceX128),
+                  },
+                  dcaParams,
+                  boostFee: boostFeeBps,
+                }
+              : undefined,
+        }),
+      )
+    : undefined;
+}
+
 export async function executeContractSwap(
-  srcAsset: Asset,
+  sourceAsset: Asset,
   destAsset: Asset,
   destAddress: string,
   wallet: HDNodeWallet,
   messageMetadata?: CcmDepositMetadata,
+  amount?: string,
+  boostFeeBps?: number,
+  fillOrKillParams?: FillOrKillParamsX128,
+  dcaParams?: DcaParams,
 ): ReturnType<typeof executeSwap> {
-  const srcChain = chainFromAsset(srcAsset);
+  const srcChain = chainFromAsset(sourceAsset);
   const destChain = chainFromAsset(destAsset);
+  const amountToSwap = amount ?? defaultAssetAmounts(sourceAsset);
 
   const networkOptions = {
     signer: wallet,
     network: 'localnet',
     vaultContractAddress: getContractAddress(srcChain, 'VAULT'),
-    srcTokenContractAddress: getContractAddress(srcChain, srcAsset),
+    srcTokenContractAddress: getContractAddress(srcChain, sourceAsset),
   } as const;
   const txOptions = {
     // This is run with fresh addresses to prevent nonce issues. Will be 1 for ERC20s.
     gasLimit: srcChain === Chains.Arbitrum ? 10000000n : 200000n,
   } as const;
 
+  const cfParameters = encodeCfParameters(
+    sourceAsset,
+    messageMetadata?.cfParameters,
+    boostFeeBps,
+    fillOrKillParams,
+    dcaParams,
+  );
+
   const receipt = await executeSwap(
     {
       destChain,
       destAsset: stateChainAssetFromAsset(destAsset),
       // It is important that this is large enough to result in
       // an amount larger than existential (e.g. on Polkadot):
-      amount: amountToFineAmount(defaultAssetAmounts(srcAsset), assetDecimals(srcAsset)),
+      amount: amountToFineAmount(amountToSwap, assetDecimals(sourceAsset)),
       destAddress,
-      srcAsset: stateChainAssetFromAsset(srcAsset),
+      srcAsset: stateChainAssetFromAsset(sourceAsset),
       srcChain,
+      // TODO: This will need some refactoring either putting the cfParameters outside the
+      // ccmParams and the user should encode it as done here or, probably better, we just
+      // add the SwapParameters support (Fok/Dca/Boost) as separate parameters, rename
+      // cfParameters to ccmAdditionalData and do the encoding within the SDK.
       ccmParams: messageMetadata && {
         gasBudget: messageMetadata.gasBudget.toString(),
         message: messageMetadata.message,
-        cfParameters: messageMetadata.cfParameters,
+        cfParameters,
       },
     } as ExecuteSwapParams,
     networkOptions,
@@ -86,33 +157,29 @@ export async function performSwapViaContract(
   messageMetadata?: CcmDepositMetadata,
   swapContext?: SwapContext,
   log = true,
+  amount?: string,
+  boostFeeBps?: number,
+  fillOrKillParams?: FillOrKillParamsX128,
+  dcaParams?: DcaParams,
 ): Promise<ContractSwapParams> {
   const tag = swapTag ?? '';
-
-  const srcChain = chainFromAsset(sourceAsset);
+  const amountToSwap = amount ?? defaultAssetAmounts(sourceAsset);
 
   // Generate a new wallet for each contract swap to prevent nonce issues when running in parallel
   // with other swaps via deposit channels.
   const mnemonic = Wallet.createRandom().mnemonic?.phrase ?? '';
   if (mnemonic === '') {
     throw new Error('Failed to create random mnemonic');
   }
-  const wallet = Wallet.fromPhrase(mnemonic).connect(getDefaultProvider(getEvmEndpoint(srcChain)));
+  const wallet = await createEvmWalletAndFund(sourceAsset);
 
   try {
-    // Fund new key with native asset and asset to swap.
-    await send(chainGasAsset(srcChain) as InternalAsset, wallet.address);
-    await send(sourceAsset, wallet.address);
-
     if (erc20Assets.includes(sourceAsset)) {
       // Doing effectively infinite approvals to make sure it doesn't fail.
       // eslint-disable-next-line @typescript-eslint/no-use-before-define
       await approveTokenVault(
         sourceAsset,
-        (
-          BigInt(amountToFineAmount(defaultAssetAmounts(sourceAsset), assetDecimals(sourceAsset))) *
-          100n
-        ).toString(),
+        (BigInt(amountToFineAmount(amountToSwap, assetDecimals(sourceAsset))) * 100n).toString(),
         wallet,
       );
     }
@@ -135,6 +202,10 @@ export async function performSwapViaContract(
       destAddress,
       wallet,
       messageMetadata,
+      amountToSwap,
+      boostFeeBps,
+      fillOrKillParams,
+      dcaParams,
     );
     swapContext?.updateStatus(swapTag, SwapStatus.ContractExecuted);
 
@@ -171,24 +242,24 @@ export async function performSwapViaContract(
     throw new Error(`${tag} ${err}`);
   }
 }
-export async function approveTokenVault(srcAsset: Asset, amount: string, wallet: HDNodeWallet) {
-  if (!erc20Assets.includes(srcAsset)) {
-    throw new Error(`Unsupported asset, not an ERC20: ${srcAsset}`);
+export async function approveTokenVault(sourceAsset: Asset, amount: string, wallet: HDNodeWallet) {
+  if (!erc20Assets.includes(sourceAsset)) {
+    throw new Error(`Unsupported asset, not an ERC20: ${sourceAsset}`);
   }
 
-  const chain = chainFromAsset(srcAsset as Asset);
+  const chain = chainFromAsset(sourceAsset as Asset);
 
   await approveVault(
     {
       amount,
       srcChain: chain as Chain,
-      srcAsset: stateChainAssetFromAsset(srcAsset) as SCAsset,
+      srcAsset: stateChainAssetFromAsset(sourceAsset) as SCAsset,
     },
     {
       signer: wallet,
       network: 'localnet',
       vaultContractAddress: getContractAddress(chain, 'VAULT'),
-      srcTokenContractAddress: getContractAddress(chain, srcAsset),
+      srcTokenContractAddress: getContractAddress(chain, sourceAsset),
     },
     // This is run with fresh addresses to prevent nonce issues
     {

bouncer/shared/send.ts

@@ -20,9 +20,7 @@ import { sendSolUsdc } from './send_solusdc';
 const cfTesterAbi = await getCFTesterAbi();
 
 export async function send(asset: Asset, address: string, amount?: string, log = true) {
-  // TODO: Remove this any when we have Sol assets in the Asset type.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  switch (asset as any) {
+  switch (asset) {
     case 'Btc':
       await sendBtc(address, amount ?? defaultAssetAmounts(asset));
       break;

bouncer/shared/swapping.ts

@@ -67,7 +67,7 @@ function newAbiEncodedMessage(types?: SolidityType[]): string {
   return web3.eth.abi.encodeParameters(typesArray, variables);
 }
 
-function newSolanaCfParameters(maxAccounts: number) {
+function newSolanaCcmAdditionalData(maxAccounts: number) {
   function arrayToHexString(byteArray: Uint8Array): string {
     return (
       '0x' +
@@ -123,7 +123,7 @@ function newCcmArbitraryBytes(maxLength: number): string {
   return randomAsHex(Math.floor(Math.random() * Math.max(0, maxLength - 10)) + 10);
 }
 
-function newCfParameters(destAsset: Asset, message?: string): string {
+function newCcmAdditionalData(destAsset: Asset, message?: string): string {
   const destChain = chainFromAsset(destAsset);
   switch (destChain) {
     case 'Ethereum':
@@ -139,7 +139,7 @@ function newCfParameters(destAsset: Asset, message?: string): string {
 
       // The maximum number of extra accounts that can be passed is limited by the tx size
       // and therefore also depends on the message length.
-      return newSolanaCfParameters(maxAccounts);
+      return newSolanaCcmAdditionalData(maxAccounts);
     }
     default:
       throw new Error(`Unsupported chain: ${destChain}`);
@@ -167,7 +167,7 @@ export function newCcmMetadata(
   cfParamsArray?: string,
 ): CcmDepositMetadata {
   const message = ccmMessage ?? newCcmMessage(destAsset);
-  const cfParameters = cfParamsArray ?? newCfParameters(destAsset, message);
+  const ccmAdditionalData = cfParamsArray ?? newCcmAdditionalData(destAsset, message);
   const gasDiv = gasBudgetFraction ?? 2;
 
   const gasBudget = Math.floor(
@@ -178,7 +178,8 @@ export function newCcmMetadata(
   return {
     message,
     gasBudget,
-    cfParameters,
+    // TODO: To rename to ccmAdditionalData
+    cfParameters: ccmAdditionalData,
   };
 }
 

bouncer/shared/utils.ts

@@ -1,5 +1,6 @@
 import { execSync } from 'child_process';
 import * as crypto from 'crypto';
+import { HDNodeWallet, Wallet, getDefaultProvider } from 'ethers';
 import { setTimeout as sleep } from 'timers/promises';
 import Client from 'bitcoin-core';
 import { ApiPromise, Keyring } from '@polkadot/api';
@@ -30,6 +31,7 @@ import { SwapParams } from './perform_swap';
 import { newSolAddress } from './new_sol_address';
 import { getChainflipApi, observeBadEvent, observeEvent } from './utils/substrate';
 import { execWithLog } from './utils/exec_with_log';
+import { send } from './send';
 
 const cfTesterAbi = await getCFTesterAbi();
 const cfTesterIdl = await getCfTesterIdl();
@@ -472,17 +474,20 @@ function checkRequestTypeMatches(actual: object | string, expected: SwapRequestT
 export async function observeSwapRequested(
   sourceAsset: Asset,
   destAsset: Asset,
-  channelId: number,
+  id: number | string,
   swapRequestType: SwapRequestType,
 ) {
   // need to await this to prevent the chainflip api from being disposed prematurely
   return observeEvent('swapping:SwapRequested', {
     test: (event) => {
       const data = event.data;
 
-      if (typeof data.origin === 'object' && 'DepositChannel' in data.origin) {
+      if (typeof data.origin === 'object') {
         const channelMatches =
-          Number(data.origin.DepositChannel.channelId.replaceAll(',', '')) === channelId;
+          (typeof id === 'number' &&
+            'DepositChannel' in data.origin &&
+            Number(data.origin.DepositChannel.channelId.replaceAll(',', '')) === id) ||
+          (typeof id === 'string' && 'Vault' in data.origin && data.origin.Vault.txHash === id);
         const sourceAssetMatches = sourceAsset === (data.inputAsset as Asset);
         const destAssetMatches = destAsset === (data.outputAsset as Asset);
         const requestTypeMatches = checkRequestTypeMatches(data.requestType, swapRequestType);
@@ -1164,3 +1169,16 @@ export function getTimeStamp(): string {
   const seconds = now.getSeconds().toString().padStart(2, '0');
   return `${hours}:${minutes}:${seconds}`;
 }
+
+export async function createEvmWalletAndFund(asset: Asset): Promise<HDNodeWallet> {
+  const chain = chainFromAsset(asset);
+
+  const mnemonic = Wallet.createRandom().mnemonic?.phrase ?? '';
+  if (mnemonic === '') {
+    throw new Error('Failed to create random mnemonic');
+  }
+  const wallet = Wallet.fromPhrase(mnemonic).connect(getDefaultProvider(getEvmEndpoint(chain)));
+  await send(chainGasAsset(chain) as SDKAsset, wallet.address);
+  await send(asset, wallet.address);
+  return wallet;
+}