Feat/add support for hyperliquid transactions

queue-manager/queue-manager-demo/package.json

@@ -16,7 +16,7 @@
   },
   "devDependencies": {
     "process": "^0.11.10",
-    "rango-sdk": "^0.1.74"
+    "rango-sdk": "^0.1.76"
   },
   "dependencies": {
     "@rango-dev/provider-all": "^0.60.1-next.4",
@@ -27,7 +27,7 @@
     "@rango-dev/wallets-shared": "^0.58.1-next.2",
     "bignumber.js": "^9.1.1",
     "ethers": "^6.13.2",
-    "rango-sdk-basic": "^0.1.74",
-    "rango-types": "^0.1.95"
+    "rango-sdk-basic": "^0.1.76",
+    "rango-types": "^0.1.97"
   }
 }

queue-manager/rango-preset/package.json

@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@rango-dev/logging-core": "^0.12.1",
-    "rango-types": "^0.1.95",
+    "rango-types": "^0.1.97",
     "ts-results": "^3.3.0",
     "uuid": "^9.0.0"
   },

queue-manager/rango-preset/src/actions/checkHyperliquidTransactionStatus/checkHyperliquidTransactionStatus.ts

@@ -0,0 +1,94 @@
+import type {
+  SwapActionTypes,
+  SwapQueueContext,
+  SwapStorage,
+} from '../../types';
+import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
+import type { ExecuterActions } from '@rango-dev/queue-manager-core';
+import type { Err } from 'ts-results';
+
+import { warn } from '@rango-dev/logging-core';
+
+import {
+  delay,
+  getCurrentStep,
+  getCurrentStepTx,
+  handleSuccessfulSign,
+} from '../../helpers';
+import { getCurrentAddressOf } from '../../shared';
+import { onNextStateError } from '../common/produceNextStateForTransaction';
+import { ensureHyperliquidTransactionIsValid } from '../executeHyperliquidTransaction';
+
+import {
+  GetHyperliquidTransactionHashError,
+  INTERVAL_FOR_CHECK_HYPERLIQUID_TRANSACTION_STATUS,
+} from './constants';
+import { getHyperliquidTransactionHash } from './utils';
+
+export async function checkHyperliquidTransactionStatus(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Promise<void> {
+  const { failed, getStorage, retry } = actions;
+
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+
+  const onFinish = () => {
+    if (actions.context.resetClaimedBy) {
+      actions.context.resetClaimedBy();
+    }
+  };
+
+  const handleErr = (err: Err<NextTransactionStateError>) => {
+    onNextStateError(actions, err.val);
+    failed();
+    onFinish();
+  };
+
+  const currentTransactionFromStorage = getCurrentStepTx(currentStep);
+  const walletAddress = getCurrentAddressOf(swap, currentStep);
+
+  const hyperliquidTransactionResult = ensureHyperliquidTransactionIsValid(
+    currentTransactionFromStorage
+  );
+  if (hyperliquidTransactionResult.err) {
+    handleErr(hyperliquidTransactionResult);
+    return;
+  }
+
+  const hyperliquidTransaction = hyperliquidTransactionResult.val;
+  const nonce = hyperliquidTransaction.nonce;
+
+  const hyperliquidTransactionHash = await getHyperliquidTransactionHash(
+    walletAddress,
+    nonce
+  );
+
+  if (hyperliquidTransactionHash.err) {
+    if (
+      hyperliquidTransactionHash.val ===
+        GetHyperliquidTransactionHashError.FETCH_ERROR ||
+      hyperliquidTransactionHash.val ===
+        GetHyperliquidTransactionHashError.RESPONSE_PARSING_ERROR
+    ) {
+      warn(new Error('check Hyperliquid transaction status Error'), {
+        tags: {
+          type: 'request-error',
+          requestBody: { type: 'userDetails', user: walletAddress, nonce },
+          pendingSwap: swap,
+        },
+      });
+    }
+
+    await delay(INTERVAL_FOR_CHECK_HYPERLIQUID_TRANSACTION_STATUS);
+    retry();
+    return;
+  }
+
+  handleSuccessfulSign(actions, {
+    isApproval: false,
+  })({
+    hash: hyperliquidTransactionHash.val,
+  });
+  onFinish();
+}

queue-manager/rango-preset/src/actions/checkHyperliquidTransactionStatus/constants.ts

@@ -0,0 +1,10 @@
+export const HYPERLIQUID_EXPLORER_API_URL =
+  'https://rpc.hyperliquid.xyz/explorer';
+
+export const INTERVAL_FOR_CHECK_HYPERLIQUID_TRANSACTION_STATUS = 5_000;
+
+export enum GetHyperliquidTransactionHashError {
+  FETCH_ERROR = 'FETCH_ERROR',
+  RESPONSE_PARSING_ERROR = 'RESPONSE_PARSING_ERROR',
+  TRANSACTION_NOT_FOUND = 'TRANSACTION_NOT_FOUND',
+}

queue-manager/rango-preset/src/actions/checkHyperliquidTransactionStatus/index.ts

@@ -0,0 +1 @@
+export { checkHyperliquidTransactionStatus } from './checkHyperliquidTransactionStatus.js';

queue-manager/rango-preset/src/actions/checkHyperliquidTransactionStatus/types.ts

@@ -0,0 +1,20 @@
+export type UserDetailsItem = {
+  time: number;
+  user: string;
+  action: {
+    type: string;
+    signatureChainId: `0x${string}`;
+    hyperliquidChain: 'Mainnet';
+    destination: string;
+    amount: string;
+    time: number;
+  };
+  block: number;
+  hash: string;
+  error: null;
+};
+
+export type UserDetailsResponse = {
+  type: 'userDetails';
+  txs: UserDetailsItem[];
+};

queue-manager/rango-preset/src/actions/checkHyperliquidTransactionStatus/utils.ts

@@ -0,0 +1,50 @@
+import type { UserDetailsResponse } from './types';
+import type { Result } from 'ts-results';
+
+import { Err, Ok } from 'ts-results';
+
+import {
+  GetHyperliquidTransactionHashError,
+  HYPERLIQUID_EXPLORER_API_URL,
+} from './constants';
+
+export async function getHyperliquidTransactionHash(
+  walletAddress: string,
+  nonce: number
+): Promise<Result<string, GetHyperliquidTransactionHashError>> {
+  let userDetailsResponse: Response;
+  try {
+    userDetailsResponse = await fetch(HYPERLIQUID_EXPLORER_API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ type: 'userDetails', user: walletAddress }),
+    });
+  } catch {
+    return new Err(GetHyperliquidTransactionHashError.FETCH_ERROR);
+  }
+
+  let userDetailsJson: UserDetailsResponse;
+  try {
+    userDetailsJson = await userDetailsResponse.json();
+
+    if (!Array.isArray(userDetailsJson.txs)) {
+      return new Err(GetHyperliquidTransactionHashError.RESPONSE_PARSING_ERROR);
+    }
+  } catch {
+    return new Err(GetHyperliquidTransactionHashError.RESPONSE_PARSING_ERROR);
+  }
+
+  const currentUserDetailsItem = userDetailsJson.txs.find(
+    (item) =>
+      (item.action.type === 'withdraw3' || item.action.type === 'usdSend') &&
+      item.action.time === nonce
+  );
+
+  if (!currentUserDetailsItem) {
+    return new Err(GetHyperliquidTransactionHashError.TRANSACTION_NOT_FOUND);
+  }
+
+  return Ok(currentUserDetailsItem.hash);
+}

