fix(api): throw if recipient or app fee recipient not initialized on HyperCore (#1865)

Author: dohaki

api/_bridges/hypercore/strategy.ts

@@ -15,6 +15,7 @@ import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "../../_constants";
 import { InvalidParamError } from "../../_errors";
 import { encodeTransferCalldata } from "../../_multicall-handler";
 import { tagIntegratorId, tagSwapApiMarker } from "../../_integrator-id";
+import { accountExistsOnHyperCore } from "../../_hypercore";
 
 const supportedTokens = [TOKEN_SYMBOLS_MAP["USDT-SPOT"]];
 
@@ -198,6 +199,16 @@ export function getHyperCoreBridgeStrategy(): BridgeStrategy {
         });
       }
 
+      const depositorExists = await accountExistsOnHyperCore({
+        account: crossSwap.depositor,
+      });
+
+      if (!depositorExists) {
+        throw new InvalidParamError({
+          message: "Depositor is not initialized on HyperCore",
+        });
+      }
+
       const data = encodeTransferCalldata(
         crossSwap.outputToken.address, // System address on HyperCore
         bridgeQuote.inputAmount // in HyperEVM decimals

api/_dexes/cross-swap-service.ts

@@ -46,6 +46,9 @@ import {
 } from "./types";
 import { BridgeStrategy } from "../_bridges/types";
 import { getSpokePoolPeripheryAddress } from "../_spoke-pool-periphery";
+import { accountExistsOnHyperCore } from "../_hypercore";
+import { CHAIN_IDs } from "../_constants";
+import { BigNumber } from "ethers";
 
 const QUOTE_BUFFER = 0.005; // 0.5%
 
@@ -247,6 +250,33 @@ export async function getCrossSwapQuotesForExactInputB2BI(
     indirectDestinationRoute.intermediaryOutputToken.decimals
   )(crossSwap.amount);
 
+  // If destination chain is HyperCore, we need to check if the app fee recipient and recipient
+  // have initialized balances on HyperCore.
+  if (crossSwap.outputToken.chainId === CHAIN_IDs.HYPERCORE) {
+    const [appFeeRecipientExists, recipientExists] = await Promise.all([
+      crossSwap.appFeeRecipient
+        ? accountExistsOnHyperCore({
+            account: crossSwap.appFeeRecipient,
+          })
+        : BigNumber.from(0),
+      accountExistsOnHyperCore({
+        account: crossSwap.recipient,
+      }),
+    ]);
+
+    if (crossSwap.appFeeRecipient && !appFeeRecipientExists) {
+      throw new InvalidParamError({
+        message: "App fee recipient is not initialized on HyperCore",
+      });
+    }
+
+    if (!recipientExists) {
+      throw new InvalidParamError({
+        message: "Recipient is not initialized on HyperCore",
+      });
+    }
+  }
+
   // 1. We fetch a quote from inputToken.chainId -> intermediaryOutputToken.chainId
   const { bridgeQuote } = await bridge.getQuoteForExactInput({
     inputToken: crossSwap.inputToken,

api/_hypercore.ts

@@ -7,6 +7,10 @@ import { CHAIN_IDs } from "./_constants";
 export const CORE_BALANCE_SYSTEM_PRECOMPILE =
   "0x0000000000000000000000000000000000000801";
 
+// Contract used to check if an account exists on Hypercore.
+export const CORE_USER_EXISTS_PRECOMPILE_ADDRESS =
+  "0x0000000000000000000000000000000000000810";
+
 // CoreWriter contract on EVM that can be used to interact with Hypercore.
 export const CORE_WRITER_EVM_ADDRESS =
   "0x3333333333333333333333333333333333333333";
@@ -67,7 +71,7 @@ export async function getBalanceOnHyperCore(params: {
   account: string;
   tokenSystemAddress: string;
 }) {
-  const provider = getProvider(CHAIN_IDs.HYPERCORE);
+  const provider = getProvider(CHAIN_IDs.HYPEREVM);
   const tokenIndex = parseInt(
     params.tokenSystemAddress.replace("0x20", ""),
     16
@@ -86,3 +90,20 @@ export async function getBalanceOnHyperCore(params: {
   );
   return BigNumber.from(decodedQueryResult[0].toString());
 }
+
+export async function accountExistsOnHyperCore(params: { account: string }) {
+  const provider = getProvider(CHAIN_IDs.HYPEREVM);
+  const balanceCoreCalldata = ethers.utils.defaultAbiCoder.encode(
+    ["address"],
+    [params.account]
+  );
+  const queryResult = await provider.call({
+    to: CORE_USER_EXISTS_PRECOMPILE_ADDRESS,
+    data: balanceCoreCalldata,
+  });
+  const decodedQueryResult = ethers.utils.defaultAbiCoder.decode(
+    ["bool"],
+    queryResult
+  );
+  return Boolean(decodedQueryResult[0]);
+}