chore: update swap order and cleanup

Author: rafaelbelchiorbd

README.md

@@ -26,8 +26,8 @@ This is a Typescript project. Npm as package manager and node. Tested with npm v
 7. Run the scripts with `npm exec ts-node src/main/scripts/SCRIPT.ts`, where `SCRIPT` can be:
 
 * `do-swap` (performs a cross-chain token transfer from Optimism to Polygon based on the first received route)
-* `do-swap-aptos-evm` (performs a cross-chain token transfer from Aptos (WETH) to Optimism ETH)
-* `do-swap-evm-aptos` (performs a cross-chain token transfer from Optimism (ETH) to Aptos (WETH))
+* `do-swap-non-evm-to-evm` (performs a cross-chain token transfer from Aptos (WETH) to Optimism ETH)
+* `do-swap-evm-to-non-evm` (performs a cross-chain token transfer from Optimism (ETH) to Aptos (WETH))
 * `get-approvals` (gets the status of an approval)
 * `get-chains` (gets the list of supported chains)
 * `get-routes` (gets a set of routes that satisfy a swap)

src/main/endpoints/routes.ts

@@ -4,30 +4,30 @@ import type {
   RoutesResponse,
   Route,
 } from "@blockdaemon/blockdaemon-defi-api-typescript-fetch";
