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

package/src/actions/checkStellarTrustline/checkStellarTrustline.ts

@@ -0,0 +1,237 @@
+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,
+  StellarChangeTrustLinePrerequisite,
+  StellarChangeTrustLinePrerequisiteResult,
+  StellarTransaction,
+} from 'rango-types';
+
+import { STELLAR_CHANGE_TRUSTLINE_TYPE, TransactionType } from 'rango-types';
+import { Err } from 'ts-results';
+
+import {
+  getCurrentStep,
+  getCurrentStepTx,
+  handleRejectedSign,
+  updateStorageWithPrerequisiteResult,
+} from '../../helpers';
+import { SwapActionTypes } from '../../types';
+import { onNextStateError } from '../common/produceNextStateForTransaction';
+import { requestBlockQueue } from '../common/utils';
+
+import {
+  checkIfTrustLineIsAlreadyOpened,
+  createTrustLineTransaction,
+  ensureRequiredStellarWalletIsConnected,
+  ensureStellarNamespaceExists,
+  getStellarWalletFromSwap,
+} from './utils';
+
+export async function checkStellarTrustline(
+  actions: ExecuterActions<SwapStorage, SwapActionTypes, SwapQueueContext>
+): Promise<void> {
+  const { failed, context, schedule, getStorage, next } = actions;
+  const { meta, getSigners } = context;
+
+  const onFinish = () => {
+    if (actions.context.resetClaimedBy) {
+      actions.context.resetClaimedBy();
+    }
+  };
+
+  const scheduleCheckPrerequisites = () => {
+    schedule(SwapActionTypes.CHECK_PREREQUISITES);
+    next();
+    onFinish();
+  };
+
+  const handleErr = (err: Err<NextTransactionStateError>) => {
+    onNextStateError(actions, err.val);
+    failed();
+    onFinish();
+  };
+
+  /*
+   *
+   * 1. Ensure transaction is available.
+   *
+   */
+  const swap = getStorage().swapDetails;
+  const currentStep = getCurrentStep(swap)!;
+  const currentTransactionFromStorage = getCurrentStepTx(currentStep);
+
+  if (!currentTransactionFromStorage) {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: 'Unexpected Error: tx is null!',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
+    return;
+  }
+
+  /*
+   *
+   * 2. Check if there is a prerequisite with STELLAR_CHANGE_TRUSTLINE_TYPE that does not have any result.
+   *
+   */
+  let unmetStellarChangeTrustLineMeta: {
+    prerequisite: StellarChangeTrustLinePrerequisite;
+    prerequisiteIndex: number;
+  } | null = null;
+
+  for (
+    let prerequisiteIndex = 0;
+    prerequisiteIndex < currentTransactionFromStorage.prerequisites.length;
+    prerequisiteIndex++
+  ) {
+    const prerequisite =
+      currentTransactionFromStorage.prerequisites[prerequisiteIndex];
+    if (prerequisite.type === STELLAR_CHANGE_TRUSTLINE_TYPE) {
+      const prerequisiteResult = currentStep.prerequisiteResults.find(
+        (
+          prerequisiteResult
+        ): prerequisiteResult is StellarChangeTrustLinePrerequisiteResult =>
+          prerequisiteResult.prerequisiteIndex === prerequisiteIndex &&
+          prerequisiteResult.prerequisiteType === STELLAR_CHANGE_TRUSTLINE_TYPE
+      );
+
+      if (!prerequisiteResult) {
+        unmetStellarChangeTrustLineMeta = {
+          prerequisite,
+          prerequisiteIndex,
+        };
+        break;
+      }
+    }
+  }
+
+  if (!unmetStellarChangeTrustLineMeta) {
+    scheduleCheckPrerequisites();
+    return;
+  }
+
+  /*
+   *
+   * 3. Ensure Stellar wallet is connected.
+   *
+   */
+
+  const stellarWallet = getStellarWalletFromSwap(swap);
+  if (!stellarWallet) {
+    handleErr(
+      new Err({
+        nextStatus: 'failed',
+        nextStepStatus: 'failed',
+        message: 'Unexpected Error: Stellar wallet was not found in the swap!',
+        details: undefined,
+        errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+      })
+    );
+    return;
+  }
+
+  const namespace = await ensureStellarNamespaceExists(
+    context,
+    stellarWallet.type
+  );
+  if (namespace.err) {
+    handleErr(namespace);
+    return;
+  }
+
+  const ensureRequiredStellarWalletIsConnectedResult =
+    await ensureRequiredStellarWalletIsConnected(actions, stellarWallet);
+
+  if (ensureRequiredStellarWalletIsConnectedResult.err) {
+    requestBlockQueue(
+      actions,
+      ensureRequiredStellarWalletIsConnectedResult.val
+    );
+    return;
+  }
+
+  /*
+   *
+   * 3. Check if trust line is already opened.
+   *
+   */
+
+  const token: TargetToken = {
+    code: unmetStellarChangeTrustLineMeta.prerequisite.code,
+    issuer: unmetStellarChangeTrustLineMeta.prerequisite.issuer,
+    value: unmetStellarChangeTrustLineMeta.prerequisite.value,
+  };
+
+  const trustLineIsAlreadyOpenedResult = await checkIfTrustLineIsAlreadyOpened(
+    unmetStellarChangeTrustLineMeta.prerequisite.wallet,
+    token,
+    {
+      namespace: namespace.val,
+    }
+  );
+
+  if (trustLineIsAlreadyOpenedResult.err) {
+    handleErr(trustLineIsAlreadyOpenedResult);
+    return;
+  }
+
+  if (trustLineIsAlreadyOpenedResult.val.trustLineIsAlreadyOpened) {
+    const prerequisiteResult: StellarChangeTrustLinePrerequisiteResult = {
+      prerequisiteIndex: unmetStellarChangeTrustLineMeta.prerequisiteIndex,
+      prerequisiteType: STELLAR_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 = await createTrustLineTransaction(
+      unmetStellarChangeTrustLineMeta.prerequisite.wallet,
+      token
+    );
+
+    const chainId = meta.blockchains['Stellar']?.chainId;
+    const walletSigners = await getSigners(stellarWallet.type);
+    const signer: GenericSigner<StellarTransaction> = walletSigners.getSigner(
+      TransactionType.STELLAR
+    );
+
+    const transactionResult = await signer.signAndSendTx(
+      trustlineTransaction,
+      stellarWallet.address,
+      chainId
+    );
+
+    const prerequisiteResult: StellarChangeTrustLinePrerequisiteResult = {
+      prerequisiteIndex: unmetStellarChangeTrustLineMeta.prerequisiteIndex,
+      prerequisiteType: STELLAR_CHANGE_TRUSTLINE_TYPE,
+      status: 'success',
+      data: {
+        executedTransactionHash: transactionResult.hash,
+      },
+    };
+
+    updateStorageWithPrerequisiteResult(actions, prerequisiteResult);
+    scheduleCheckPrerequisites();
+  } catch (e) {
+    handleRejectedSign(actions)(e);
+    onFinish();
+  }
+}

package/src/actions/checkStellarTrustline/constants.ts

@@ -0,0 +1 @@
+export const TRUST_LINE_INFINITE_VALUE = '922337203685.4775807'; // https://stellar-sdk.readthedocs.io/en/stable/_modules/stellar_sdk/operation/change_trust.html

package/src/actions/checkStellarTrustline/index.ts

@@ -0,0 +1,6 @@
+export { checkStellarTrustline } from './checkStellarTrustline.js';
+export {
+  ensureRequiredStellarWalletIsConnected,
+  ensureStellarNamespaceExists,
+  getStellarWalletFromSwap,
+} from './utils.js';

package/src/actions/checkStellarTrustline/types.ts

@@ -0,0 +1,9 @@
+import type { ProxiedNamespace } from '@rango-dev/wallets-core';
+import type { StellarActions } from '@rango-dev/wallets-core/namespaces/stellar';
+
+export type StellarNamespace = ProxiedNamespace<StellarActions>;
+export type TargetToken = {
+  code: string;
+  issuer: string;
+  value: string;
+};

package/src/actions/checkStellarTrustline/utils.ts

@@ -0,0 +1,200 @@
+import type { StellarNamespace, TargetToken } from './types';
+import type { TargetNamespace } from '../../shared';
+import type { NextTransactionStateError } from '../common/produceNextStateForTransaction';
+import type {
+  BlockedReason,
+  ExecuterActions,
+} from '@rango-dev/queue-manager-core';
+import type { WalletType } from '@rango-dev/wallets-shared';
+import type { PendingSwap, StellarTransaction } from 'rango-types';
+import type { Result } from 'ts-results';
+
+import { legacyReadAccountAddress as readAccountAddress } from '@rango-dev/wallets-core/legacy';
+import * as StellarSdk from '@stellar/stellar-sdk';
+import BigNumber from 'bignumber.js';
+import { TransactionType } from 'rango-types';
+import { Err, Ok } from 'ts-results';
+
+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';
+
+import { TRUST_LINE_INFINITE_VALUE } from './constants';
+
+export async function ensureStellarNamespaceExists(
+  context: SwapQueueContext,
+  walletType: string
+): Promise<Result<StellarNamespace, NextTransactionStateError>> {
+  // We need to work with namespace instance
+  const provider = context.hubProvider(walletType);
+  const stellarNamespace = provider.get('stellar');
+  if (!stellarNamespace) {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Stellar is not available on your wallet.',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+  return Ok(stellarNamespace);
+}
+
+export async function checkIfTrustLineIsAlreadyOpened(
+  account: string,
+  token: TargetToken,
+  options: { namespace: StellarNamespace }
+): Promise<
+  Result<{ trustLineIsAlreadyOpened: boolean }, NextTransactionStateError>
+> {
+  try {
+    // Get account lines for the account
+    const accountLines = await options.namespace.balanceLines(account);
+
+    // Find the target account line
+    const targetAccountLine = accountLines
+      .filter(
+        (accountLine) =>
+          accountLine.asset_type !== 'native' &&
+          accountLine.asset_type !== 'liquidity_pool_shares'
+      )
+      .find(
+        (accountLine) =>
+          accountLine.asset_code === token.code &&
+          accountLine.asset_issuer === token.issuer
+      );
+
+    // 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
+     * TODO: we can add some logic to check if the target limit has enough capacity to hold the token amount,
+     * but it needs that we always get the correct needed limit value in prerequisites
+     */
+    return new Ok({
+      trustLineIsAlreadyOpened: lineLimit.gte(targetLimit),
+    });
+  } catch {
+    return new Err({
+      nextStatus: 'failed',
+      nextStepStatus: 'failed',
+      message: 'Could not get account lines from Stellar.',
+      details: undefined,
+      errorCode: 'CLIENT_UNEXPECTED_BEHAVIOUR',
+    });
+  }
+}
+
+export function createTrustLineTransaction(
+  _accountId: string,
+  token: TargetToken
+): StellarTransaction {
+  const asset = new StellarSdk.Asset(token.code, token.issuer);
+  const TRUST_LINE_FEE = '100';
+  const TRUST_LINE_TIMEOUT = 30;
+  // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+  const now = Math.floor(Date.now() / 1000);
+
+  const operation = StellarSdk.Operation.changeTrust({
+    asset,
+    limit: TRUST_LINE_INFINITE_VALUE,
+  });
+
+  return {
+    type: TransactionType.STELLAR,
+    blockChain: 'Stellar',
+    prerequisites: [],
+    data: {
+      baseFee: TRUST_LINE_FEE,
+      memoXdrBase64: null,
+      preconditions: {
+        timeBounds: {
+          minTime: 0,
+          maxTime: now + TRUST_LINE_TIMEOUT,
+        },
+        ledgerBounds: { minLedger: 0, maxLedger: 0 },
+        minSeqNumber: null,
+        minSeqAge: null,
+        minSeqLedgerGap: null,
+        extraSigners: null,
+      },
+      operationsXdrBase64: [operation.toXDR('base64')],
+    },
+  };
+}
+
+export function getStellarWalletFromSwap(swap: PendingSwap): {
+  type: WalletType;
+  namespace: TargetNamespace;
+  address: string;
+} | null {
+  const stellarWallet = swap.wallets['STELLAR'];
+
+  if (!stellarWallet) {
+    return null;
+  }
+
+  return {
+    type: stellarWallet.walletType,
+    namespace: {
+      namespace: 'Stellar',
+      network: 'Stellar',
+    },
+    address: stellarWallet.address,
+  };
+}
+
+export async function ensureRequiredStellarWalletIsConnected(
+  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);
+}