@rango-dev/queue-manager-rango-preset 0.62.1-next.4 → 0.63.0

package/src/actions/executeHyperliquidTransaction/executeHyperliquidTransaction.ts

@@ -0,0 +1,167 @@
+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',
+      })
+    );
+    return;
+  }
+
+  onSuccessfulFinish();
+}

package/src/actions/executeHyperliquidTransaction/index.ts

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

package/src/actions/executeHyperliquidTransaction/types.ts

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

package/src/actions/executeHyperliquidTransaction/utils.ts

@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+import type { EthersV6CompatibleTypedData } from './types';
+import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
+import type { HyperliquidTransaction, Transaction } from 'rango-sdk';
+import type { Result } from 'ts-results';
+
+import { mainAPI } from 'rango-types';
+import { Err, Ok } from 'ts-results';
+
+import { HYPERLIQUID_EXCHANGE_API_URL } from './constants';
+
+export function ensureHyperliquidTransactionIsValid(
+  tx: Transaction | null
+): Result<HyperliquidTransaction, NextTransactionStateError> {
+  if (!tx) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Unexpected Error: tx is null!',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  if (!mainAPI.isHyperliquidTransaction(tx)) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message:
+        "Unexpected Error: Expected Hyperliquid transaction but it doesn't match with the structure.",
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  if (tx.action.type !== 'withdraw3' && tx.action.type !== 'usdSend') {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Unexpected Error: Transaction action is not supported.',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  if (!tx.message) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Unexpected Error: Transaction message does not exist.',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  return Ok(tx);
+}
+
+export function getEthersV6CompatibleTypedDataFromMessage(
+  message: string
+): Result<EthersV6CompatibleTypedData, NextTransactionStateError> {
+  try {
+    const typedData = JSON.parse(message);
+    const ethersV6CompatibleTypedData = {
+      domain: typedData.domain,
+      types: {
+        [typedData.primaryType]: typedData.types[typedData.primaryType],
+      },
+      value: typedData.message,
+    };
+    return Ok(ethersV6CompatibleTypedData);
+  } catch {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Unexpected Error: Could not infer typed data from message.',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+}
+
+export async function initiateWithdrawalRequest(
+  action: HyperliquidTransaction['action'],
+  signature: Signature,
+  nonce: HyperliquidTransaction['nonce']
+): Promise<Result<{ status: string }, NextTransactionStateError>> {
+  try {
+    const initiateWithdrawalResponse = await fetch(
+      HYPERLIQUID_EXCHANGE_API_URL,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          action,
+          signature,
+          nonce,
+        }),
+      }
+    );
+
+    const initiateWithdrawalResponseJson =
+      await initiateWithdrawalResponse.json();
+
+    return Ok(initiateWithdrawalResponseJson);
+  } catch {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Unexpected Error: Failed to initiate withdrawal.',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+}
+
+interface Signature {
+  /** First 32-byte component of ECDSA signature. */
+  r: string;
+  /** Second 32-byte component of ECDSA signature. */
+  s: string;
+  /** Recovery identifier. */
+  v: 27 | 28;
+}
+export function splitSignature( // validate and decode a 65-byte 0x… signature into { r, s, v } with v normalized to 27/28 for the Hyperliquid withdrawal request
+  signature: `0x${string}`
+): Result<Signature, NextTransactionStateError> {
+  if (signature.length !== 132) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: `Expected 65-byte signature (132 hex chars), got ${signature.length}`,
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+  const r = `0x${signature.slice(2, 66)}`;
+  const s = `0x${signature.slice(66, 130)}`;
+  let v = parseInt(signature.slice(130, 132), 16);
+  if (v === 0 || v === 1) {
+    v += 27;
+  }
+  if (v !== 27 && v !== 28) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: `Invalid signature recovery value: ${v}, expected 27 or 28`,
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+  return Ok({ r, s, v });
+}

package/src/helpers.ts

@@ -49,6 +49,7 @@ import { legacyReadAccountAddress as readAccountAddress } from '@rango-dev/walle
 import {
   getBlockChainNameFromId,
   getEvmProvider,
+  HYPERLIQUID_SIGN_NETWORK,
 } from '@rango-dev/wallets-shared';
 import BigNumber from 'bignumber.js';
 import {
@@ -178,6 +179,7 @@ export const getCurrentStepTx = (
     tonTransaction,
     suiTransaction,
     xrplTransaction,
+    hyperliquidTransaction,
   } = currentStep;
   return (
     evmTransaction ||
@@ -191,7 +193,8 @@ export const getCurrentStepTx = (
     tronTransaction ||
     tonTransaction ||
     suiTransaction ||
-    xrplTransaction
+    xrplTransaction ||
+    hyperliquidTransaction
   );
 };
 
@@ -217,6 +220,7 @@ export const setCurrentStepTx = (
   currentStep.suiTransaction = null;
   currentStep.xrplTransaction = null;
   currentStep.stellarTransaction = null;
+  currentStep.hyperliquidTransaction = null;
 
   const txType = transaction.type;
   switch (txType) {
@@ -713,6 +717,24 @@ export async function getProviderChainId(
  * For running a swap safely, we need to make sure about the state of wallet
  * which means the netowrk/chain of wallet should be exactly on what a transaction needs.
  */
+/**
+ * The EVM chain a wallet must be actively connected to in order to sign the current step.
+ *
+ * For Hyperliquid the wallet is stored under the "HYPERLIQUID" key, but the action is an
+ * EIP-712 message signed with the Arbitrum domain chainId. Many wallets reject
+ * `eth_signTypedData_v4` unless their active chain matches that chainId, so the wallet
+ * must actually be on Arbitrum (HYPERLIQUID_SIGN_NETWORK) before signing — even though
+ * the step's network/storage key is "HYPERLIQUID".
+ */
+export function getRequiredSignNetwork(
+  step: PendingSwapStep,
+  fallbackNetwork: string
+): string {
+  return step.hyperliquidTransaction
+    ? HYPERLIQUID_SIGN_NETWORK
+    : fallbackNetwork;
+}
+
 export async function isNetworkMatchedForTransaction(
   swap: PendingSwap,
   step: PendingSwapStep,
@@ -729,13 +751,17 @@ export async function isNetworkMatchedForTransaction(
     return false;
   }
 
+  // The EVM chain the wallet must actually be on to sign (Arbitrum for Hyperliquid).
+  const requiredNetwork = getRequiredSignNetwork(step, fromNamespace.network);
+
   if (
     meta.evmBasedChains.find(
-      (evmBlochain) => evmBlochain.name === fromNamespace.network
+      (evmBlochain) => evmBlochain.name === requiredNetwork
     )
   ) {
     try {
-      const sourceWallet = swap.wallets[fromNamespace.network];
+      // Resolve via the step-aware key so the Hyperliquid wallet (keyed "HYPERLIQUID") is found.
+      const sourceWallet = getRelatedWalletOrNull(swap, step);
       if (sourceWallet) {
         const chainId = await getProviderChainId(
           providers,
@@ -751,13 +777,13 @@ export async function isNetworkMatchedForTransaction(
           );
           if (
             blockChain &&
-            blockChain.toLowerCase() === fromNamespace.network.toLowerCase()
+            blockChain.toLowerCase() === requiredNetwork.toLowerCase()
           ) {
             return true;
           }
           if (
             blockChain &&
-            blockChain.toLowerCase() !== fromNamespace.network.toLowerCase()
+            blockChain.toLowerCase() !== requiredNetwork.toLowerCase()
           ) {
             return false;
           }
@@ -787,6 +813,7 @@ export const isTxAlreadyCreated = (
     swap.wallets[step.suiTransaction?.blockChain || ''] ||
     swap.wallets[step.stellarTransaction?.blockChain || ''] ||
     swap.wallets[step.xrplTransaction?.blockChain || ''] ||
+    swap.wallets[step.hyperliquidTransaction?.type || ''] ||
     step.transferTransaction?.fromWalletAddress ||
     null;
 
@@ -913,10 +940,14 @@ export function onBlockForChangeNetwork(
     setStorage: queue.setStorage.bind(queue),
   });
 
-  const requiredNetwork = getCurrentNamespaceOfOrNull(
+  const namespaceNetwork = getCurrentNamespaceOfOrNull(
     swap,
     currentStep
   )?.network;
+  // For Hyperliquid the wallet must be switched to Arbitrum, not "HYPERLIQUID".
+  const requiredNetwork = currentStep.hyperliquidTransaction
+    ? HYPERLIQUID_SIGN_NETWORK
+    : namespaceNetwork;
 
   const requiredWallet = getRequiredWallet(swap).type;
 
@@ -939,9 +970,20 @@ export function onBlockForChangeNetwork(
 
   // Try to auto switch
   const { type, namespace } = getRequiredWallet(swap);
-  if (!!type && !!namespace?.network) {
-    if (context.canSwitchNetworkTo(type, namespace.network, namespace)) {
-      const result = context.switchNetwork(type, namespace);
+  /*
+   * For Hyperliquid we must switch the wallet to the signing chain (Arbitrum) rather than
+   * the step's "HYPERLIQUID" network, otherwise the wallet rejects signing the
+   * Arbitrum-domain EIP-712 message ("chainId should be same as current chainId").
+   */
+  const switchNamespace =
+    currentStep.hyperliquidTransaction && namespace
+      ? { ...namespace, network: HYPERLIQUID_SIGN_NETWORK }
+      : namespace;
+  if (!!type && !!switchNamespace?.network) {
+    if (
+      context.canSwitchNetworkTo(type, switchNamespace.network, switchNamespace)
+    ) {
+      const result = context.switchNetwork(type, switchNamespace);
       if (result) {
         result
           .then(() => {

package/src/queueDef.ts

@@ -1,11 +1,13 @@
 import type { SwapQueueDef } from './types';
 
+import { checkHyperliquidTransactionStatus } from './actions/checkHyperliquidTransactionStatus';
 import { checkPrerequisites } from './actions/checkPrerequisites';
 import { checkStatus } from './actions/checkStatus';
 import { checkStellarTrustline } from './actions/checkStellarTrustline';
 import { checkXrplTrustline } from './actions/checkXrplTrustline';
 import { checkXrplTrustLineTransactionStatus } from './actions/checkXrplTrustlineTransactionStatus';
 import { createTransaction } from './actions/createTransaction';
+import { executeHyperliquidTransaction } from './actions/executeHyperliquidTransaction';
 import { executeStellarTransaction } from './actions/executeStellarTransaction';
 import { executeTransaction } from './actions/executeTransaction';
 import { executeXrplTransaction } from './actions/executeXrplTransaction';
@@ -39,6 +41,10 @@ export const swapQueueDef: SwapQueueDef = {
     [SwapActionTypes.EXECUTE_TRANSACTION]: executeTransaction,
     [SwapActionTypes.EXECUTE_XRPL_TRANSACTION]: executeXrplTransaction,
     [SwapActionTypes.EXECUTE_STELLAR_TRANSACTION]: executeStellarTransaction,
+    [SwapActionTypes.EXECUTE_HYPERLIQUID_TRANSACTION]:
+      executeHyperliquidTransaction,
+    [SwapActionTypes.CHECK_HYPERLIQUID_TRANSACTION_STATUS]:
+      checkHyperliquidTransactionStatus,
     [SwapActionTypes.CHECK_TRANSACTION_STATUS]: checkStatus,
   },
   run: [SwapActionTypes.START],

package/src/shared.ts

@@ -1,4 +1,3 @@
-import type { NamespaceInputForConnect } from '@rango-dev/wallets-core/dist/legacy/types';
 import type { Network, WalletType } from '@rango-dev/wallets-shared';
 import type {
   BlockchainMeta,
@@ -15,6 +14,7 @@ import type {
   WalletTypeAndAddress,
 } from 'rango-types';
 
+import { type NamespaceInputForConnect } from '@rango-dev/wallets-core/dist/legacy/types';
 import BigNumber from 'bignumber.js';
 
 import { numberToString } from './numbers';
@@ -119,6 +119,7 @@ export const getCurrentNamespaceOf = (
   const suiNetwork = step.suiTransaction?.blockChain;
   const xrplNetwork = step.xrplTransaction?.blockChain;
   const stellarNetwork = step.stellarTransaction?.blockChain;
+  const hyperliquidNetwork = step.hyperliquidTransaction?.blockChain;
 
   if (evmNetwork) {
     return {
@@ -160,6 +161,11 @@ export const getCurrentNamespaceOf = (
       namespace: 'Stellar',
       network: stellarNetwork,
     };
+  } else if (hyperliquidNetwork) {
+    return {
+      namespace: 'EVM',
+      network: hyperliquidNetwork,
+    };
   } else if (!!step.transferTransaction) {
     const transferAddress = step.transferTransaction.fromWalletAddress;
     if (!transferAddress) {
@@ -239,6 +245,7 @@ export const getCurrentWalletTypeAndAddress = (
     swap.wallets[step.suiTransaction?.blockChain || ''] ||
     swap.wallets[step.xrplTransaction?.blockChain || ''] ||
     swap.wallets[step.stellarTransaction?.blockChain || ''] ||
+    swap.wallets[step.hyperliquidTransaction?.type || ''] ||
     (step.transferTransaction?.fromWalletAddress
       ? {
           address: step.transferTransaction.fromWalletAddress,

package/src/types.ts

@@ -52,7 +52,9 @@ export enum SwapActionTypes {
   EXECUTE_TRANSACTION = 'EXECUTE_TRANSACTION',
   EXECUTE_XRPL_TRANSACTION = 'EXECUTE_XRPL_TRANSACTION',
   EXECUTE_STELLAR_TRANSACTION = 'EXECUTE_STELLAR_TRANSACTION',
+  EXECUTE_HYPERLIQUID_TRANSACTION = 'EXECUTE_HYPERLIQUID_TRANSACTION',
 
+  CHECK_HYPERLIQUID_TRANSACTION_STATUS = 'CHECK_HYPERLIQUID_TRANSACTION_STATUS',
   CHECK_TRANSACTION_STATUS = 'CHECK_TRANSACTION_STATUS',
 }