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

package/src/actions/checkXrplTrustline/checkXrplTrustline.ts

@@ -2,63 +2,48 @@ import type { TargetToken } from './types';
 import type { SwapQueueContext, SwapStorage } 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,
+  XrplChangeTrustLinePrerequisite,
+  XrplChangeTrustLinePrerequisiteResult,
+  XrplTransaction,
+} from 'rango-types';
+
+import { TransactionType, XRPL_CHANGE_TRUSTLINE_TYPE } from 'rango-types';
+import { Err } from 'ts-results';
 
 import {
   getCurrentStep,
   getCurrentStepTx,
   handleRejectedSign,
-  updateStorageOnSuccessfulSign,
+  updateStorageWithPrerequisiteResult,
 } from '../../helpers';
-import { getCurrentAddressOf, getRelatedWallet } from '../../shared';
 import { SwapActionTypes } from '../../types';
-import { checkEnvironmentBeforeExecuteTransaction } from '../common/checkEnvironmentBeforeExecuteTransaction';
-import {
-  onNextStateError,
-  onNextStateOk,
-  produceNextStateForTransaction,
-} from '../common/produceNextStateForTransaction';
+import { onNextStateError } from '../common/produceNextStateForTransaction';
 import { requestBlockQueue } from '../common/utils';
 
 import {
-  checkTruslineAlreadyOpened,
-  createTrustlineTransaction,
+  checkIfTrustLineIsAlreadyOpened,
+  createTrustLineTransaction,
+  ensureRequiredXrplWalletIsConnected,
   ensureXrplNamespaceExists,
-  ensureXrplTransactionIsValid,
+  getXrplWalletFromSwap,
 } from './utils';
 
 export async function checkXrplTrustline(
   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, context, schedule, getStorage, next } = 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();
     }
   };
