chore: rename contract swaps -> vault swaps (#5357)

* chore: rename contract swaps -> vault swaps

* chore: bump dca test timeout

api/lib/src/lib.rs

@@ -4,7 +4,7 @@ use anyhow::{anyhow, bail, Context, Result};
 use async_trait::async_trait;
 use cf_chains::{
 	address::{try_from_encoded_address, EncodedAddress},
-	btc::smart_contract_encoding::{
+	btc::vault_swap_encoding::{
 		encode_swap_params_in_nulldata_utxo, SharedCfParameters, UtxoEncodedData,
 	},
 	dot::PolkadotAccountId,

bouncer/shared/swapping.ts

@@ -16,7 +16,7 @@ import {
 } from '../shared/utils';
 import { BtcAddressType } from '../shared/new_btc_address';
 import { CcmDepositMetadata } from '../shared/new_swap';
-import { performSwapViaContract } from '../shared/contract_swap';
+import { performVaultSwap } from '../shared/vault_swap';
 import { SwapContext, SwapStatus } from './swap_context';
 
 enum SolidityType {
@@ -236,7 +236,7 @@ export async function testSwap(
     swapContext,
   );
 }
-export async function testSwapViaContract(
+export async function testVaultSwap(
   sourceAsset: Asset,
   destAsset: Asset,
   addressType?: BtcAddressType,
@@ -250,12 +250,12 @@ export async function testSwapViaContract(
     destAsset,
     addressType,
     messageMetadata,
-    (tagSuffix ?? '') + ' Contract',
+    (tagSuffix ?? '') + ' Vault',
     log,
     swapContext,
   );
 
-  return performSwapViaContract(
+  return performVaultSwap(
     sourceAsset,
     destAsset,
     destAddress,

bouncer/shared/contract_swap.ts → bouncer/shared/vault_swap.ts

@@ -28,7 +28,7 @@ import { SwapContext, SwapStatus } from './swap_context';
 
 const erc20Assets: Asset[] = ['Flip', 'Usdc', 'Usdt', 'ArbUsdc'];
 
-export async function executeContractSwap(
+export async function executeVaultSwap(
   srcAsset: Asset,
   destAsset: Asset,
   destAddress: string,
@@ -71,27 +71,27 @@ export async function executeContractSwap(
 
   return receipt;
 }
-export type ContractSwapParams = {
+export type VaultSwapParams = {
   sourceAsset: Asset;
   destAsset: Asset;
   destAddress: string;
   txHash: string;
 };
 
-export async function performSwapViaContract(
+export async function performVaultSwap(
   sourceAsset: Asset,
   destAsset: Asset,
   destAddress: string,
   swapTag = '',
   messageMetadata?: CcmDepositMetadata,
   swapContext?: SwapContext,
   log = true,
-): Promise<ContractSwapParams> {
+): Promise<VaultSwapParams> {
   const tag = swapTag ?? '';
 
   const srcChain = chainFromAsset(sourceAsset);
 
-  // Generate a new wallet for each contract swap to prevent nonce issues when running in parallel
+  // Generate a new wallet for each vault swap to prevent nonce issues when running in parallel
   // with other swaps via deposit channels.
   const mnemonic = Wallet.createRandom().mnemonic?.phrase ?? '';
   if (mnemonic === '') {
@@ -122,14 +122,14 @@ export async function performSwapViaContract(
     if (log) {
       console.log(`${tag} Old balance: ${oldBalance}`);
       console.log(
-        `${tag} Executing (${sourceAsset}) contract swap to(${destAsset}) ${destAddress}. Current balance: ${oldBalance}`,
+        `${tag} Executing (${sourceAsset}) vault swap to(${destAsset}) ${destAddress}. Current balance: ${oldBalance}`,
       );
     }
 
-    // To uniquely identify the contractSwap, we need to use the TX hash. This is only known
+    // To uniquely identify the VaultSwap, we need to use the TX hash. This is only known
     // after sending the transaction, so we send it first and observe the events afterwards.
     // There are still multiple blocks of safety margin inbetween before the event is emitted
-    const receipt = await executeContractSwap(
+    const receipt = await executeVaultSwap(
       sourceAsset,
       destAsset,
       destAddress,

bouncer/tests/DCA_test.ts

@@ -15,7 +15,7 @@ import { requestNewSwap } from '../shared/perform_swap';
 import { DcaParams } from '../shared/new_swap';
 
 /* eslint-disable @typescript-eslint/no-use-before-define */
-export const testDCASwaps = new ExecutableTest('DCA-Swaps', main, 150);
+export const testDCASwaps = new ExecutableTest('DCA-Swaps', main, 250);
 
 // Requested number of blocks between each chunk
 const CHUNK_INTERVAL = 2;

bouncer/tests/all_swaps.ts

@@ -1,21 +1,21 @@
 import { InternalAsset as Asset, InternalAssets as Assets } from '@chainflip/cli';
-import { ContractSwapParams } from '../shared/contract_swap';
+import { VaultSwapParams } from '../shared/vault_swap';
 import { ExecutableTest } from '../shared/executable_test';
 import { SwapParams } from '../shared/perform_swap';
-import { newCcmMetadata, testSwap, testSwapViaContract } from '../shared/swapping';
+import { newCcmMetadata, testSwap, testVaultSwap } from '../shared/swapping';
 import { btcAddressTypes } from '../shared/new_btc_address';
 import { ccmSupportedChains, chainFromAsset } from '../shared/utils';
 
 /* eslint-disable @typescript-eslint/no-use-before-define */
 export const testAllSwaps = new ExecutableTest('All-Swaps', main, 3000);
 
 async function main() {
-  const allSwaps: Promise<SwapParams | ContractSwapParams>[] = [];
+  const allSwaps: Promise<SwapParams | VaultSwapParams>[] = [];
 
   function appendSwap(
     sourceAsset: Asset,
     destAsset: Asset,
-    functionCall: typeof testSwap | typeof testSwapViaContract,
+    functionCall: typeof testSwap | typeof testVaultSwap,
     ccmSwap: boolean = false,
   ) {
     if (destAsset === 'Btc') {
@@ -52,12 +52,12 @@ async function main() {
         const sourceChain = chainFromAsset(sourceAsset);
         const destChain = chainFromAsset(destAsset);
         if (sourceChain === 'Ethereum' || sourceChain === 'Arbitrum') {
-          // Contract Swaps
-          appendSwap(sourceAsset, destAsset, testSwapViaContract);
+          // Vault Swaps
+          appendSwap(sourceAsset, destAsset, testVaultSwap);
 
           if (ccmSupportedChains.includes(destChain)) {
-            // CCM contract swaps
-            appendSwap(sourceAsset, destAsset, testSwapViaContract, true);
+            // CCM Vault swaps
+            appendSwap(sourceAsset, destAsset, testVaultSwap, true);
           }
         }
 

bouncer/tests/evm_deposits.ts

@@ -78,7 +78,7 @@ async function testNoDuplicateWitnessing(sourceAsset: Asset, destAsset: Asset) {
 }
 
 // Not supporting Btc to avoid adding more unnecessary complexity with address encoding.
-async function testTxMultipleContractSwaps(sourceAsset: Asset, destAsset: Asset) {
+async function testTxMultipleVaultSwaps(sourceAsset: Asset, destAsset: Asset) {
   const { destAddress, tag } = await prepareSwap(sourceAsset, destAsset);
 
   const web3 = new Web3(getEvmEndpoint(chainFromAsset(sourceAsset)));
@@ -194,10 +194,10 @@ async function main() {
   ]);
 
   const multipleTxSwapsTest = Promise.all([
-    testTxMultipleContractSwaps('Eth', 'Dot'),
-    testTxMultipleContractSwaps('Eth', 'Flip'),
-    testTxMultipleContractSwaps('ArbEth', 'Dot'),
-    testTxMultipleContractSwaps('ArbEth', 'Flip'),
+    testTxMultipleVaultSwaps('Eth', 'Dot'),
+    testTxMultipleVaultSwaps('Eth', 'Flip'),
+    testTxMultipleVaultSwaps('ArbEth', 'Dot'),
+    testTxMultipleVaultSwaps('ArbEth', 'Flip'),
   ]);
 
   const doubleDepositTests = Promise.all([

bouncer/tests/rotation_barrier.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S pnpm tsx
 import { submitGovernanceExtrinsic } from '../shared/cf_governance';
 import { ExecutableTest } from '../shared/executable_test';
-import { testSwapViaContract } from '../shared/swapping';
+import { testVaultSwap } from '../shared/swapping';
 import { observeEvent, observeBadEvent } from '../shared/utils/substrate';
 
 /* eslint-disable @typescript-eslint/no-use-before-define */
@@ -22,7 +22,7 @@ async function main() {
   const broadcastAborted = observeBadEvent(':BroadcastAborted', { label: 'Rotate and swap' });
 
   // Using Arbitrum as the ingress chain to make the swap as fast as possible
-  await testSwapViaContract('ArbEth', 'Eth');
+  await testVaultSwap('ArbEth', 'Eth');
 
   await broadcastAborted.stop();
 }

engine/src/witness/arb.rs

@@ -181,7 +181,7 @@ use cf_primitives::{Asset, AssetAmount, TransactionHash};
 impl super::evm::vault::IngressCallBuilder for ArbCallBuilder {
 	type Chain = Arbitrum;
 
-	fn contract_swap_request(
+	fn vault_swap_request(
 		source_asset: Asset,
 		deposit_amount: AssetAmount,
 		destination_asset: Asset,
@@ -190,7 +190,7 @@ impl super::evm::vault::IngressCallBuilder for ArbCallBuilder {
 		tx_hash: TransactionHash,
 	) -> state_chain_runtime::RuntimeCall {
 		state_chain_runtime::RuntimeCall::ArbitrumIngressEgress(
-			pallet_cf_ingress_egress::Call::contract_swap_request {
+			pallet_cf_ingress_egress::Call::vault_swap_request {
 				input_asset: source_asset.try_into().expect("invalid asset for chain"),
 				output_asset: destination_asset,
 				deposit_amount,

engine/src/witness/btc.rs

@@ -1,7 +1,7 @@
 mod chain_tracking;
 mod deposits;
-pub mod smart_contract;
 pub mod source;
+pub mod vault_swaps;
 
 use crate::{
 	btc::{

engine/src/witness/btc/deposits.rs

@@ -76,7 +76,7 @@ impl<Inner: ChunkedByVault> ChunkedByVaultBuilder<Inner> {
 				for vault_address in vault_addresses {
 					for tx in &txs {
 						if let Some(call) =
-							super::smart_contract::try_extract_contract_call(tx, &vault_address)
+							super::vault_swaps::try_extract_vault_swap_call(tx, &vault_address)
 						{
 							process_call(call.into(), epoch.index).await;
 						}

engine/src/witness/btc/smart_contract.rs → engine/src/witness/btc/vault_swaps.rs

@@ -3,8 +3,8 @@ use cf_amm::common::{bounded_sqrt_price, sqrt_price_to_price};
 use cf_chains::{
 	assets::btc::Asset as BtcAsset,
 	btc::{
-		deposit_address::DepositAddress, smart_contract_encoding::UtxoEncodedData,
-		BtcDepositDetails, ScriptPubkey, UtxoId,
+		deposit_address::DepositAddress, vault_swap_encoding::UtxoEncodedData, BtcDepositDetails,
+		ScriptPubkey, UtxoId,
 	},
 	ChannelRefundParameters, ForeignChainAddress,
 };
@@ -79,7 +79,7 @@ fn script_buf_to_script_pubkey(script: &ScriptBuf) -> Option<ScriptPubkey> {
 type BtcIngressEgressCall =
 	pallet_cf_ingress_egress::Call<state_chain_runtime::Runtime, BitcoinInstance>;
 
-pub fn try_extract_contract_call(
+pub fn try_extract_vault_swap_call(
 	tx: &VerboseTransaction,
 	vault_address: &DepositAddress,
 ) -> Option<BtcIngressEgressCall> {
@@ -128,7 +128,7 @@ pub fn try_extract_contract_call(
 
 	let tx_id: [u8; 32] = tx.txid.to_byte_array();
 
-	Some(BtcIngressEgressCall::contract_swap_request {
+	Some(BtcIngressEgressCall::vault_swap_request {
 		input_asset: NATIVE_ASSET,
 		output_asset: data.output_asset,
 		deposit_amount,
@@ -172,7 +172,7 @@ mod tests {
 
 	use super::*;
 
-	use cf_chains::btc::smart_contract_encoding::*;
+	use cf_chains::btc::vault_swap_encoding::*;
 
 	const MOCK_DOT_ADDRESS: [u8; 32] = [9u8; 32];
 
@@ -267,8 +267,8 @@ mod tests {
 		);
 
 		assert_eq!(
-			try_extract_contract_call(&tx, &vault_deposit_address),
-			Some(BtcIngressEgressCall::contract_swap_request {
+			try_extract_vault_swap_call(&tx, &vault_deposit_address),
+			Some(BtcIngressEgressCall::vault_swap_request {
 				input_asset: NATIVE_ASSET,
 				output_asset: MOCK_SWAP_PARAMS.output_asset,
 				deposit_amount: DEPOSIT_AMOUNT,

engine/src/witness/eth.rs

@@ -226,7 +226,7 @@ pub struct EthCallBuilder {}
 impl super::evm::vault::IngressCallBuilder for EthCallBuilder {
 	type Chain = Ethereum;
 
-	fn contract_swap_request(
+	fn vault_swap_request(
 		source_asset: Asset,
 		deposit_amount: AssetAmount,
 		destination_asset: Asset,
@@ -235,7 +235,7 @@ impl super::evm::vault::IngressCallBuilder for EthCallBuilder {
 		tx_hash: TransactionHash,
 	) -> state_chain_runtime::RuntimeCall {
 		state_chain_runtime::RuntimeCall::EthereumIngressEgress(
-			pallet_cf_ingress_egress::Call::contract_swap_request {
+			pallet_cf_ingress_egress::Call::vault_swap_request {
 				input_asset: source_asset.try_into().expect("invalid asset for chain"),
 				output_asset: destination_asset,
 				deposit_amount,

engine/src/witness/evm/vault.rs

@@ -64,7 +64,7 @@ where
 			amount,
 			sender: _,
 			cf_parameters: _,
-		}) => Some(CallBuilder::contract_swap_request(
+		}) => Some(CallBuilder::vault_swap_request(
 			native_asset,
 			try_into_primitive(amount)?,
 			try_into_primitive(dst_token)?,
@@ -80,7 +80,7 @@ where
 			amount,
 			sender: _,
 			cf_parameters: _,
-		}) => Some(CallBuilder::contract_swap_request(
+		}) => Some(CallBuilder::vault_swap_request(
 			*(supported_assets
 				.get(&src_token)
 				.ok_or(anyhow!("Source token {src_token:?} not found"))?),
@@ -100,7 +100,7 @@ where
 			gas_amount,
 			cf_parameters,
 		}) =>
-			Some(CallBuilder::contract_swap_request(
+			Some(CallBuilder::vault_swap_request(
 				native_asset,
 				try_into_primitive(amount)?,
 				try_into_primitive(dst_token)?,
@@ -136,7 +136,7 @@ where
 			gas_amount,
 			cf_parameters,
 		}) =>
-			Some(CallBuilder::contract_swap_request(
+			Some(CallBuilder::vault_swap_request(
 				*(supported_assets
 					.get(&src_token)
 					.ok_or(anyhow!("Source token {src_token:?} not found"))?),
@@ -197,7 +197,7 @@ where
 pub trait IngressCallBuilder {
 	type Chain: cf_chains::Chain<ChainAccount = EthereumAddress>;
 
-	fn contract_swap_request(
+	fn vault_swap_request(
 		source_asset: Asset,
 		deposit_amount: cf_primitives::AssetAmount,
 		destination_asset: Asset,

state-chain/cf-integration-tests/src/solana.rs

@@ -427,7 +427,7 @@ fn solana_ccm_fails_with_invalid_input() {
 
 			// Contract call fails with invalid CCM
 			assert_ok!(RuntimeCall::SolanaIngressEgress(
-				pallet_cf_ingress_egress::Call::contract_swap_request {
+				pallet_cf_ingress_egress::Call::vault_swap_request {
 					input_asset: SolAsset::Sol,
 					output_asset: Asset::SolUsdc,
 					deposit_amount: 1_000_000_000_000u64,
@@ -481,7 +481,7 @@ fn solana_ccm_fails_with_invalid_input() {
 			};
 
 			witness_call(RuntimeCall::SolanaIngressEgress(
-				pallet_cf_ingress_egress::Call::contract_swap_request {
+				pallet_cf_ingress_egress::Call::vault_swap_request {
 					input_asset: SolAsset::Sol,
 					output_asset: Asset::SolUsdc,
 					deposit_amount: 1_000_000_000_000u64,
@@ -705,7 +705,7 @@ fn solana_ccm_execution_error_can_trigger_fallback() {
 				},
 			};
 			witness_call(RuntimeCall::SolanaIngressEgress(
-				pallet_cf_ingress_egress::Call::contract_swap_request {
+				pallet_cf_ingress_egress::Call::vault_swap_request {
 					input_asset: SolAsset::Sol,
 					output_asset: Asset::SolUsdc,
 					deposit_amount: 1_000_000_000_000u64,

state-chain/cf-integration-tests/src/swapping.rs

@@ -572,7 +572,7 @@ fn can_process_ccm_via_direct_deposit() {
 		let deposit_amount = 100_000_000_000;
 
 		witness_call(RuntimeCall::EthereumIngressEgress(
-			pallet_cf_ingress_egress::Call::contract_swap_request {
+			pallet_cf_ingress_egress::Call::vault_swap_request {
 				input_asset: EthAsset::Flip,
 				output_asset: Asset::Usdc,
 				deposit_amount,
@@ -622,7 +622,7 @@ fn failed_swaps_are_rolled_back() {
 		let flip_pool = get_pool(Asset::Flip);
 
 		witness_call(RuntimeCall::EthereumIngressEgress(
-			pallet_cf_ingress_egress::Call::contract_swap_request {
+			pallet_cf_ingress_egress::Call::vault_swap_request {
 				input_asset: EthAsset::Eth,
 				output_asset: Asset::Flip,
 				deposit_amount: 10_000 * DECIMALS,
@@ -784,7 +784,7 @@ fn can_resign_failed_ccm() {
 			setup_pool_and_accounts(vec![Asset::Eth, Asset::Flip], OrderType::LimitOrder);
 
 			witness_call(RuntimeCall::EthereumIngressEgress(
-				pallet_cf_ingress_egress::Call::contract_swap_request {
+				pallet_cf_ingress_egress::Call::vault_swap_request {
 					input_asset: EthAsset::Flip,
 					output_asset: Asset::Usdc,
 					deposit_amount: 10_000_000_000_000,