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

package/dist/types.d.ts

@@ -0,0 +1,46 @@
+import { QueueStorage, QueueDef } from '@rango-dev/queue-manager-core';
+import { QueueContext } from '@rango-dev/queue-manager-core/dist/queue';
+import { ConnectResult, Providers } from '@rango-dev/wallets-core';
+import { EvmBlockchainMeta, Meta, Network, WalletSigners, WalletState, WalletType } from '@rango-dev/wallets-shared';
+import { PendingSwap, SwapProgressNotification, Wallet } from './shared';
+export declare type SwapQueueDef = QueueDef<SwapStorage, SwapActionTypes, SwapQueueContext>;
+export interface SwapStorage extends QueueStorage {
+    swapDetails: PendingSwap;
+}
+export declare enum SwapActionTypes {
+    START = "START",
+    SCHEDULE_NEXT_STEP = "SCHEDULE_NEXT_STEP",
+    CREATE_TRANSACTION = "CREATE_TRANSACTION",
+    EXECUTE_TRANSACTION = "EXECUTE_TRANSACTION",
+    CHECK_TRANSACTION_STATUS = "CHECK_TRANSACTION_STATUS"
+}
+export declare type GetCurrentAddress = (type: WalletType, network: Network) => string | undefined;
+export declare enum BlockReason {
+    WAIT_FOR_CONNECT_WALLET = "waiting_for_connecting_wallet",
+    WAIT_FOR_NETWORK_CHANGE = "waiting_for_network_change",
+    DEPENDS_ON_OTHER_QUEUES = "depends_on_other_queues"
+}
+export interface Block<T = any> {
+    reason: BlockReason;
+    description: string;
+    details?: T;
+}
+export interface SwapQueueContext extends QueueContext {
+    meta: Meta;
+    wallets: Wallet | null;
+    providers: Providers;
+    getSigners: (type: WalletType) => WalletSigners;
+    switchNetwork: (wallet: WalletType, network: Network) => Promise<ConnectResult> | undefined;
+    connect: (wallet: WalletType, network: Network) => Promise<ConnectResult> | undefined;
+    state: (type: WalletType) => WalletState;
+    notifier: (data: SwapProgressNotification) => void;
+    claimedBy?: string;
+    resetClaimedBy?: () => void;
+}
+export interface UseQueueManagerParams {
+    lastConnectedWallet: string;
+    disconnectedWallet: WalletType | undefined;
+    clearDisconnectedWallet: () => void;
+    evmChains: EvmBlockchainMeta[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,EACL,iBAAiB,EACjB,IAAI,EACJ,OAAO,EACP,aAAa,EACb,WAAW,EACX,UAAU,EACX,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEzE,oBAAY,YAAY,GAAG,QAAQ,CACjC,WAAW,EACX,eAAe,EACf,gBAAgB,CACjB,CAAC;AAEF,MAAM,WAAW,WAAY,SAAQ,YAAY;IAC/C,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,oBAAY,eAAe;IACzB,KAAK,UAAU;IACf,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,mBAAmB,wBAAwB;IAC3C,wBAAwB,6BAA6B;CACtD;AAED,oBAAY,iBAAiB,GAAG,CAC9B,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,OAAO,KACb,MAAM,GAAG,SAAS,CAAC;AAExB,oBAAY,WAAW;IACrB,uBAAuB,kCAAkC;IACzD,uBAAuB,+BAA+B;IACtD,uBAAuB,4BAA4B;CACpD;AAGD,MAAM,WAAW,KAAK,CAAC,CAAC,GAAG,GAAG;IAC5B,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,CAAC;CACb;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,aAAa,CAAC;IAChD,aAAa,EAAE,CACb,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,OAAO,KACb,OAAO,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC;IACxC,OAAO,EAAE,CACP,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,OAAO,KACb,OAAO,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC;IACxC,KAAK,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,WAAW,CAAC;IACzC,QAAQ,EAAE,CAAC,IAAI,EAAE,wBAAwB,KAAK,IAAI,CAAC;IAGnD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,qBAAqB;IACpC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,UAAU,GAAG,SAAS,CAAC;IAC3C,uBAAuB,EAAE,MAAM,IAAI,CAAC;IACpC,SAAS,EAAE,iBAAiB,EAAE,CAAC;CAChC"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@rango-dev/queue-manager-rango-preset",
+  "version": "0.1.10-next.77",
+  "license": "MIT",
+  "module": "dist/queue-manager-rango-preset.esm.js",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "dev": "tsdx watch",
+    "build": "tsdx build",
+    "test": "tsdx test",
+    "lint": "tsdx lint",
+    "size": "size-limit",
+    "analyze": "size-limit --why"
+  },
+  "peerDependencies": {
+    "@rango-dev/queue-manager-core": "*",
+    "@rango-dev/wallets-core": "*",
+    "@rango-dev/wallets-shared": "*",
+    "@sentry/browser": "*",
+    "bignumber.js": "*",
+    "uuid": "*"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "tsdx lint"
+    }
+  },
+  "prettier": {
+    "printWidth": 80,
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "es5"
+  },
+  "size-limit": [
+    {
+      "path": "dist/queue-manager-rango-preset.cjs.production.min.js",
+      "limit": "10 KB"
+    },
+    {
+      "path": "dist/queue-manager-rango-preset.esm.js",
+      "limit": "10 KB"
+    }
+  ],
+  "devDependencies": {
+    "@types/uuid": "^8.3.4"
+  },
+  "dependencies": {
+    "rango-sdk": "^0.1.17",
+    "uuid": "^9.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/readme.md

@@ -0,0 +1,9 @@
+# Rango Queue Preset
+
+## Requirements
+
+### Env variables
+
+REACT_APP_RANGO_DAPP_ID_QUERY
+REACT_APP_BASE_URL
+

package/src/actions/checkStatus.ts

@@ -0,0 +1,213 @@
+import BigNumber from 'bignumber.js';
+import { ExecuterActions } from '@rango-dev/queue-manager-core';
+import {
+  delay,
+  getCurrentStep,
+  isCosmosTransaction,
+  isEvmTransaction,
+  isSolanaTransaction,
+  isStarknetTransaction,
+  isTrasnferTransaction,
+  isTronTransaction,
+  resetNetworkStatus,
+} from '../helpers';
+import { SwapActionTypes, SwapQueueContext, SwapStorage } from '../types';
+import { getNextStep, MessageSeverity, SwapperStatusResponse } from '../shared';
+import { checkApproved, checkSwapStatus } from '../shared-api';
+
+const INTERVAL_FOR_CHECK = 2000;
+
+/**
+ * Subscribe to status of swap transaction by checking from server periodically.
+ * After getting the status, notify the user and schedule `SCHEDULE_NEXT_STEP`.
+ */
+async function checkTransactionStatus({
+  getStorage,
+  setStorage,
+  next,
+  schedule,
+  retry,
+  context,
+}: ExecuterActions<
+  SwapStorage,
+  SwapActionTypes,
+  SwapQueueContext
+>): Promise<void> {
+  const swap = getStorage().swapDetails;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const currentStep = getCurrentStep(swap)!;
+  const txId = currentStep.executedTransactionId;
+
+  let status: SwapperStatusResponse | null = null;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    status = await checkSwapStatus(swap.requestId, txId!, currentStep.id);
+  } catch (e) {
+    await delay(INTERVAL_FOR_CHECK);
+    retry();
+    return;
+  }
+
+  const outputAmount: BigNumber | null =
+    status?.outputAmount ||
+    (!!currentStep.outputAmount
+      ? new BigNumber(currentStep.outputAmount)
+      : null);
+  const prevOutputAmount = currentStep.outputAmount;
+  swap.extraMessage = status?.extraMessage || swap.extraMessage;
+  swap.extraMessageSeverity = MessageSeverity.info;
+  swap.extraMessageDetail = '';
+
+  currentStep.status = status?.status || currentStep.status;
+  currentStep.diagnosisUrl =
+    status?.diagnosisUrl || currentStep.diagnosisUrl || null;
+  currentStep.outputAmount =
+    outputAmount?.toFixed() || currentStep.outputAmount;
+  currentStep.explorerUrl = status?.explorerUrl || currentStep.explorerUrl;
+  currentStep.internalSteps = status?.steps || null;
+
+  const newTransaction = status?.newTx;
+
+  if (!!newTransaction) {
+    currentStep.status = 'created';
+    currentStep.executedTransactionId = null;
+    currentStep.transferTransaction = null;
+    currentStep.cosmosTransaction = null;
+    currentStep.evmTransaction = null;
+    currentStep.solanaTransaction = null;
+    currentStep.evmApprovalTransaction = null;
+    currentStep.starknetApprovalTransaction = null;
+    currentStep.starknetTransaction = null;
+    currentStep.tronApprovalTransaction = null;
+    currentStep.tronTransaction = null;
+
+    if (isEvmTransaction(newTransaction)) {
+      if (newTransaction.isApprovalTx)
+        currentStep.evmApprovalTransaction = newTransaction;
+      else currentStep.evmTransaction = newTransaction;
+    } else if (isCosmosTransaction(newTransaction)) {
+      currentStep.cosmosTransaction = newTransaction;
+    } else if (isSolanaTransaction(newTransaction)) {
+      currentStep.solanaTransaction = newTransaction;
+    } else if (isTrasnferTransaction(newTransaction)) {
+      currentStep.transferTransaction = newTransaction;
+    } else if (isStarknetTransaction(newTransaction)) {
+      if (newTransaction.isApprovalTx)
+        currentStep.starknetApprovalTransaction = newTransaction;
+      else currentStep.starknetTransaction = newTransaction;
+    } else if (isTronTransaction(newTransaction)) {
+      if (newTransaction.isApprovalTx)
+        currentStep.tronApprovalTransaction = newTransaction;
+      else currentStep.tronTransaction = newTransaction;
+    }
+  }
+
+  if (prevOutputAmount === null && outputAmount !== null)
+    context.notifier({
+      eventType: 'step_completed_with_output',
+      swap: swap,
+      step: currentStep,
+    });
+
+  if (currentStep.status === 'success') {
+    const nextStep = getNextStep(swap, currentStep);
+    swap.extraMessageDetail = '';
+    swap.extraMessage = !!nextStep
+      ? `starting next step: ${nextStep.swapperId}: ${nextStep.fromBlockchain} -> ${nextStep.toBlockchain}`
+      : '';
+  }
+
+  // Sync data with storage
+  setStorage({ ...getStorage(), swapDetails: swap });
+
+  if (
+    status?.status === 'failed' ||
+    status?.status === 'success' ||
+    (status?.status === 'running' && !!status.newTx)
+  ) {
+    schedule(SwapActionTypes.SCHEDULE_NEXT_STEP);
+    next();
+  } else {
+    await delay(INTERVAL_FOR_CHECK);
+    retry();
+  }
+}
+
+/**
+ * Subscribe to status of approval transaction by checking from server periodically.
+ * After getting the status, notify the user and schedule `SCHEDULE_NEXT_STEP`.
+ */
+async function checkApprovalStatus({
+  getStorage,
+  setStorage,
+  next,
+  schedule,
+  retry,
+  context,
+}: ExecuterActions<
+  SwapStorage,
+  SwapActionTypes,
+  SwapQueueContext
+>): Promise<void> {
+  const swap = getStorage().swapDetails as SwapStorage['swapDetails'];
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const currentStep = getCurrentStep(swap)!;
+  let isApproved = false;
+  try {
+    const response = await checkApproved(swap.requestId);
+    isApproved = response.isApproved;
+  } catch (e) {
+    console.error('Failed to check getApprovedAmount', e);
+  }
+  if (isApproved) {
+    currentStep.status = 'approved';
+    swap.extraMessage = `Spending ${currentStep.fromSymbol} approved successfully.`;
+    swap.extraMessageDetail = null;
+    swap.extraMessageSeverity = MessageSeverity.success;
+    currentStep.evmApprovalTransaction = null;
+    currentStep.executedTransactionId = null;
+
+    setStorage({
+      ...getStorage(),
+      swapDetails: swap,
+    });
+
+    context.notifier({
+      eventType: 'contract_confirmed',
+      swap: swap,
+      step: currentStep,
+    });
+
+    schedule(SwapActionTypes.SCHEDULE_NEXT_STEP);
+    next();
+  } else {
+    await delay(2000);
+    retry();
+  }
+}
+
+/**
+ *
+ * For doing a swap the user needs to accept a `contract` so it can use the user balance.
+ * There is two types of check status:
+ *  1. Checking approval transaction (Give permission to a contract)
+ *  2. Checking swap transaction.
+ *
+ */
+export async function checkStatus(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Promise<void> {
+  const swap = actions.getStorage().swapDetails;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const currentStep = getCurrentStep(swap)!;
+
+  // Reset network status
+  // Because when check status is on `loading` or `failed` status, it shows previous message that isn't related to current state.
+  resetNetworkStatus(actions);
+
+  if (currentStep.status === 'running') {
+    await checkTransactionStatus(actions);
+  } else if (currentStep.status === 'waitingForApproval') {
+    await checkApprovalStatus(actions);
+  }
+}

package/src/actions/createTransaction.ts

@@ -0,0 +1,101 @@
+import { ExecuterActions } from '@rango-dev/queue-manager-core';
+import { SwapActionTypes, SwapQueueContext, SwapStorage } from '../types';
+import {
+  getCurrentStep,
+  isCosmosTransaction,
+  isEvmTransaction,
+  isSolanaTransaction,
+  isTrasnferTransaction,
+  updateSwapStatus,
+} from '../helpers';
+import { createTransaction as requestTransaction } from '../shared-api';
+import { APIErrorCode } from '../shared-errors';
+import { prettifyErrorMessage } from '../shared';
+import { CreateTransactionRequest } from 'rango-sdk';
+
+/**
+ *
+ * When a user asks for a swap, We first create the transaction by sending a request to server
+ * Server will return the transaction that need to be sent to wallet.
+ * It can be failed if server goes through an error, If not, we will schedule the `EXECTUTE_TRANSACTION`.
+ *
+ */
+export async function createTransaction(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Promise<void> {
+  const { setStorage, getStorage, next, schedule, context } = actions;
+  const swap = getStorage().swapDetails;
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const currentStep = getCurrentStep(swap)!;
+
+  const {
+    evmTransaction,
+    cosmosTransaction,
+    transferTransaction,
+    evmApprovalTransaction,
+    solanaTransaction,
+  } = currentStep;
+
+  if (
+    !evmTransaction &&
+    !cosmosTransaction &&
+    !transferTransaction &&
+    !evmApprovalTransaction &&
+    !solanaTransaction
+  ) {
+    const request: CreateTransactionRequest = {
+      requestId: swap.requestId,
+      step: currentStep.id,
+      userSettings: {
+        slippage: swap.settings.slippage,
+        infiniteApprove: swap.settings.infiniteApprove,
+      },
+      validations: {
+        balance: swap.validateBalanceOrFee,
+        fee: swap.validateBalanceOrFee,
+      },
+    };
+    try {
+      // Getting transcation from server.
+      const { transaction } = await requestTransaction(request);
+
+      if (transaction) {
+        if (isEvmTransaction(transaction)) {
+          if (transaction.isApprovalTx)
+            currentStep.evmApprovalTransaction = transaction;
+          else currentStep.evmTransaction = transaction;
+        } else if (isCosmosTransaction(transaction)) {
+          currentStep.cosmosTransaction = transaction;
+        } else if (isSolanaTransaction(transaction)) {
+          currentStep.solanaTransaction = transaction;
+        } else if (isTrasnferTransaction(transaction)) {
+          currentStep.transferTransaction = transaction;
+        }
+      }
+
+      setStorage({ ...getStorage(), swapDetails: swap });
+      schedule(SwapActionTypes.EXECUTE_TRANSACTION);
+      next();
+    } catch (error) {
+      swap.status = 'failed';
+      swap.finishTime = new Date().getTime().toString();
+      const { extraMessage, extraMessageDetail } = prettifyErrorMessage(error);
+
+      const updateResult = updateSwapStatus({
+        getStorage,
+        setStorage,
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: extraMessage,
+        details: extraMessageDetail,
+        errorCode: APIErrorCode.FETCH_TX_FAILED,
+      });
+      context.notifier({
+        eventType: 'task_failed',
+        ...updateResult,
+      });
+
+      actions.failed();
+    }
+  }
+}

package/src/actions/executeTransaction.ts

@@ -0,0 +1,117 @@
+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);
+  if (isWrongAddress) {
+    const { type, address } = getRequiredWallet(swap);
+    const description = !wallets
+      ? 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 running tasks to be finished',
+      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,60 @@
+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();
+    }
+
+    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,23 @@
+export const RANGO_DAPP_ID_QUERY = process.env.REACT_APP_RANGO_DAPP_ID_QUERY;
+export const BASE_URL = process.env.REACT_APP_BASE_URL;
+export const RANGO_COOKIE_HEADER = 'X-Rango-Id';
+
+export const ERROR_MESSAGE_DEPENDS_ON_OTHER_QUEUES =
+  'Waiting for other running tasks to be finished';
+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}.`;