-import {aptosProvider, isAptosTransaction, log} from "../utils/common";
-import {Account, MoveStructId} from "@aptos-labs/ts-sdk";
+import { aptosProvider, isAptosTransaction, log } from "../utils/common";
+import { Account, MoveStructId } from "@aptos-labs/ts-sdk";
 
 const logger = log.getLogger("routes-endpoint");
 
 function chooseBestRoute(routes: Route[], preferredIntegrator: string): Route {
   const topThree = [...routes]
-      .sort((a, b) => Number(b.to.amount) - Number(a.to.amount))
-      .slice(0, 3);
+    .sort((a, b) => Number(b.to.amount) - Number(a.to.amount))
+    .slice(0, 3);
 
   const chosen = topThree.filter(
-      (r) => r.steps?.[0].integrationDetails?.key === preferredIntegrator,
+    (r) => r.steps?.[0].integrationDetails?.key === preferredIntegrator,
   );
 
   return chosen[0];
 }
 
 export async function getRoutes(
-    exchangeAPI: ExchangeApi,
-    routeParameters: GetRoutesRequest,
-    preferredIntegrator: string = "",
+  exchangeAPI: ExchangeApi,
+  routeParameters: GetRoutesRequest,
+  preferredIntegrator: string = "",
 ): Promise<Route> {
   const routesResponse: RoutesResponse =
-      await exchangeAPI.getRoutes(routeParameters);
+    await exchangeAPI.getRoutes(routeParameters);
   logger.info("Got valid routes");
   if (!routesResponse.routes || routesResponse.routes.length === 0) {
     throw new Error("No valid routes returned.");
@@ -37,26 +37,26 @@ export async function getRoutes(
     return routesResponse.routes[0];
   }
   const selectedRoute: Route = chooseBestRoute(
-      routesResponse.routes,
-      preferredIntegrator,
+    routesResponse.routes,
+    preferredIntegrator,
   );
   logger.debug("Selected route:", JSON.stringify(selectedRoute, null, 2));
   logger.info(`Selected best route using ${preferredIntegrator}`);
   return selectedRoute;
 }
 
 export async function executeSwap(
-    selectedRoute: Route,
-    wallet: { address: string; privateKey: string },
-    rpcUrl: string,
+  selectedRoute: Route,
+  wallet: { address: string; privateKey: string },
+  rpcUrl: string,
 ): Promise<{ hash: string }> {
   const { signAndBroadcastTransaction } = await import("./wallet");
   logger.info("Executing swap transaction...");
   const { transactionRequest } = selectedRoute;
   const broadcastResult = await signAndBroadcastTransaction(
-      transactionRequest,
-      wallet.privateKey,
-      rpcUrl,
+    transactionRequest,
+    wallet.privateKey,
+    rpcUrl,
   );
   if (!broadcastResult?.hash) {
     throw new Error("Failed to broadcast swap transaction");
@@ -66,16 +66,19 @@ export async function executeSwap(
 }
 
 export async function executeSwapAptos(
-    selectedRoute: Route,
-    aptosAccount: Account,
+  selectedRoute: Route,
+  aptosAccount: Account,
 ): Promise<{ hash: string }> {
   logger.info("Executing Aptos swap transaction...");
 
   const { transactionRequest } = selectedRoute;
 
   try {
     if (!isAptosTransaction(transactionRequest)) {
-      throw new Error('Expected Aptos transaction but received: ' + transactionRequest.chainType);
+      throw new Error(
+        "Expected Aptos transaction but received: " +
+          transactionRequest.chainType,
+      );
     }
 
     const rawTxData = transactionRequest as any;
@@ -84,7 +87,7 @@ export async function executeSwapAptos(
       sender: rawTxData.sender,
       function: rawTxData.payload.function,
       typeArgs: rawTxData.payload.type_arguments,
-      args: rawTxData.payload.arguments
+      args: rawTxData.payload.arguments,
     });
 
     // Format the arguments properly
@@ -94,7 +97,7 @@ export async function executeSwapAptos(
         return new Uint8Array(arg);
       }
       // If argument is a hex string (starting with 0x), convert to bytes
-      if (typeof arg === 'string' && arg.startsWith('0x')) {
+      if (typeof arg === "string" && arg.startsWith("0x")) {
         // Remove '0x' prefix and convert to Uint8Array
         const hexString = arg.slice(2);
         const bytes = new Uint8Array(hexString.length / 2);
@@ -104,11 +107,11 @@ export async function executeSwapAptos(
         return bytes;
       }
       // For boolean values
-      if (typeof arg === 'boolean') {
+      if (typeof arg === "boolean") {
         return arg;
       }
       // For numeric values
-      if (typeof arg === 'number' || !isNaN(Number(arg))) {
+      if (typeof arg === "number" || !isNaN(Number(arg))) {
         return Number(arg);
       }
       return arg;
@@ -120,13 +123,13 @@ export async function executeSwapAptos(
       data: {
         function: rawTxData.payload.function as MoveStructId,
         typeArguments: rawTxData.payload.type_arguments,
-        functionArguments: formattedArguments
+        functionArguments: formattedArguments,
       },
       options: {
         maxGasAmount: Number(rawTxData.max_gas_amount),
         gasUnitPrice: Number(rawTxData.gas_unit_price),
-        expireTimestamp: Number(rawTxData.expiration_timestamp_secs)
-      }
+        expireTimestamp: Number(rawTxData.expiration_timestamp_secs),
+      },
     });
 
     // Sign and submit the transaction
@@ -139,12 +142,16 @@ export async function executeSwapAptos(
       throw new Error("No transaction hash returned from submission");
     }
 
-    const txHash = committedTxn.hash.startsWith('0x') ? committedTxn.hash : `0x${committedTxn.hash}`;
-    logger.info(`Aptos swap transaction submitted successfully. Tx Hash: ${txHash}`);
+    const txHash = committedTxn.hash.startsWith("0x")
+      ? committedTxn.hash
+      : `0x${committedTxn.hash}`;
+    logger.info(
+      `Aptos swap transaction submitted successfully. Tx Hash: ${txHash}`,
+    );
 
     // Wait for transaction to be confirmed
     await aptosProvider.waitForTransaction({
-      transactionHash: txHash
+      transactionHash: txHash,
     });
 
     logger.info(`Transaction executed and committed: ${txHash}`);
@@ -153,4 +160,4 @@ export async function executeSwapAptos(
     logger.error("Failed to execute Aptos transaction:", error);
     throw new Error(`Aptos transaction execution failed: ${error}`);
   }
-}
+}

src/main/endpoints/status.ts

@@ -3,7 +3,7 @@ import {
   type ExchangeApi,
   StatusEnum,
 } from "@blockdaemon/blockdaemon-defi-api-typescript-fetch";
-import { handleApiError, isSdkErrorResponse } from "../utils/error";
+import { handleApiError } from "../utils/error";
 import { log } from "../utils/common";
 
 const scriptName = "utils-status";
@@ -12,8 +12,8 @@ const logger = log.getLogger(scriptName);
 const WAIT_TIME = 10000; // 10 seconds
 const MAX_RETRIES = 30;
 export async function checkTransactionStatus(
-    exchangeAPI: ExchangeApi,
-    request: GetStatusRequest,
+  exchangeAPI: ExchangeApi,
+  request: GetStatusRequest,
 ): Promise<void> {
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     try {
@@ -30,13 +30,13 @@ export async function checkTransactionStatus(
       logger.info(`Current approval status: ${approvalStatus.status}`);
       if (attempt < MAX_RETRIES - 1) {
         logger.debug(
-            `Waiting for ${WAIT_TIME / 1000} seconds before retry ${attempt + 1} of ${MAX_RETRIES}`,
+          `Waiting for ${WAIT_TIME / 1000} seconds before retry ${attempt + 1} of ${MAX_RETRIES}`,
         );
         await delay(WAIT_TIME);
       }
     } catch (error) {
       logger.warn(
-          `Failure at ${scriptName} - Attempt ${attempt + 1} of ${MAX_RETRIES}. Retrying...`,
+        `Failure at ${scriptName} - Attempt ${attempt + 1} of ${MAX_RETRIES}. Retrying...`,
       );
       if (attempt < MAX_RETRIES - 1) {
         await delay(WAIT_TIME);
@@ -46,10 +46,10 @@ export async function checkTransactionStatus(
     }
   }
   throw new Error(
-      `Transaction status not completed after ${MAX_RETRIES} attempts`,
+    `Transaction status not completed after ${MAX_RETRIES} attempts`,
   );
 }
 
 function delay(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

src/main/endpoints/wallet.ts

@@ -5,17 +5,22 @@ import {
   parseUnits,
 } from "ethers";
 import { log } from "../utils/common";
-import type { TransactionRequest, EvmTransactionRequest } from "@blockdaemon/blockdaemon-defi-api-typescript-fetch";
+import type {
+  TransactionRequest,
+  EvmTransactionRequest,
+} from "@blockdaemon/blockdaemon-defi-api-typescript-fetch";
 
 const logger = log.getLogger("wallet");
 
-function isEvmTransaction(tx: TransactionRequest): tx is (EvmTransactionRequest & { chainType: 'evm' }) {
-  return tx.chainType === 'evm';
+function isEvmTransaction(
+  tx: TransactionRequest,
+): tx is EvmTransactionRequest & { chainType: "evm" } {
+  return tx.chainType === "evm";
 }
 
 function removeEIPPrefix(chainId: string): number {
-  if (chainId.startsWith('eip155:')) {
-    return parseInt(chainId.split(':')[1]);
+  if (chainId.startsWith("eip155:")) {
+    return parseInt(chainId.split(":")[1]);
   }
   return parseInt(chainId);
 }
@@ -26,7 +31,7 @@ export async function signAndBroadcastTransaction(
   rpcUrl: string,
 ): Promise<TransactionResponse> {
   if (!isEvmTransaction(transactionRequest)) {
-    throw new Error('Only EVM transactions are supported');
+    throw new Error("Only EVM transactions are supported");
   }
 
   const chainId = removeEIPPrefix(transactionRequest.chainID);
@@ -49,7 +54,7 @@ export async function signAndBroadcastTransaction(
 
   try {
     logger.info(
-      `Signing and Broadcasting EVM transaction on chain ${chainId} from ${txObject.from} to ${txObject.to} with value ${txObject.value}...`,
+      `Signing and Broadcasting EVM transaction on chain ${chainId} from ${txObject.from} to ${txObject.to} with field value ${txObject.value}...`,
     );
     const receipt = await wallet.sendTransaction(txObject);