@rango-dev/queue-manager-rango-preset 0.0.0-experimental-936229e8-20251208

package/src/actions/common/produceNextStateForTransaction.ts

@@ -0,0 +1,167 @@
+import type { ExecuterActions } from '@rango-dev/queue-manager-core';
+import type {
+  APIErrorCode,
+  SignerErrorCode,
+  StepStatus,
+  SwapStatus,
+} from 'rango-types';
+
+import { Err, Ok, type Result } from 'ts-results';
+
+import { DEFAULT_ERROR_CODE } from '../../constants';
+import {
+  getCurrentStep,
+  getCurrentStepTx,
+  getLastFinishedStepInput,
+  getLastFinishedStepInputUsd,
+  isApprovalCurrentStepTx,
+  updateSwapStatus,
+} from '../../helpers';
+import { notifier } from '../../services/eventEmitter';
+import { getRelatedWallet } from '../../shared';
+import {
+  StepEventType,
+  StepExecutionEventStatus,
+  type SwapActionTypes,
+  type SwapQueueContext,
+  type SwapStorage,
+} from '../../types';
+
+export interface NextTransactionState {
+  nextStatus?: SwapStatus;
+  nextStepStatus: StepStatus;
+
+  message: string;
+  details?: string;
+}
+
+export interface NextTransactionStateError extends NextTransactionState {
+  errorCode: APIErrorCode | SignerErrorCode | null;
+}
+
+export function produceNextStateForTransaction(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Result<NextTransactionState, NextTransactionStateError> {
+  const { getStorage, context } = actions;
+  const { isMobileWallet } = context;
+  const swap = getStorage().swapDetails;
+
+  const currentStep = getCurrentStep(swap)!;
+
+  const sourceWallet = getRelatedWallet(swap, currentStep);
+  const mobileWallet = isMobileWallet(sourceWallet?.walletType);
+  const tx = getCurrentStepTx(currentStep);
+  const isApproval = isApprovalCurrentStepTx(currentStep);
+
+  if (!tx || !tx.type) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Unexpected Error: tx is null!',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+
+  const hasAlreadyProceededToSign =
+    typeof swap.hasAlreadyProceededToSign === 'boolean';
+
+  if (isApproval) {
+    return new Ok({
+      nextStatus: undefined,
+      nextStepStatus: 'waitingForApproval',
+      details:
+        'Waiting for approve transaction to be mined and confirmed successfully',
+      message: `Waiting for approval of ${currentStep?.fromSymbol} coin ${
+        mobileWallet ? 'on your mobile phone!' : ''
+      }`,
+    });
+  } else if (hasAlreadyProceededToSign) {
+    return new Err({
+      message: 'Transaction is expired. Please try again.',
+      nextStepStatus: 'failed',
+      nextStatus: 'failed',
+      details: '',
+      errorCode: 'TX_EXPIRED',
+    });
+  }
+
+  return new Ok({
+    message: 'Executing transaction ...',
+    nextStepStatus: 'running',
+    nextStatus: 'running',
+    details: `${mobileWallet ? 'Check your mobile phone!' : ''}`,
+  });
+}
+
+export function onNextStateError(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>,
+  error: NextTransactionStateError
+) {
+  const { getStorage, setStorage } = actions;
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+  const isApproval = isApprovalCurrentStepTx(currentStep);
+
+  const hasAlreadyProceededToSign =
+    typeof swap.hasAlreadyProceededToSign === 'boolean';
+
+  const updatedResult = updateSwapStatus({
+    getStorage,
+    setStorage,
+
+    nextStepStatus: error.nextStepStatus,
+    nextStatus: error.nextStatus,
+    message: error.message,
+    details: error.details,
+    errorCode: error.errorCode,
+
+    hasAlreadyProceededToSign: isApproval
+      ? undefined
+      : hasAlreadyProceededToSign,
+  });
+
+  notifier({
+    event: {
+      type: StepEventType.FAILED,
+      reason: error.message,
+      reasonCode: updatedResult.failureType ?? DEFAULT_ERROR_CODE,
+      inputAmount: getLastFinishedStepInput(swap),
+      inputAmountUsd: getLastFinishedStepInputUsd(swap),
+    },
+    ...updatedResult,
+  });
+}
+
+export function onNextStateOk(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>,
+  ok: NextTransactionState
+) {
+  const { getStorage, setStorage } = actions;
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+  const isApproval = isApprovalCurrentStepTx(currentStep);
+
+  const hasAlreadyProceededToSign =
+    typeof swap.hasAlreadyProceededToSign === 'boolean';
+
+  const updateResult = updateSwapStatus({
+    getStorage,
+    setStorage,
+    nextStepStatus: ok.nextStepStatus,
+    nextStatus: ok.nextStatus,
+    message: ok.message,
+    details: ok.details,
+    hasAlreadyProceededToSign: isApproval
+      ? undefined
+      : hasAlreadyProceededToSign,
+  });
+
+  notifier({
+    event: {
+      type: StepEventType.TX_EXECUTION,
+      status: StepExecutionEventStatus.SEND_TX,
+    },
+    ...updateResult,
+  });
+}

package/src/actions/common/utils.ts

@@ -0,0 +1,25 @@
+import type {
+  SwapActionTypes,
+  SwapQueueContext,
+  SwapStorage,
+} from '../../types';
+import type {
+  BlockedReason,
+  ExecuterActions,
+} from '@rango-dev/queue-manager-core';
+
+export function isClaimedByCurrentQueue(context: SwapQueueContext): boolean {
+  return context.claimedBy === context._queue?.id;
+}
+
+export function requestBlockQueue(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>,
+  blockedFor: BlockedReason
+) {
+  actions.block(blockedFor);
+
+  const isClaimed = isClaimedByCurrentQueue(actions.context);
+  if (isClaimed && actions.context.resetClaimedBy) {
+    actions.context.resetClaimedBy();
+  }
+}

package/src/actions/createTransaction.ts

@@ -0,0 +1,117 @@
+import type { SwapQueueContext, SwapStorage } from '../types';
+import type { ExecuterActions } from '@rango-dev/queue-manager-core';
+import type { CreateTransactionRequest } from 'rango-sdk';
+
+import { warn } from '@rango-dev/logging-core';
+
+import {
+  createStepFailedEvent,
+  getCurrentStep,
+  getCurrentStepTx,
+  setCurrentStepTx,
+  throwOnOK,
+  updateSwapStatus,
+} from '../helpers';
+import { httpService } from '../services';
+import { notifier } from '../services/eventEmitter';
+import { prettifyErrorMessage } from '../shared-errors';
+import {
+  StepEventType,
+  StepExecutionEventStatus,
+  SwapActionTypes,
+} from '../types';
+
+/**
+ *
+ * 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 } = actions;
+  const swap = getStorage().swapDetails;
+
+  const currentStep = getCurrentStep(swap)!;
+  const transaction = getCurrentStepTx(currentStep);
+
+  if (!transaction) {
+    notifier({
+      event: {
+        type: StepEventType.TX_EXECUTION,
+        status: StepExecutionEventStatus.CREATE_TX,
+      },
+      swap,
+      step: currentStep,
+    });
+    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,
+        approve: true,
+      },
+    };
+    try {
+      // Getting transcation from server.
+
+      const { transaction } = await throwOnOK(
+        httpService().createTransaction(request)
+      );
+
+      if (transaction) {
+        setCurrentStepTx(currentStep, transaction);
+      }
+
+      setStorage({ ...getStorage(), swapDetails: swap });
+      schedule(SwapActionTypes.EXECUTE_TRANSACTION);
+      next();
+    } catch (error: unknown) {
+      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: 'FETCH_TX_FAILED',
+      });
+
+      const event = createStepFailedEvent(
+        swap,
+        extraMessage,
+        updateResult.failureType
+      );
+
+      notifier({
+        event,
+        ...updateResult,
+      });
+
+      if (error instanceof Error) {
+        warn(new Error('create transaction error'), {
+          tags: {
+            message: error.message,
+            requestBody: request,
+            reason: event.reason,
+            reasonCode: event.reasonCode,
+            pendingSwap: swap,
+          },
+        });
+      }
+
+      actions.failed();
+    }
+  }
+}

package/src/actions/executeTransaction/executeTransaction.ts

@@ -0,0 +1,107 @@
+import type {
+  SwapActionTypes,
+  SwapQueueContext,
+  SwapStorage,
+} from '../../types';
+import type { ExecuterActions } from '@rango-dev/queue-manager-core';
+import type { SignerFactory } from 'rango-types';
+
+import {
+  getCurrentStep,
+  getCurrentStepTx,
+  handleRejectedSign,
+  handleSuccessfulSign,
+  isApprovalCurrentStepTx,
+  resetNetworkStatus,
+} from '../../helpers';
+import { getCurrentAddressOf, getRelatedWallet } from '../../shared';
+import { checkEnvironmentBeforeExecuteTransaction } from '../common/checkEnvironmentBeforeExecuteTransaction';
+import {
+  onNextStateError,
+  onNextStateOk,
+  produceNextStateForTransaction,
+} from '../common/produceNextStateForTransaction';
+import { requestBlockQueue } from '../common/utils';
+
+/**
+ *
+ * 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 checkResult = await checkEnvironmentBeforeExecuteTransaction(actions);
+  if (checkResult.err) {
+    requestBlockQueue(actions, checkResult.val);
+    return;
+  }
+
+  resetNetworkStatus(actions);
+
+  // All the conditions are met. We can safely send the tx to wallet for sign.
+  const { failed, getStorage, context } = actions;
+  const { meta, getSigners } = context;
+
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+  const isApproval = isApprovalCurrentStepTx(currentStep);
+
+  const onFinish = () => {
+    // TODO resetClaimedBy is undefined here
+    if (actions.context.resetClaimedBy) {
+      actions.context.resetClaimedBy();
+    }
+  };
+
+  /*
+   * 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) {
+    onNextStateError(actions, nextStateResult.val);
+    failed();
+    onFinish();
+    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 tx = getCurrentStepTx(currentStep)!;
+
+  const sourceWallet = getRelatedWallet(swap, currentStep);
+  const walletAddress = getCurrentAddressOf(swap, currentStep);
+
+  const chainId = meta.blockchains?.[tx.blockChain]?.chainId;
+
+  let walletSigners: SignerFactory;
+  try {
+    walletSigners = await getSigners(sourceWallet.walletType);
+  } catch (error) {
+    handleRejectedSign(actions)(error);
+    onFinish();
+    return;
+  }
+
+  const signer = walletSigners.getSigner(tx.type);
+  await signer
+    .signAndSendTx(tx, walletAddress, chainId)
+    .then(
+      handleSuccessfulSign(actions, {
+        isApproval,
+      }),
+      handleRejectedSign(actions)
+    )
+    .finally(() => {
+      onFinish();
+    });
+}

package/src/actions/executeTransaction/index.ts

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

package/src/actions/scheduleNextStep.ts

@@ -0,0 +1,104 @@
+import type { SwapQueueContext, SwapStorage } from '../types';
+import type { ExecuterActions } from '@rango-dev/queue-manager-core';
+import type { PendingSwapStep } from 'rango-types';
+
+import {
+  getCurrentStep,
+  getLastFinishedStepInput,
+  getLastFinishedStepInputUsd,
+  getLastSuccessfulStep,
+  getLastSuccessfulStepOutputUsd,
+  isTxAlreadyCreated,
+} from '../helpers';
+import { notifier } from '../services/eventEmitter';
+import { StepEventType, SwapActionTypes } from '../types';
+
+/**
+ *
+ * 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,
+}: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>): void {
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap);
+  const isFailed = swap.steps.find(
+    (step: PendingSwapStep) => step.status === 'failed'
+  );
+
+  if (!!currentStep && !isFailed) {
+    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 });
+
+    notifier({
+      event: { type: StepEventType.STARTED },
+      swap,
+      step: currentStep,
+    });
+
+    schedule(SwapActionTypes.CREATE_TRANSACTION);
+    next();
+  } else {
+    swap.status = isFailed ? 'failed' : 'success';
+    swap.finishTime = new Date().getTime().toString();
+
+    setStorage({
+      ...getStorage(),
+      swapDetails: swap,
+    });
+
+    const inputAmount = getLastFinishedStepInput(swap);
+    const inputAmountUsd = getLastFinishedStepInputUsd(swap);
+
+    notifier({
+      ...(isFailed
+        ? {
+            event: {
+              type: StepEventType.FAILED,
+              reason: swap.extraMessage ?? undefined,
+              reasonCode: 'CALL_OR_SEND_FAILED',
+              inputAmount,
+              inputAmountUsd,
+            },
+          }
+        : {
+            event: {
+              type: StepEventType.SUCCEEDED,
+              inputAmount,
+              inputAmountUsd,
+              outputAmount:
+                getLastSuccessfulStep(swap.steps)?.outputAmount ?? '',
+              outputAmountUsd: getLastSuccessfulStepOutputUsd(swap),
+            },
+          }),
+      swap: swap,
+      step: null,
+    });
+
+    if (isFailed) {
+      failed();
+    } else {
+      next();
+    }
+  }
+}

package/src/actions/start.ts

@@ -0,0 +1,16 @@
+import { ExecuterActions } from '@rango-dev/queue-manager-core';
+import { StepEventType, SwapActionTypes, SwapStorage } from '../types';
+import { notifier } from '../services/eventEmitter';
+
+export function start({
+  schedule,
+  next,
+  getStorage,
+}: ExecuterActions<SwapStorage, SwapActionTypes>): void {
+  const swap = getStorage().swapDetails;
+
+  notifier({ event: { type: StepEventType.STARTED }, swap, step: null });
+
+  schedule(SwapActionTypes.SCHEDULE_NEXT_STEP);
+  next();
+}

package/src/configs.ts

@@ -0,0 +1,38 @@
+import type { RouteExecutionEvents } from './types';
+
+interface Emitter<Events extends Record<string, unknown>> {
+  emit<K extends keyof Events>(type: K, event: Events[K]): void;
+}
+
+export interface Configs {
+  API_KEY: string;
+  BASE_URL?: string;
+  emitter?: Emitter<RouteExecutionEvents>;
+}
+
+/*
+ * this API key is limited and
+ * it is only for test purpose
+ */
+
+const RANGO_PUBLIC_API_KEY = 'c6381a79-2817-4602-83bf-6a641a409e32';
+
+let configs: Configs = {
+  API_KEY: RANGO_PUBLIC_API_KEY,
+  BASE_URL: '',
+};
+
+export function getConfig<K extends keyof Configs>(name: K): Configs[K] {
+  return configs[name];
+}
+
+export function setConfig(name: keyof Configs, value: any) {
+  configs[name] = value;
+
+  return value;
+}
+
+export function initConfig(nextConfigs: Configs) {
+  configs = nextConfigs;
+  return configs;
+}

package/src/constants.ts

@@ -0,0 +1,18 @@
+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 your ${type ?? ''} wallet.`;
+export const ERROR_MESSAGE_WAIT_FOR_CHANGE_NETWORK = (
+  network: string | null
+): string => `Please change your network to ${network}.`;
+
+export const DEFAULT_ERROR_CODE = 'CLIENT_UNEXPECTED_BEHAVIOUR';