@rango-dev/queue-manager-rango-preset 0.1.10-next.101

package/src/actions/executeTransaction.ts

@@ -0,0 +1,121 @@
+import { ExecuterActions } from '@rango-dev/queue-manager-core';
+import {
+  ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK,
+  ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION,
+  ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION_WRONG_WALLET,
+} from '../constants';
+
+import {
+  getCurrentStep,
+  isNetworkMatchedForTransaction,
+  isRequiredWalletConnected,
+  updateNetworkStatus,
+  singTransaction,
+  resetNetworkStatus,
+  getRequiredWallet,
+  isNeedBlockQueueForParallel,
+} from '../helpers';
+import { getCurrentBlockchainOf, PendingSwapNetworkStatus } from '../shared';
+import {
+  BlockReason,
+  SwapActionTypes,
+  SwapQueueContext,
+  SwapStorage,
+} from '../types';
+
+/**
+ * Excecute a created transaction.
+ *
+ * This function implemented the parallel mode by `claim` mechanism which means
+ * All the queues the meet certain situation (like multiple evm transaction) will go through
+ * a `claim` mechanims that decides which queue should be run and it blocks other ones.
+ *
+ * A queue will be go to sign process, if the wallet and network is matched.
+ */
+export async function executeTransaction(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Promise<void> {
+  const { getStorage, context } = actions;
+  const { meta, wallets, providers } = context;
+
+  const isClaimed = context.claimedBy === context._queue?.id;
+  const requestBlock: typeof actions.block = (blockedFor) => {
+    actions.block(blockedFor);
+    if (isClaimed && actions.context.resetClaimedBy) {
+      actions.context.resetClaimedBy();
+    }
+  };
+
+  const swap = getStorage().swapDetails;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const currentStep = getCurrentStep(swap)!;
+
+  // Resetting network status, so we will set it again during the running of this task.
+  resetNetworkStatus(actions);
+
+  /* Make sure wallet is connected and also the connected wallet is matched with tx by checking address. */
+  const isWrongAddress = !isRequiredWalletConnected(swap, context.state).ok;
+  if (isWrongAddress) {
+    const { type, address } = getRequiredWallet(swap);
+    const isWalletInCompatible = wallets?.blockchains?.find(
+      (w) => !w.accounts?.find((account) => account.walletType === type)
+    );
+    const description =
+      !wallets || isWalletInCompatible
+        ? ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION(type)
+        : ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION_WRONG_WALLET(type, address);
+
+    const blockedFor = {
+      reason: BlockReason.WAIT_FOR_CONNECT_WALLET,
+      description,
+    };
+    requestBlock(blockedFor);
+    return;
+  }
+
+  /* 
+  For avoiding conflict by making too many requests to wallet, we need to make sure
+  We only run one request at a time (In parallel mode).
+  */
+  const needsToBlockQueue = isNeedBlockQueueForParallel(currentStep);
+
+  if (needsToBlockQueue && !isClaimed && context.claimedBy) {
+    const blockedFor = {
+      reason: BlockReason.DEPENDS_ON_OTHER_QUEUES,
+      description: 'Waiting for other swaps to complete',
+      details: {},
+    };
+    requestBlock(blockedFor);
+    return;
+  }
+
+  /* Wallet should be on correct network */
+  const networkMatched = await isNetworkMatchedForTransaction(
+    swap,
+    currentStep,
+    wallets,
+    meta,
+    providers
+  );
+  if (!networkMatched) {
+    const fromBlockchain = getCurrentBlockchainOf(swap, currentStep);
+    const details = ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK(fromBlockchain);
+
+    const blockedFor = {
+      reason: BlockReason.WAIT_FOR_NETWORK_CHANGE,
+      details: details,
+    };
+    requestBlock(blockedFor);
+    return;
+  } else {
+    // Update network to mark it as network changed successfully.
+    updateNetworkStatus(actions, {
+      message: '',
+      details: 'Wallet network changed successfully',
+      status: PendingSwapNetworkStatus.NetworkChanged,
+    });
+  }
+
+  // All the conditions are met. We can safely send the tx to wallet for sign.
+  singTransaction(actions);
+}

package/src/actions/scheduleNextStep.ts

@@ -0,0 +1,61 @@
+import { ExecuterActions } from '@rango-dev/queue-manager-core';
+import { SwapActionTypes, SwapQueueContext, SwapStorage } from '../types';
+import { getCurrentStep, isTxAlreadyCreated } from '../helpers';
+
+/**
+ *
+ * This function is responsibe for scheduling the correct `action` based on `PendingSwap` status.
+ * It means `action`s schedule this step to decide what should be the next step/task.
+ *
+ * It's acts like a `while(true)` and will `break` the loop on certain `action`s like `CHECK_STATUS`.
+ *
+ *
+ */
+export function scheduleNextStep({
+  schedule,
+  next,
+  failed,
+  setStorage,
+  getStorage,
+  context,
+}: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>): void {
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap);
+  if (!!currentStep) {
+    if (isTxAlreadyCreated(swap, currentStep)) {
+      schedule(SwapActionTypes.EXECUTE_TRANSACTION);
+      return next();
+    }
+
+    // TODO double check it after approval changes
+    if (currentStep?.executedTransactionId) {
+      schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
+      return next();
+    }
+
+    swap.status = 'running';
+
+    setStorage({ ...getStorage(), swapDetails: swap });
+
+    schedule(SwapActionTypes.CREATE_TRANSACTION);
+    next();
+  } else {
+    const isFailed = swap.steps.find((step) => step.status === 'failed');
+    swap.status = isFailed ? 'failed' : 'success';
+    swap.finishTime = new Date().getTime().toString();
+
+    setStorage({
+      ...getStorage(),
+      swapDetails: swap,
+    });
+
+    context.notifier({
+      eventType: isFailed ? 'task_failed' : 'task_completed',
+      swap: swap,
+      step: null,
+    });
+
+    if (isFailed) failed();
+    else next();
+  }
+}

package/src/actions/start.ts

@@ -0,0 +1,10 @@
+import { ExecuterActions } from '@rango-dev/queue-manager-core';
+import { SwapActionTypes, SwapStorage } from '../types';
+
+export function start({
+  schedule,
+  next,
+}: ExecuterActions<SwapStorage, SwapActionTypes>): void {
+  schedule(SwapActionTypes.SCHEDULE_NEXT_STEP);
+  next();
+}

package/src/constants.ts

@@ -0,0 +1,22 @@
+export const RANGO_DAPP_API_KEY = process.env.REACT_APP_API_KEY;
+export const RANGO_DAPP_API_BASE_URL = process.env.REACT_APP_API_BASE_URL;
+
+export const ERROR_MESSAGE_DEPENDS_ON_OTHER_QUEUES =
+  'Waiting for other swaps to complete';
+export const ERROR_MESSAGE_WAIT_FOR_WALLET = 'Waiting for connecting wallet';
+export const ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION_WRONG_WALLET = (
+  type: string | null,
+  address: string | null
+): string =>
+  `Please change your ${type || 'wallet'} account to ${
+    address || 'proper address'
+  }`;
+export const ERROR_MESSAGE_WAIT_FOR_WALLET_DESCRIPTION = (
+  type: string | null
+): string =>
+  `Please connect to ${
+    type || 'your wallet'
+  } by using bellow button or top right button on page.`;
+export const ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK = (
+  network: string | null
+): string => `Please change your network to ${network}.`;