@rango-dev/queue-manager-rango-preset 0.61.2-next.3 → 0.61.2-next.5

package/src/actions/checkXrplTrustlineTransactionStatus/checkXrplTrustlineTransactionStatus.ts

@@ -0,0 +1,145 @@
+import type { SwapQueueContext, SwapStorage } from '../../types';
+import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
+import type { ExecuterActions } from '@rango-dev/queue-manager-core';
+import type { TrustSet, TxResponse } from 'xrpl';
+
+import {
+  isXrplChangeTrustLinePrerequisiteResult,
+  XRPL_CHANGE_TRUSTLINE_TYPE,
+  type XrplChangeTrustLinePrerequisiteResult,
+} from 'rango-types';
+import { Err } from 'ts-results';
+import { Client } from 'xrpl';
+
+import {
+  delay,
+  getCurrentStep,
+  updateStorageWithPrerequisiteResult,
+} from '../../helpers';
+import { SwapActionTypes } from '../../types';
+import { onNextStateError } from '../common/produceNextStateForTransaction';
+
+import {
+  INTERVAL_FOR_CHECK_XRPL_TRUSTLINE_TRANSACTION_STATUS,
+  XRPL_PUBLIC_SERVER,
+} from './constants';
+
+export async function checkXrplTrustLineTransactionStatus(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Promise<void> {
+  const { failed, getStorage, retry, next, schedule } = actions;
+
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+
+  const onFinish = () => {
+    if (actions.context.resetClaimedBy) {
+      actions.context.resetClaimedBy();
+    }
+  };
+
+  const onSuccessfulFinish = () => {
+    schedule(SwapActionTypes.CHECK_PREREQUISITES);
+    next();
+    onFinish();
+  };
+
+  const handleErr = (err: Err<NextTransactionStateError>) => {
+    onNextStateError(actions, err.val);
+    failed();
+    onFinish();
+  };
+
+  const retryAfterDelay = async () => {
+    await delay(INTERVAL_FOR_CHECK_XRPL_TRUSTLINE_TRANSACTION_STATUS);
+    retry();
+  };
+
+  /*
+   *
+   * 1. Ensure a pending XRPL_CHANGE_TRUSTLINE prerequisite result is available.
+   *
+   */
+  let pendingXrplChangeTrustLinePrerequisiteResult: XrplChangeTrustLinePrerequisiteResult | null =
+    null;
+
+  for (const prerequisiteResult of currentStep.prerequisiteResults) {
+    if (
+      isXrplChangeTrustLinePrerequisiteResult(prerequisiteResult) &&
+      prerequisiteResult.status === 'pending'
+    ) {
+      pendingXrplChangeTrustLinePrerequisiteResult = prerequisiteResult;
+      break;
+    }
+  }
+
+  if (!pendingXrplChangeTrustLinePrerequisiteResult) {
+    onSuccessfulFinish();
+    return;
+  }
+
+  try {
+    const client = new Client(XRPL_PUBLIC_SERVER);
+    await client.connect();
+
+    const response: TxResponse<TrustSet> = await client.request({
+      command: 'tx',
+      transaction:
+        pendingXrplChangeTrustLinePrerequisiteResult.data
+          .executedTransactionHash,
+    });
+
+    if (!response.result.validated) {
+      // If data is not final, we need to retry
+      await retryAfterDelay();
+      return;
+    }
+
+    // If data is final, we can update the prerequisite status
+    if (
+      typeof response.result.meta !== 'string' && // `response.result.meta` should not be of type "string" because `binary` filed is not set in tx request
+      response.result.meta?.TransactionResult === 'tesSUCCESS' // https://xrpl.org/docs/references/protocol/transactions/transaction-results
+    ) {
+      const prerequisiteResult: XrplChangeTrustLinePrerequisiteResult = {
+        prerequisiteIndex:
+          pendingXrplChangeTrustLinePrerequisiteResult.prerequisiteIndex,
+        prerequisiteType: XRPL_CHANGE_TRUSTLINE_TYPE,
+        status: 'success',
+        data: {
+          executedTransactionHash:
+            pendingXrplChangeTrustLinePrerequisiteResult.data
+              .executedTransactionHash,
+        },
+      };
+
+      updateStorageWithPrerequisiteResult(actions, prerequisiteResult);
+      onSuccessfulFinish();
+    } else {
+      const prerequisiteResult: XrplChangeTrustLinePrerequisiteResult = {
+        prerequisiteIndex:
+          pendingXrplChangeTrustLinePrerequisiteResult.prerequisiteIndex,
+        prerequisiteType: XRPL_CHANGE_TRUSTLINE_TYPE,
+        status: 'failed',
+        data: {
+          executedTransactionHash:
+            pendingXrplChangeTrustLinePrerequisiteResult.data
+              .executedTransactionHash,
+        },
+      };
+
+      updateStorageWithPrerequisiteResult(actions, prerequisiteResult);
+      handleErr(
+        new Err({
+          nextStatus: 'failed',
+          nextStepStatus: 'failed',
+          message:
+            'Unexpected Error: xrpl change trustline transaction failed!',
+          details: undefined,
+          errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+        })
+      );
+    }
+  } catch {
+    await retryAfterDelay();
+  }
+}

package/src/actions/checkXrplTrustlineTransactionStatus/constants.ts

@@ -0,0 +1,2 @@
+export const INTERVAL_FOR_CHECK_XRPL_TRUSTLINE_TRANSACTION_STATUS = 5_000;
+export const XRPL_PUBLIC_SERVER = 'wss://xrplcluster.com/';

package/src/actions/checkXrplTrustlineTransactionStatus/index.ts

@@ -0,0 +1 @@
+export { checkXrplTrustLineTransactionStatus } from './checkXrplTrustlineTransactionStatus';

package/src/actions/executeStellarTransaction/executeStellarTransaction.ts

@@ -0,0 +1,168 @@
+import type {
+  SwapActionTypes,
+  SwapQueueContext,
+  SwapStorage,
+} from '../../types';
+import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
+import type { ExecuterActions } from '@rango-dev/queue-manager-core';
+
+import {
+  type GenericSigner,
+  type StellarTransaction,
+  TransactionType,
+} from 'rango-types';
+import { Err } from 'ts-results';
+
+import {
+  getCurrentStep,
+  getCurrentStepTx,
+  handleRejectedSign,
+  handleSuccessfulSign,
+} from '../../helpers';
+import { getCurrentAddressOf } from '../../shared';
+import {
+  ensureRequiredStellarWalletIsConnected,
+  ensureStellarNamespaceExists,
+  getStellarWalletFromSwap,
+} from '../checkStellarTrustline';
+import {
+  onNextStateError,
+  onNextStateOk,
+  produceNextStateForTransaction,
+} from '../common/produceNextStateForTransaction';
+import { requestBlockQueue } from '../common/utils';
+
+import { ensureStellarTransactionIsValid } from './helpers';
+
+export async function executeStellarTransaction(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Promise<void> {
+  const { failed, getStorage, context } = actions;
+  const { meta, getSigners } = context;
+
+  const onFinish = () => {
+    if (actions.context.resetClaimedBy) {
+      actions.context.resetClaimedBy();
+    }
+  };
+
+  const handleErr = (err: Err<NextTransactionStateError>) => {
+    onNextStateError(actions, err.val);
+    failed();
+    onFinish();
+  };
+
+  /*
+   *
+   * 1. Ensure transaction is available.
+   *
+   */
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+  const currentTransactionFromStorage = getCurrentStepTx(currentStep);
+
+  const transaction = await ensureStellarTransactionIsValid(
+    currentTransactionFromStorage
+  );
+  if (transaction.err) {
+    handleErr(transaction);
+    return;
+  }
+
+  /*
+   *
+   * 2. Ensure wallet is connected with a correct address.
+   *
+   */
+  const stellarWallet = getStellarWalletFromSwap(swap);
+  if (!stellarWallet) {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: 'Unexpected Error: Stellar wallet was not found in the swap!',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
+    return;
+  }
+
+  const namespace = await ensureStellarNamespaceExists(
+    context,
+    stellarWallet.type
+  );
+  if (namespace.err) {
+    handleErr(namespace);
+    return;
+  }
+
+  const ensureRequiredStellarWalletIsConnectedResult =
+    await ensureRequiredStellarWalletIsConnected(actions, stellarWallet);
+
+  if (ensureRequiredStellarWalletIsConnectedResult.err) {
+    requestBlockQueue(
+      actions,
+      ensureRequiredStellarWalletIsConnectedResult.val
+    );
+    return;
+  }
+
+  const walletAddress = getCurrentAddressOf(swap, currentStep);
+
+  /*
+   * Checking the current transaction state to determine the next step.
+   * It will either be Err, indicating process should stop, or Ok, indicating process should continue.
+   */
+  const nextStateResult = produceNextStateForTransaction(actions);
+
+  if (nextStateResult.err) {
+    handleErr(nextStateResult);
+    return;
+  }
+
+  // On success, we should update Swap object and also call notifier
+  onNextStateOk(actions, nextStateResult.val);
+
+  /*
+   *
+   * 3. Execute transaction
+   *
+   */
+  const chainId = meta.blockchains['Stellar']?.chainId;
+  let signer: GenericSigner<StellarTransaction>;
+
+  try {
+    const walletSigners = await getSigners(stellarWallet.type);
+    signer = walletSigners.getSigner(TransactionType.STELLAR);
+  } catch {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message:
+          'Unexpected Error: Failed to load the signer. Please refresh the page and try again.',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
+    return;
+  }
+
+  try {
+    const result = await signer.signAndSendTx(
+      transaction.val,
+      walletAddress,
+      chainId
+    );
+
+    handleSuccessfulSign(actions, {
+      isApproval: false,
+    })(result);
+  } catch (e) {
+    handleRejectedSign(actions)(e);
+  }
+
+  // this works as `finally` for the iterator.
+  onFinish();
+}

package/src/actions/executeStellarTransaction/helpers.ts

@@ -0,0 +1,43 @@
+import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
+import type { Transaction } from 'rango-sdk';
+import type { StellarTransaction } from 'rango-types';
+import type { Result } from 'ts-results';
+
+import { isStellarTransaction } from 'rango-types';
+import { Err, Ok } from 'ts-results';
+
+// Extracting currency and account from the following format (it's a convention on rango's backend): currency-accountAddress
+export function extractFromSymbolAddress(
+  symbolAddress: string
+): [string, string | undefined] {
+  const [currency, account] = symbolAddress.split('-');
+
+  return [currency, account];
+}
+
+export async function ensureStellarTransactionIsValid(
+  tx: Transaction | null
+): Promise<Result<StellarTransaction, NextTransactionStateError>> {
+  if (!tx) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Unexpected Error: tx is null!',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  if (!isStellarTransaction(tx)) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message:
+        "Unexpected Error: Expected Stellar transaction but it doesn't match with the structure.",
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  return Ok(tx);
+}

package/src/actions/executeStellarTransaction/index.ts

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

package/src/actions/executeXrplTransaction/executeXrplTransaction.ts

@@ -5,8 +5,13 @@ import type {
 } from '../../types';
 import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
 import type { ExecuterActions } from '@rango-dev/queue-manager-core';
-import type { GenericSigner, XrplTransaction } from 'rango-types';
-import type { Err } from 'ts-results';
+
+import {
+  type GenericSigner,
+  TransactionType,
+  type XrplTransaction,
+} from 'rango-types';
+import { Err } from 'ts-results';
 
 import {
   getCurrentStep,
@@ -14,12 +19,12 @@ import {
   handleRejectedSign,
   handleSuccessfulSign,
 } from '../../helpers';
-import { getCurrentAddressOf, getRelatedWallet } from '../../shared';
+import { getCurrentAddressOf } from '../../shared';
 import {
+  ensureRequiredXrplWalletIsConnected,
   ensureXrplNamespaceExists,
-  ensureXrplTransactionIsValid,
+  getXrplWalletFromSwap,
 } from '../checkXrplTrustline';
-import { checkEnvironmentBeforeExecuteTransaction } from '../common/checkEnvironmentBeforeExecuteTransaction';
 import {
   onNextStateError,
   onNextStateOk,
@@ -27,30 +32,14 @@ import {
 } from '../common/produceNextStateForTransaction';
 import { requestBlockQueue } from '../common/utils';
 
+import { ensureXrplTransactionIsValid } from './helpers';
+
 export async function executeXrplTransaction(
   actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
 ): Promise<void> {
-  /*
-   *
-   * 1. Ensure wallet is connected with a correct address.
-   *
-   */
-  const checkResult = await checkEnvironmentBeforeExecuteTransaction(actions);
-  if (checkResult.err) {
-    requestBlockQueue(actions, checkResult.val);
-    return;
-  }
-
   const { failed, getStorage, context } = actions;
   const { meta, getSigners } = context;
 
-  const swap = getStorage().swapDetails;
-  const currentStep = getCurrentStep(swap)!;
-  const currentTransactionFromStorage = getCurrentStepTx(currentStep);
-
-  const sourceWallet = getRelatedWallet(swap, currentStep);
-  const walletAddress = getCurrentAddressOf(swap, currentStep);
-
   const onFinish = () => {
     if (actions.context.resetClaimedBy) {
       actions.context.resetClaimedBy();
@@ -64,52 +53,95 @@ export async function executeXrplTransaction(
   };
 
   /*
-   * Checking the current transaction state to determine the next step.
-   * It will either be Err, indicating process should stop, or Ok, indicating process should continue.
+   *
+   * 1. Ensure transaction is available.
+   *
    */
-  const nextStateResult = produceNextStateForTransaction(actions);
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+  const currentTransactionFromStorage = getCurrentStepTx(currentStep);
 
-  if (nextStateResult.err) {
-    handleErr(nextStateResult);
+  const transaction = await ensureXrplTransactionIsValid(
+    currentTransactionFromStorage
+  );
+  if (transaction.err) {
+    handleErr(transaction);
     return;
   }
 
-  // On success, we should update Swap object and also call notifier
-  onNextStateOk(actions, nextStateResult.val);
-
   /*
    *
-   * 2. Ensure tx is supported, and namespace exists.
+   * 2. Ensure wallet is connected with a correct address.
    *
    */
-  const transaction = await ensureXrplTransactionIsValid(
-    currentTransactionFromStorage
-  );
-  if (transaction.err) {
-    handleErr(transaction);
+
+  const xrplWallet = getXrplWalletFromSwap(swap);
+  if (!xrplWallet) {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: 'Unexpected Error: Stellar wallet was not found in the swap!',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
     return;
   }
 
-  const namespace = await ensureXrplNamespaceExists(
-    context,
-    sourceWallet.walletType
-  );
+  const namespace = await ensureXrplNamespaceExists(context, xrplWallet.type);
   if (namespace.err) {
     handleErr(namespace);
     return;
   }
 
+  const ensureRequiredXrplWalletIsConnectedResult =
+    await ensureRequiredXrplWalletIsConnected(actions, xrplWallet);
+
+  if (ensureRequiredXrplWalletIsConnectedResult.err) {
+    requestBlockQueue(actions, ensureRequiredXrplWalletIsConnectedResult.val);
+    return;
+  }
+
+  const walletAddress = getCurrentAddressOf(swap, currentStep);
+
+  /*
+   * Checking the current transaction state to determine the next step.
+   * It will either be Err, indicating process should stop, or Ok, indicating process should continue.
+   */
+  const nextStateResult = produceNextStateForTransaction(actions);
+
+  if (nextStateResult.err) {
+    handleErr(nextStateResult);
+    return;
+  }
+
+  // On success, we should update Swap object and also call notifier
+  onNextStateOk(actions, nextStateResult.val);
+
   /*
    *
    * 3. Execute transaction
    *
    */
-  const chainId = meta.blockchains[transaction.val.blockChain]?.chainId;
-  const walletSigners = await getSigners(sourceWallet.walletType);
-
-  const signer: GenericSigner<XrplTransaction> = walletSigners.getSigner(
-    transaction.val.type
-  );
+  const chainId = meta.blockchains['XRPL']?.chainId;
+  let signer: GenericSigner<XrplTransaction>;
+  try {
+    const walletSigners = await getSigners(xrplWallet.type);
+    signer = walletSigners.getSigner(TransactionType.XRPL);
+  } catch {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message:
+          'Unexpected Error: Failed to load the signer. Please refresh the page and try again.',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
+    return;
+  }
 
   try {
     const result = await signer.signAndSendTx(

package/src/actions/executeXrplTransaction/helpers.ts

@@ -1,3 +1,11 @@
+import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
+import type { Transaction } from 'rango-sdk';
+import type { XrplTransaction } from 'rango-types';
+import type { Result } from 'ts-results';
+
+import { isXrplTransaction } from 'rango-types';
+import { Err, Ok } from 'ts-results';
+
 // Extracting currency and account from the following format (it's a convention on rango's backend): currency-accountAddress
 export function extractFromSymbolAddress(
   symbolAddress: string
@@ -6,3 +14,41 @@ export function extractFromSymbolAddress(
 
   return [currency, account];
 }
+
+export async function ensureXrplTransactionIsValid(
+  tx: Transaction | null
+): Promise<Result<XrplTransaction, NextTransactionStateError>> {
+  if (!tx) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Unexpected Error: tx is null!',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  if (!isXrplTransaction(tx)) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message:
+        "Unexpected Error: Expected XRPL transaction but it doesn't match with the structure.",
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  if (tx.data.TransactionType !== 'Payment') {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message:
+        'Unexpected Error: Only XRPL transactions with payment type are supported',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  return Ok(tx);
+}

package/src/actions/scheduleNextStep.ts

@@ -1,7 +1,7 @@
 import type { SwapQueueContext, SwapStorage } from '../types';
 import type { ExecuterActions } from '@rango-dev/queue-manager-core';
 
-import { type PendingSwapStep, TransactionType } from 'rango-types';
+import { type PendingSwapStep } from 'rango-types';
 
 import {
   getCurrentStep,
@@ -38,11 +38,7 @@ export function scheduleNextStep({
 
   if (!!currentStep && !isFailed) {
     if (isTxAlreadyCreated(swap, currentStep)) {
-      if (currentStep.fromBlockchain === TransactionType.XRPL) {
-        schedule(SwapActionTypes.CHECK_XRPL_TRUSTLINE);
-      } else {
-        schedule(SwapActionTypes.EXECUTE_TRANSACTION);
-      }
+      schedule(SwapActionTypes.CHECK_PREREQUISITES);
       return next();
     }
 

package/src/helpers.ts

@@ -39,6 +39,7 @@ import type {
   PendingSwapStep,
   SignerErrorCode,
   StepStatus,
+  SwapStepStatus,
 } from 'rango-types';
 
 import { warn } from '@rango-dev/logging-core';
@@ -55,6 +56,7 @@ import {
   TransactionType,
 } from 'rango-types';
 
+import { matchesPrerequisiteKey } from './actions/checkPrerequisites/utils';
 import {
   DEFAULT_ERROR_CODE,
   ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK,
@@ -170,6 +172,7 @@ export const getCurrentStepTx = (
     transferTransaction,
     starknetApprovalTransaction,
     starknetTransaction,
+    stellarTransaction,
     tronApprovalTransaction,
     tronTransaction,
     tonTransaction,
@@ -184,6 +187,7 @@ export const getCurrentStepTx = (
     transferTransaction ||
     starknetApprovalTransaction ||
     starknetTransaction ||
+    stellarTransaction ||
     tronApprovalTransaction ||
     tronTransaction ||
     tonTransaction ||
@@ -784,6 +788,7 @@ export const isTxAlreadyCreated = (
     swap.wallets[step.solanaTransaction?.blockChain || ''] ||
     swap.wallets[step.tonTransaction?.blockChain || ''] ||
     swap.wallets[step.suiTransaction?.blockChain || ''] ||
+    swap.wallets[step.stellarTransaction?.blockChain || ''] ||
     swap.wallets[step.xrplTransaction?.blockChain || ''] ||
     step.transferTransaction?.fromWalletAddress ||
     null;
@@ -1067,6 +1072,30 @@ export function isRequiredWalletConnected(
   return { ok: matched, reason: 'account_miss_match' };
 }
 
+export function updateStorageWithPrerequisiteResult(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>,
+  prerequisiteResult: SwapStepStatus['prerequisiteResults'][number]
+) {
+  const { getStorage, setStorage } = actions;
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+
+  const index = currentStep.prerequisiteResults.findIndex((existing) =>
+    matchesPrerequisiteKey(existing, prerequisiteResult)
+  );
+
+  if (index >= 0) {
+    currentStep.prerequisiteResults[index] = prerequisiteResult;
+  } else {
+    currentStep.prerequisiteResults.push(prerequisiteResult);
+  }
+
+  setStorage({
+    ...getStorage(),
+    swapDetails: swap,
+  });
+}
+
 export function updateStorageOnSuccessfulSign(
   actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any