@rango-dev/queue-manager-rango-preset 0.60.1-next.2 → 0.60.1-next.5

package/src/actions/executeXrplTransaction/executeXrplTransaction.ts

@@ -5,14 +5,8 @@ import type {
 } from '../../types';
 import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
 import type { ExecuterActions } from '@rango-dev/queue-manager-core';
-import type {
-  GenericSigner,
-  XrplTransaction,
-  XrplTrustSetTransactionData,
-} from 'rango-types';
-
-import { isXrplTransaction } from 'rango-types';
-import { Err } from 'ts-results';
+import type { GenericSigner, XrplTransaction } from 'rango-types';
+import type { Err } from 'ts-results';
 
 import {
   getCurrentStep,
@@ -21,6 +15,10 @@ import {
   handleSuccessfulSign,
 } from '../../helpers';
 import { getCurrentAddressOf, getRelatedWallet } from '../../shared';
+import {
+  ensureXrplNamespaceExists,
+  ensureXrplTransactionIsValid,
+} from '../checkXrplTrustline';
 import { checkEnvironmentBeforeExecuteTransaction } from '../common/checkEnvironmentBeforeExecuteTransaction';
 import {
   onNextStateError,
@@ -29,12 +27,14 @@ import {
 } from '../common/produceNextStateForTransaction';
 import { requestBlockQueue } from '../common/utils';
 
-import { TRUST_LINE_AMOUNT } from './constants';
-import { extractFromSymbolAddress } 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);
@@ -46,6 +46,11 @@ export async function executeXrplTransaction(
 
   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();
@@ -63,152 +68,61 @@ export async function executeXrplTransaction(
    * It will either be Err, indicating process should stop, or Ok, indicating process should continue.
    */
   const nextStateResult = produceNextStateForTransaction(actions);
-  const tx = getCurrentStepTx(currentStep);
 
   if (nextStateResult.err) {
     handleErr(nextStateResult);
     return;
   }
 
-  // This has been checked inproduceNextStateForTransaction. Checking it in here would make it more resilient for future changes.
-  if (!tx) {
-    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);
 
-  if (!isXrplTransaction(tx)) {
-    handleErr(
-      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',
-      })
-    );
+  /*
+   *
+   * 2. Ensure tx is supported, and namespace exists.
+   *
+   */
+  const transaction = await ensureXrplTransactionIsValid(
+    currentTransactionFromStorage
+  );
+  if (transaction.err) {
+    handleErr(transaction);
     return;
   }
 
-  if (tx.data.TransactionType !== 'Payment') {
-    handleErr(
-      new Err({
-        nextStatus: 'failed',
-        nextStepStatus: 'failed',
-        message:
-          'Unexpected Error: We only support XRPL transactions with payment type',
-        details: undefined,
-        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
-      })
-    );
+  const namespace = await ensureXrplNamespaceExists(
+    context,
+    sourceWallet.walletType
+  );
+  if (namespace.err) {
+    handleErr(namespace);
     return;
   }
 
-  // On success, we should update Swap object and also call notifier
-  onNextStateOk(actions, nextStateResult.val);
-
-  const sourceWallet = getRelatedWallet(swap, currentStep);
-  const walletAddress = getCurrentAddressOf(swap, currentStep);
-
-  const chainId = meta.blockchains?.[tx.blockChain]?.chainId;
+  /*
+   *
+   * 3. Execute transaction
+   *
+   */
+  const chainId = meta.blockchains[transaction.val.blockChain]?.chainId;
   const walletSigners = await getSigners(sourceWallet.walletType);
 
-  const transactionQueue: XrplTransaction[] = [tx];
-
-  // null means it's native token (xrpl).
-  if (currentStep.toSymbolAddress) {
-    const [currency, account] = extractFromSymbolAddress(
-      currentStep.toSymbolAddress
-    );
-    if (!currency || !account) {
-      handleErr(
-        new Err({
-          nextStatus: 'failed',
-          nextStepStatus: 'failed',
-          message: 'Unexpected token format for XRPL transaction.',
-          details: undefined,
-          errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
-        })
-      );
-      return;
-    }
-
-    // We need to work with namespace instance
-    const provider = context.hubProvider(sourceWallet.walletType);
-    const xrplNamespace = provider.get('xrpl');
-    if (!xrplNamespace) {
-      handleErr(
-        new Err({
-          nextStatus: 'failed',
-          nextStepStatus: 'failed',
-          message: 'XRPL is not available on your wallet.',
-          details: undefined,
-          errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
-        })
-      );
-      return;
-    }
-
-    // Check if a trust line exists or not and also have capacity or not, if not, open a new one.
-
-    // 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 lines = await xrplNamespace.accountLines(sourceWallet.address, {
-      peer: account,
-    });
-    const isTruslineAlreadyOpened = lines.some((trustline) => {
-      return (
-        trustline.currency === currency &&
-        trustline.account === account &&
-        trustline.limit !== '0'
-      );
-    });
-
-    if (!isTruslineAlreadyOpened) {
-      const trustlineTx: XrplTrustSetTransactionData = {
-        TransactionType: 'TrustSet',
-        Account: tx.data.Account,
-        LimitAmount: {
-          currency: currency,
-          issuer: account,
-          value: TRUST_LINE_AMOUNT,
-        },
-      };
-
-      transactionQueue.unshift({
-        ...tx,
-        data: trustlineTx,
-      });
-    }
-  }
-
   const signer: GenericSigner<XrplTransaction> = walletSigners.getSigner(
-    tx.type
+    transaction.val.type
   );
 
-  for (const transaction of transactionQueue) {
-    try {
-      const result = await signer.signAndSendTx(
-        transaction,
-        walletAddress,
-        chainId
-      );
-
-      // TODO: approval has different meaning for EVM, we may need to add a third type called trustline for the following function.
-      handleSuccessfulSign(actions, {
-        isApproval: transaction.data.TransactionType === 'TrustSet',
-      })(result);
-    } catch (e) {
-      handleRejectedSign(actions)(e);
-      break;
-    }
+  try {
+    const result = await signer.signAndSendTx(
+      transaction.val,
+      walletAddress,
+      chainId
+    );
+
+    handleSuccessfulSign(actions, {
+      isApproval: transaction.val.data.TransactionType === 'TrustSet',
+    })(result);
+  } catch (e) {
+    handleRejectedSign(actions)(e);
   }
 
   // this works as `finally` for the iterator.

package/src/actions/scheduleNextStep.ts

@@ -39,7 +39,7 @@ export function scheduleNextStep({
   if (!!currentStep && !isFailed) {
     if (isTxAlreadyCreated(swap, currentStep)) {
       if (currentStep.fromBlockchain === TransactionType.XRPL) {
-        schedule(SwapActionTypes.EXECUTE_XRPL_TRANSACTION);
+        schedule(SwapActionTypes.CHECK_XRPL_TRUSTLINE);
       } else {
         schedule(SwapActionTypes.EXECUTE_TRANSACTION);
       }

package/src/configs.ts

@@ -1,5 +1,7 @@
 import type { RouteExecutionEvents } from './types';
 
+import { getApiKeyFromEnvOrNotSet } from './env';
+
 interface Emitter<Events extends Record<string, unknown>> {
   emit<K extends keyof Events>(type: K, event: Events[K]): void;
 }
@@ -10,15 +12,8 @@ export interface Configs {
   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,
+  API_KEY: getApiKeyFromEnvOrNotSet(),
   BASE_URL: '',
 };
 

package/src/env.ts

@@ -0,0 +1,28 @@
+export function getApiKeyFromEnv(): string | undefined {
+  // NOTE: parcel doesn't support for dynamic keys, so we have to do it statically.
+  return process.env.REACT_APP_RANGO_API_KEY;
+}
+
+/**
+ * This is useful when the api key is mandatory and nothing works corectly without api key.
+ * You need to first fallback to user's input (widget config), then you can use this to try to find from envs (e.g. widget/app or widget/playground)
+ * Then throw an runtime error to panic the program.
+ */
+export function getApiKeyFromEnvOrThrow() {
+  // NOTE: parcel doesn't support for dynamic keys, so we have to do it statically.
+  const value = getApiKeyFromEnv();
+  if (value) {
+    return value;
+  }
+
+  throw new Error(
+    'Ensure you have set REACT_APP_RANGO_API_KEY in your env variables.'
+  );
+}
+
+/**
+ * You can use this whenever you want to use the api key in initialize process, but mark the key explictly as not set to debug more easily since you should never reach there.
+ */
+export function getApiKeyFromEnvOrNotSet(): string {
+  return getApiKeyFromEnv() || 'NOT_SET';
+}

package/src/helpers.ts

@@ -213,6 +213,7 @@ export const setCurrentStepTx = (
   currentStep.tonTransaction = null;
   currentStep.suiTransaction = null;
   currentStep.xrplTransaction = null;
+  currentStep.stellarTransaction = null;
 
   const txType = transaction.type;
   switch (txType) {
@@ -255,6 +256,9 @@ export const setCurrentStepTx = (
     case TransactionType.XRPL:
       currentStep.xrplTransaction = transaction;
       break;
+    case TransactionType.STELLAR:
+      currentStep.stellarTransaction = transaction;
+      break;
     default:
       ((x: never) => {
         throw new Error(`${x} was unhandled!`);
@@ -1060,39 +1064,53 @@ export function isRequiredWalletConnected(
   return { ok: matched, reason: 'account_miss_match' };
 }
 
+export function updateStorageOnSuccessfulSign(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  signResult: { hash: string; response?: any },
+  data: { isApproval: boolean }
+) {
+  const { setTransactionDataByHash } = inMemoryTransactionsData();
+  const { getStorage, context } = actions;
+  const { meta } = context;
+  const swap = getStorage().swapDetails;
+
+  const currentStep = getCurrentStep(swap)!;
+
+  const currentStepNamespace = getCurrentNamespaceOf(swap, currentStep);
+  const explorerUrl = getScannerUrl(
+    signResult.hash,
+    currentStepNamespace.network,
+    meta.blockchains
+  );
+  setStepTransactionIds(
+    actions,
+    signResult.hash,
+    explorerUrl &&
+      (!signResult.response ||
+        (signResult.response && !signResult.response.hashRequiringUpdate))
+      ? {
+          url: explorerUrl,
+          description: data.isApproval ? 'Approve' : 'Swap',
+        }
+      : undefined
+  );
+  // response used for evm transactions to get receipt and track replaced
+  if (signResult.response) {
+    setTransactionDataByHash(signResult.hash, {
+      response: signResult.response,
+    });
+  }
+}
+
 export function handleSuccessfulSign(
   actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>,
   data: { isApproval: boolean }
 ) {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   return ({ hash, response }: { hash: string; response?: any }) => {
-    const { setTransactionDataByHash } = inMemoryTransactionsData();
-    const { getStorage, next, schedule, context } = actions;
-    const { meta } = context;
-    const swap = getStorage().swapDetails;
-
-    const currentStep = getCurrentStep(swap)!;
-
-    const currentStepNamespace = getCurrentNamespaceOf(swap, currentStep);
-    const explorerUrl = getScannerUrl(
-      hash,
-      currentStepNamespace.network,
-      meta.blockchains
-    );
-    setStepTransactionIds(
-      actions,
-      hash,
-      explorerUrl && (!response || (response && !response.hashRequiringUpdate))
-        ? {
-            url: explorerUrl,
-            description: data.isApproval ? 'Approve' : 'Swap',
-          }
-        : undefined
-    );
-    // response used for evm transactions to get receipt and track replaced
-    if (response) {
-      setTransactionDataByHash(hash, { response });
-    }
+    const { schedule, next } = actions;
+    updateStorageOnSuccessfulSign(actions, { hash, response }, data);
     schedule(SwapActionTypes.CHECK_TRANSACTION_STATUS);
     next();
   };

package/src/queueDef.ts

@@ -1,6 +1,7 @@
 import type { SwapQueueDef } from './types';
 
 import { checkStatus } from './actions/checkStatus';
+import { checkXrplTrustline } from './actions/checkXrplTrustline';
 import { createTransaction } from './actions/createTransaction';
 import { executeTransaction } from './actions/executeTransaction';
 import { executeXrplTransaction } from './actions/executeXrplTransaction';
@@ -28,6 +29,7 @@ export const swapQueueDef: SwapQueueDef = {
     [SwapActionTypes.CREATE_TRANSACTION]: createTransaction,
     [SwapActionTypes.EXECUTE_TRANSACTION]: executeTransaction,
     [SwapActionTypes.EXECUTE_XRPL_TRANSACTION]: executeXrplTransaction,
+    [SwapActionTypes.CHECK_XRPL_TRUSTLINE]: checkXrplTrustline,
     [SwapActionTypes.CHECK_TRANSACTION_STATUS]: checkStatus,
   },
   run: [SwapActionTypes.START],

package/src/shared.ts

@@ -119,6 +119,7 @@ export const getCurrentNamespaceOf = (
   const tonNetwork = step.tonTransaction?.blockChain;
   const suiNetwork = step.suiTransaction?.blockChain;
   const xrplNetwork = step.xrplTransaction?.blockChain;
+  const stellarNetwork = step.stellarTransaction?.blockChain;
 
   if (evmNetwork) {
     return {
@@ -160,6 +161,11 @@ export const getCurrentNamespaceOf = (
       namespace: 'XRPL',
       network: xrplNetwork,
     };
+  } else if (stellarNetwork) {
+    return {
+      namespace: 'Stellar',
+      network: stellarNetwork,
+    };
   } else if (!!step.transferTransaction) {
     const transferAddress = step.transferTransaction.fromWalletAddress;
     if (!transferAddress) {
@@ -239,6 +245,7 @@ export const getCurrentWalletTypeAndAddress = (
     swap.wallets[step.tonTransaction?.blockChain || ''] ||
     swap.wallets[step.suiTransaction?.blockChain || ''] ||
     swap.wallets[step.xrplTransaction?.blockChain || ''] ||
+    swap.wallets[step.stellarTransaction?.blockChain || ''] ||
     (step.transferTransaction?.fromWalletAddress
       ? {
           address: step.transferTransaction.fromWalletAddress,
@@ -472,6 +479,7 @@ export function calculatePendingSwap(params: {
           tonTransaction: null,
           suiTransaction: null,
           xrplTransaction: null,
+          stellarTransaction: null,
 
           // front fields
           hasAlreadyProceededToSign: false,

package/src/types.ts

@@ -44,6 +44,7 @@ export enum SwapActionTypes {
   CREATE_TRANSACTION = 'CREATE_TRANSACTION',
   EXECUTE_TRANSACTION = 'EXECUTE_TRANSACTION',
   EXECUTE_XRPL_TRANSACTION = 'EXECUTE_XRPL_TRANSACTION',
+  CHECK_XRPL_TRUSTLINE = 'CHECK_XRPL_TRUSTLINE',
   CHECK_TRANSACTION_STATUS = 'CHECK_TRANSACTION_STATUS',
 }