-  const onSuccessfulFinish = () => {
-    schedule(SwapActionTypes.EXECUTE_XRPL_TRANSACTION);
+
+  const scheduleCheckPrerequisites = () => {
+    schedule(SwapActionTypes.CHECK_PREREQUISITES);
     next();
     onFinish();
   };
@@ -70,110 +55,175 @@ export async function checkXrplTrustline(
   };
 
   /*
-   * 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);
+  if (!currentTransactionFromStorage) {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: 'Unexpected Error: tx is null!',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
     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. Check if there is a prerequisite with XRPL_CHANGE_TRUSTLINE_TYPE that does not have any result.
    *
    */
-  const transaction = await ensureXrplTransactionIsValid(
-    currentTransactionFromStorage
-  );
-  if (transaction.err) {
-    handleErr(transaction);
-    return;
+  let unmetXrplChangeTrustLineMeta: {
+    prerequisite: XrplChangeTrustLinePrerequisite;
+    prerequisiteIndex: number;
+  } | null = null;
+
+  for (
+    let prerequisiteIndex = 0;
+    prerequisiteIndex < currentTransactionFromStorage.prerequisites.length;
+    prerequisiteIndex++
+  ) {
+    const prerequisite =
+      currentTransactionFromStorage.prerequisites[prerequisiteIndex];
+    if (prerequisite.type === XRPL_CHANGE_TRUSTLINE_TYPE) {
+      const prerequisiteResult = currentStep.prerequisiteResults?.find(
+        (
+          prerequisiteResult
+        ): prerequisiteResult is XrplChangeTrustLinePrerequisiteResult =>
+          prerequisiteResult.prerequisiteIndex === prerequisiteIndex &&
+          prerequisiteResult.prerequisiteType === XRPL_CHANGE_TRUSTLINE_TYPE
+      );
+
+      if (!prerequisiteResult) {
+        unmetXrplChangeTrustLineMeta = {
+          prerequisite,
+          prerequisiteIndex,
+        };
+      }
+    }
   }
 
-  const namespace = await ensureXrplNamespaceExists(
-    context,
-    sourceWallet.walletType
-  );
-  if (namespace.err) {
-    handleErr(namespace);
+  if (!unmetXrplChangeTrustLineMeta) {
+    scheduleCheckPrerequisites();
     return;
   }
 
   /*
-   * 3. Do we need open a trustline for this transaction?
    *
-   * Trust line only should be opened for issued token (not native), server is putting that data as prerequisite for us.
-   * If there is no need for that, we are skipping this step and consider it as done.
+   * 3. Ensure XRPL wallet is connected.
+   *
    */
-  const trustlinePrerequisite = transaction.val.prerequisites.find(
-    (item) => item.type === 'XRPL_CHANGE_TRUSTLINE'
-  );
-  if (!trustlinePrerequisite) {
-    onSuccessfulFinish();
+
+  const xrplWallet = getXrplWalletFromSwap(swap);
+  if (!xrplWallet) {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: 'Unexpected Error: XRPL wallet was not found in the swap!',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
+    return;
+  }
+  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;
   }
 
   /*
    *
-   * 4. Ensure trusline has been opened, then execute if needed.
+   * 3. Check if trust line is already opened.
    *
    */
-  const chainId = meta.blockchains[transaction.val.blockChain]?.chainId;
-  const walletSigners = await getSigners(sourceWallet.walletType);
 
   const token: TargetToken = {
-    currency: trustlinePrerequisite.currency,
-    account: trustlinePrerequisite.issuer,
-    amount: trustlinePrerequisite.value,
+    currency: unmetXrplChangeTrustLineMeta.prerequisite.currency,
+    account: unmetXrplChangeTrustLineMeta.prerequisite.issuer,
+    amount: unmetXrplChangeTrustLineMeta.prerequisite.value,
   };
 
-  // TODO: it's better to add some logic around `balance` to ensure we have enough capacity for the trust line. Now we only check it's already open or not.
-  const isTruslineAlreadyOpened = await checkTruslineAlreadyOpened(
-    trustlinePrerequisite.wallet,
+  const trustLineIsAlreadyOpenedResult = await checkIfTrustLineIsAlreadyOpened(
+    unmetXrplChangeTrustLineMeta.prerequisite.wallet,
     token,
     {
       namespace: namespace.val,
     }
   );
 
-  if (!isTruslineAlreadyOpened) {
-    const trustlineTx = createTrustlineTransaction(
-      trustlinePrerequisite.wallet,
+  if (trustLineIsAlreadyOpenedResult.err) {
+    handleErr(trustLineIsAlreadyOpenedResult);
+    return;
+  }
+
+  if (trustLineIsAlreadyOpenedResult.val.trustLineIsAlreadyOpened) {
+    const prerequisiteResult: XrplChangeTrustLinePrerequisiteResult = {
+      prerequisiteIndex: unmetXrplChangeTrustLineMeta.prerequisiteIndex,
+      prerequisiteType: XRPL_CHANGE_TRUSTLINE_TYPE,
+      status: 'skipped',
+      data: null,
+    };
+    updateStorageWithPrerequisiteResult(actions, prerequisiteResult);
+    scheduleCheckPrerequisites();
+    return;
+  }
+
+  /*
+   *
+   * 4. Create trust line transaction.
+   *
+   */
+
+  try {
+    // Create trust line transaction with the required limit
+    const trustlineTransaction = createTrustLineTransaction(
+      unmetXrplChangeTrustLineMeta.prerequisite.wallet,
       token
     );
 
+    const chainId = meta.blockchains['XRPL']?.chainId;
+    const walletSigners = await getSigners(xrplWallet.type);
     const signer: GenericSigner<XrplTransaction> = walletSigners.getSigner(
-      transaction.val.type
+      TransactionType.XRPL
     );
 
-    try {
-      const trustlineTransaction: XrplTransaction = {
-        ...transaction.val,
-        data: trustlineTx,
-      };
-      const result = await signer.signAndSendTx(
-        trustlineTransaction,
-        walletAddress,
-        chainId
-      );
+    const transactionResult = await signer.signAndSendTx(
+      trustlineTransaction,
+      xrplWallet.address,
+      chainId
+    );
 
-      updateStorageOnSuccessfulSign(actions, result, {
-        // TODO: approval has different meaning for EVM, we may need to add a third type called trustline for the following function.
-        isApproval: true,
-      });
-      onSuccessfulFinish();
-    } catch (e) {
-      handleRejectedSign(actions)(e);
-      onFinish();
-    }
-  } else {
-    onSuccessfulFinish();
-    return;
+    const prerequisiteResult: XrplChangeTrustLinePrerequisiteResult = {
+      prerequisiteIndex: unmetXrplChangeTrustLineMeta.prerequisiteIndex,
+      prerequisiteType: XRPL_CHANGE_TRUSTLINE_TYPE,
+      status: 'pending',
+      data: {
+        executedTransactionHash: transactionResult.hash,
+      },
+    };
+
+    updateStorageWithPrerequisiteResult(actions, prerequisiteResult);
+    scheduleCheckPrerequisites();
+  } catch (e) {
+    handleRejectedSign(actions)(e);
+    onFinish();
   }
 }

package/src/actions/checkXrplTrustline/constants.ts

@@ -0,0 +1 @@
+export const TRUST_LINE_INFINITE_VALUE = '10000000000000';

package/src/actions/checkXrplTrustline/index.ts

@@ -1,5 +1,6 @@
 export { checkXrplTrustline } from './checkXrplTrustline.js';
 export {
   ensureXrplNamespaceExists,
-  ensureXrplTransactionIsValid,
+  ensureRequiredXrplWalletIsConnected,
+  getXrplWalletFromSwap,
 } from './utils.js';

package/src/actions/checkXrplTrustline/utils.ts

@@ -1,50 +1,31 @@
 import type { TargetToken, XrplNamespace } from './types';
-import type { SwapQueueContext } from '../../types';
+import type { TargetNamespace } from '../../shared';
 import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
-import type { Transaction } from 'rango-sdk';
-import type { XrplTransaction, XrplTrustSetTransactionData } from 'rango-types';
+import type {
+  BlockedReason,
+  ExecuterActions,
+} from '@rango-dev/queue-manager-core';
+import type { WalletType } from '@rango-dev/wallets-shared';
+import type { PendingSwap, XrplTransaction } from 'rango-types';
 import type { Result } from 'ts-results';
 
-import { isXrplTransaction } from 'rango-types';
+import { legacyReadAccountAddress as readAccountAddress } from '@rango-dev/wallets-core/legacy';
+import BigNumber from 'bignumber.js';
+import { TransactionType } from 'rango-types';
 import { Err, Ok } from 'ts-results';
 
-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',
-    });
-  }
+import {
+  ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION,
+  ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION_WRONG_WALLET,
+} from '../../constants';
+import {
+  BlockReason,
+  type SwapActionTypes,
+  type SwapQueueContext,
+  type SwapStorage,
+} from '../../types';
 
-  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: We only support XRPL transactions with payment type',
-      details: undefined,
-      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
-    });
-  }
-
-  return Ok(tx);
-}
+import { TRUST_LINE_INFINITE_VALUE } from './constants';
 
 export async function ensureXrplNamespaceExists(
   context: SwapQueueContext,
@@ -65,34 +46,128 @@ export async function ensureXrplNamespaceExists(
   return Ok(xrplNamespace);
 }
 
-export async function checkTruslineAlreadyOpened(
+export async function checkIfTrustLineIsAlreadyOpened(
   account: string,
   token: TargetToken,
   options: { namespace: XrplNamespace }
-): Promise<boolean> {
-  const lines = await options.namespace.accountLines(account, {
-    peer: token.account,
-  });
-  return !!lines.some((trustline) => {
-    return (
-      trustline.currency === token.currency &&
-      trustline.account === token.account &&
-      trustline.limit !== '0'
+): Promise<
+  Result<{ trustLineIsAlreadyOpened: boolean }, NextTransactionStateError>
+> {
+  try {
+    // Get account lines for the account
+    const accountLines = await options.namespace.accountLines(account, {
+      peer: token.account,
+    });
+
+    // Find the target account line
+    const targetAccountLine = accountLines.find(
+      (accountLine) =>
+        accountLine.currency === token.currency &&
+        accountLine.account === token.account
     );
-  });
+
+    // If not account line is open on the target token, return false
+    if (!targetAccountLine) {
+      return new Ok({
+        trustLineIsAlreadyOpened: false,
+      });
+    }
+
+    const lineLimit = new BigNumber(targetAccountLine.limit);
+    const targetLimit = new BigNumber(TRUST_LINE_INFINITE_VALUE);
+
+    // If the account line is open, and contains a suitable limit, return true
+    return new Ok({
+      trustLineIsAlreadyOpened: lineLimit.gte(targetLimit),
+    });
+  } catch {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Could not get account lines from XRPL.',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
 }
 
-export function createTrustlineTransaction(
+export function createTrustLineTransaction(
   account: string,
   token: TargetToken
-): XrplTrustSetTransactionData {
+): XrplTransaction {
   return {
-    TransactionType: 'TrustSet',
-    Account: account,
-    LimitAmount: {
-      currency: token.currency,
-      issuer: token.account,
-      value: token.amount,
+    type: TransactionType.XRPL,
+    blockChain: 'XRPL',
+    prerequisites: [],
+    data: {
+      TransactionType: 'TrustSet',
+      Account: account,
+      LimitAmount: {
+        currency: token.currency,
+        issuer: token.account,
+        value: TRUST_LINE_INFINITE_VALUE,
+      },
     },
   };
 }
+
+export function getXrplWalletFromSwap(swap: PendingSwap): {
+  type: WalletType;
+  namespace: TargetNamespace;
+  address: string;
+} | null {
+  const xrplWallet = swap.wallets['XRPL'];
+
+  if (!xrplWallet) {
+    return null;
+  }
+
+  return {
+    type: xrplWallet.walletType,
+    namespace: {
+      namespace: 'XRPL',
+      network: 'XRPL',
+    },
+    address: xrplWallet.address,
+  };
+}
+
+export async function ensureRequiredXrplWalletIsConnected(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>,
+  requiredWallet: {
+    type: WalletType;
+    namespace: TargetNamespace;
+    address: string;
+  }
+): Promise<Result<true, BlockedReason>> {
+  const { context } = actions;
+
+  const walletState = context.state(requiredWallet.type);
+  const { accounts, connected } = walletState;
+
+  if (!connected) {
+    return new Err({
+      reason: BlockReason.WAIT_FOR_CONNECT_WALLET,
+      description: ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION(
+        requiredWallet.type
+      ),
+    });
+  }
+
+  if (
+    !accounts?.find(
+      (account) =>
+        readAccountAddress(account).address === requiredWallet.address
+    )
+  ) {
+    return new Err({
+      reason: BlockReason.WAIT_FOR_CONNECT_WALLET,
+      description: ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION_WRONG_WALLET(
+        requiredWallet.type,
+        requiredWallet.address
+      ),
+    });
+  }
+
+  return new Ok(true);
+}