queue-manager/rango-preset/src/actions/executeHyperliquidTransaction/constants.ts

@@ -0,0 +1,2 @@
+export const HYPERLIQUID_EXCHANGE_API_URL =
+  'https://api.hyperliquid.xyz/exchange';

queue-manager/rango-preset/src/actions/executeHyperliquidTransaction/executeHyperliquidTransaction.ts

@@ -0,0 +1,166 @@
+import type { SwapQueueContext, SwapStorage } from '../../types';
+import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
+import type { ExecuterActions } from '@rango-dev/queue-manager-core';
+import type { EvmTransaction } from 'rango-sdk';
+
+import { type GenericSigner, TransactionType } from 'rango-types';
+import { Err } from 'ts-results';
+
+import {
+  getCurrentStep,
+  getCurrentStepTx,
+  handleRejectedSign,
+} from '../../helpers';
+import { getCurrentAddressOf, getRelatedWallet } from '../../shared';
+import { SwapActionTypes } from '../../types';
+import { checkEnvironmentBeforeExecuteTransaction } from '../common/checkEnvironmentBeforeExecuteTransaction';
+import {
+  onNextStateError,
+  onNextStateOk,
+  produceNextStateForTransaction,
+} from '../common/produceNextStateForTransaction';
+import { requestBlockQueue } from '../common/utils';
+
+import {
+  ensureHyperliquidTransactionIsValid,
+  getEthersV6CompatibleTypedDataFromMessage,
+  initiateWithdrawalRequest,
+  splitSignature,
+} from './utils';
+
+export async function executeHyperliquidTransaction(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Promise<void> {
+  const checkResult = await checkEnvironmentBeforeExecuteTransaction(actions);
+  if (checkResult.err) {
+    requestBlockQueue(actions, checkResult.val);
+    return;
+  }
+
+  const { failed, getStorage, context, schedule, next } = actions;
+  const { getSigners } = context;
+
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+
+  const onFinish = () => {
+    if (actions.context.resetClaimedBy) {
+      actions.context.resetClaimedBy();
+    }
+  };
+
+  const onSuccessfulFinish = () => {
+    schedule(SwapActionTypes.CHECK_HYPERLIQUID_TRANSACTION_STATUS);
+    next();
+    onFinish();
+  };
+
+  const handleErr = (err: Err<NextTransactionStateError>) => {
+    onNextStateError(actions, err.val);
+    failed();
+    onFinish();
+  };
+
+  /*
+   * Checking the current transaction state to determine the next step.
+   * It will either be Err, indicating process should stop, or Ok, indicating process should continu.
+   */
+  const nextStateResult = produceNextStateForTransaction(actions);
+
+  if (nextStateResult.err) {
+    handleErr(nextStateResult);
+    return;
+  }
+
+  // On sucess, we should update Swap object and also call notifier
+  onNextStateOk(actions, nextStateResult.val);
+
+  // when we are producing next step, it will check to tx shouldn't be null. So ! here is safe.
+  const currentTransactionFromStorage = getCurrentStepTx(currentStep)!;
+  const hyperliquidTransactionResult = ensureHyperliquidTransactionIsValid(
+    currentTransactionFromStorage
+  );
+  if (hyperliquidTransactionResult.err) {
+    handleErr(hyperliquidTransactionResult);
+    return;
+  }
+  const hyperliquidTransaction = hyperliquidTransactionResult.val;
+
+  const sourceWallet = getRelatedWallet(swap, currentStep);
+  const walletAddress = getCurrentAddressOf(swap, currentStep);
+
+  let signer: GenericSigner<EvmTransaction>;
+  try {
+    const walletSigners = await getSigners(sourceWallet.walletType);
+    signer = walletSigners.getSigner(TransactionType.EVM); // We need EVM signer for Hyperliquid transactions
+  } catch (error) {
+    handleRejectedSign(actions)(error);
+    onFinish();
+    return;
+  }
+
+  if (!signer?.signTypedData) {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: 'Unexpected Error: Signer does not support signTypedData.',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
+    return;
+  }
+
+  const typedData = getEthersV6CompatibleTypedDataFromMessage(
+    hyperliquidTransaction.message
+  );
+  if (typedData.err) {
+    handleErr(typedData);
+    return;
+  }
+
+  let signature: `0x${string}`;
+  try {
+    signature = (await signer.signTypedData(
+      typedData.val,
+      walletAddress,
+      hyperliquidTransaction.action.signatureChainId
+    )) as `0x${string}`;
+  } catch (error) {
+    handleRejectedSign(actions)(error);
+    onFinish();
+    return;
+  }
+
+  const splitSignatureResult = splitSignature(signature);
+  if (splitSignatureResult.err) {
+    handleErr(splitSignatureResult);
+    return;
+  }
+  const splittedSignature = splitSignatureResult.val;
+
+  const initiateWithdrawalResponse = await initiateWithdrawalRequest(
+    hyperliquidTransaction.action,
+    splittedSignature,
+    hyperliquidTransaction.nonce
+  );
+  if (initiateWithdrawalResponse.err) {
+    handleErr(initiateWithdrawalResponse);
+    return;
+  }
+
+  if (initiateWithdrawalResponse.val.status !== 'ok') {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: 'Unexpected Error: Failed to initiate withdrawal.',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
+  }
+
+  onSuccessfulFinish();
+}

queue-manager/rango-preset/src/actions/executeHyperliquidTransaction/index.ts

@@ -0,0 +1,2 @@
+export { executeHyperliquidTransaction } from './executeHyperliquidTransaction.js';
+export { ensureHyperliquidTransactionIsValid } from './utils.js';

queue-manager/rango-preset/src/actions/executeHyperliquidTransaction/types.ts

@@ -0,0 +1,5 @@
+export type EthersV6CompatibleTypedData = {
+  domain: unknown;
+  types: Record<string, unknown>;
+  value: Record<string, unknown>;
+};