feat(web-client): modify XRP trustline user flow (#328)

* refactor(web-client): add optional 'flags' parameter to createUnsignedTrustSetTx

* fix(web-client): pause opportunistic XRPL token opt-in

* style(web-client): fix typo

* feat(web-client): add createTrustLine

* feat(web-client): default all XRPL Trustline opt-ins when deleting XRPL account

* fix(web-client): use absolute path instead of relative path

Author: billguo99

web-client/src/app/services/xrpl.service.ts

@@ -149,13 +149,18 @@ export class XrplService {
 
   async createUnsignedTrustSetTx(
     fromAddress: string,
-    limitAmount: IssuedCurrencyAmount
+    limitAmount: IssuedCurrencyAmount,
+    flags?: number | xrpl.TrustSetFlagsInterface
   ): Promise<xrpl.TrustSet> {
     const unpreparedTx: xrpl.TrustSet = {
       Account: fromAddress,
       TransactionType: 'TrustSet',
       LimitAmount: limitAmount,
     };
+    if (typeof flags !== 'undefined') {
+      unpreparedTx.Flags = flags;
+    }
+
     return await this.withConnection(
       async (client) => await client.autofill(unpreparedTx)
     );

web-client/src/app/state/session-xrpl.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core';
 import { firstValueFrom } from 'rxjs';
-import { EnclaveService } from 'src/app/services/enclave/index';
+import { EnclaveService } from 'src/app/services/enclave';
 import { XrplService } from 'src/app/services/xrpl.service';
 import {
   checkTxResponseSucceeded,
@@ -16,7 +16,7 @@ import { parseNumber } from 'src/app/utils/validators';
 import { ifDefined } from 'src/helpers/helpers';
 import { TransactionSigned, TransactionToSign } from 'src/schema/actions';
 import * as xrpl from 'xrpl';
-import { IssuedCurrencyAmount } from 'xrpl/dist/npm/models/common/index';
+import { IssuedCurrencyAmount } from 'xrpl/dist/npm/models/common';
 import { Trustline } from 'xrpl/dist/npm/models/methods/accountLines';
 import { ConnectorQuery } from './connector';
 import { SessionQuery } from './session.query';
@@ -206,7 +206,8 @@ export class SessionXrplService {
    * @see XrplService.createUnsignedTrustSetTx
    */
   async sendTrustSetTx(
-    limitAmount: IssuedCurrencyAmount
+    limitAmount: IssuedCurrencyAmount,
+    flags?: number | xrpl.TrustSetFlagsInterface
   ): Promise<xrpl.TxResponse> {
     const { wallet } = this.sessionQuery.assumeActiveSession();
 
@@ -215,7 +216,8 @@ export class SessionXrplService {
       async () =>
         await this.xrplService.createUnsignedTrustSetTx(
           wallet.xrpl_account.address_base58,
-          limitAmount
+          limitAmount,
+          flags
         ),
       { from: wallet.xrpl_account.address_base58, limitAmount }
     );
@@ -253,11 +255,11 @@ export class SessionXrplService {
       (await firstValueFrom(this.sessionQuery.xrplTrustlines)) ?? [];
 
     const txResponses: xrpl.TxResponse[] = [];
-    for (const trustLine of trustLines) {
-      ifDefined(await this.checkTrustlineOptIn(trustLine), (txResponse) =>
-        txResponses.push(txResponse)
-      );
-    }
+    // for (const trustLine of trustLines) {
+    //   ifDefined(await this.checkTrustlineOptIn(trustLine), (txResponse) =>
+    //     txResponses.push(txResponse)
+    //   );
+    // }
     return txResponses;
   }
 
@@ -318,6 +320,115 @@ export class SessionXrplService {
     }
   }
 
+  /**
+   * Helper: Create a trust line between active session's wallet and targeted account.
+   *
+   * This creates and sends a `TrustSet` transaction.
+   *
+   * @return the `TrustSet` response, or undefined
+   */
+  async createTrustline(
+    currency: string,
+    issuer: string,
+    value: string,
+    rippling: boolean
+  ): Promise<xrpl.TxResponse | undefined> {
+    const limitAmount = {
+      currency,
+      issuer,
+      value,
+    };
+
+    if (rippling) {
+      const enableRippling: xrpl.TrustSetFlagsInterface = {
+        tfClearNoRipple: true,
+      };
+      return await withLoggedExchange(
+        'SessionXrplService.createTrustline: sending TrustSet',
+        async () => await this.sendTrustSetTx(limitAmount, enableRippling),
+        limitAmount
+      );
+    }
+
+    return await withLoggedExchange(
+      'SessionXrplService.createTrustline: sending TrustSet',
+      async () => await this.sendTrustSetTx(limitAmount),
+      limitAmount
+    );
+  }
+
+  /**
+   * Default trustline opt-in for each of this account's trust lines.
+   *
+   * @return The responses to `TrustSet` transactions sent out (empty if none sent)
+   * @see defaultTrustlineOptIn
+   */
+  async defaultTrustlineOptIns(): Promise<xrpl.TxResponse[]> {
+    // TODO(Pi): Check for necessary owner reserves before sending.
+    //           See: https://xrpl.org/reserves.html
+
+    const trustLines =
+      (await firstValueFrom(this.sessionQuery.xrplTrustlines)) ?? [];
+
+    const txResponses: xrpl.TxResponse[] = [];
+    for (const trustLine of trustLines) {
+      ifDefined(await this.defaultTrustlineOptIn(trustLine), (txResponse) =>
+        txResponses.push(txResponse)
+      );
+    }
+    return txResponses;
+  }
+
+  /**
+   * Helper: Default trustline opt-in for the given trust-line.
+   *
+   * This sends a `TrustSet` transaction defaulting the limit to zero.
+   *
+   * @return the `TrustSet` response, or undefined
+   */
+  async defaultTrustlineOptIn(
+    trustline: Trustline
+  ): Promise<xrpl.TxResponse | undefined> {
+    const limit_peer = parseNumber(trustline.limit_peer);
+    if (limit_peer === undefined) {
+      throw panic(
+        'SessionXrplService.defaultTrustlineOptIn: bad limit_peer:',
+        trustline
+      );
+    }
+    if (limit_peer !== 0) {
+      throw panic(
+        'SessionXrplService.defaultTrustlineOptIn: limit_peer is not zero:',
+        trustline
+      );
+    }
+
+    const limit = parseNumber(trustline.limit);
+    if (limit === undefined) {
+      throw panic(
+        'SessionXrplService.defaultTrustlineOptIn: bad limit:',
+        trustline
+      );
+    }
+
+    if (0 < limit) {
+      const limitAmount = {
+        currency: trustline.currency,
+        issuer: trustline.account,
+        value: '0',
+      };
+      const defaultFlags: xrpl.TrustSetFlagsInterface = {
+        tfSetNoRipple: true,
+        tfClearFreeze: true,
+      };
+      return await withLoggedExchange(
+        'SessionXrplService.defaultTrustlineOptIn: sending TrustSet',
+        async () => await this.sendTrustSetTx(limitAmount, defaultFlags),
+        limitAmount
+      );
+    }
+  }
+
   protected async prepareUnsignedTransaction(
     receiverId: string,
     amount: xrpl.Payment['Amount']

web-client/src/app/views/delete-user/delete-user.page.ts

@@ -138,7 +138,7 @@ export class DeleteUserPage implements OnInit {
   async refreshWalletData(): Promise<void> {
     this.balancesIsLoading = true;
     try {
-      await withConsoleGroup('WalletPage.refreshWalletData:', async () => {
+      await withConsoleGroup('DeleteUserPage.refreshWalletData:', async () => {
         await withConsoleGroupCollapsed('Loading wallet data', async () => {
           await Promise.all([
             (async () => {
@@ -207,7 +207,7 @@ export class DeleteUserPage implements OnInit {
       });
       if (0 < unsuccessfulResponses.length) {
         console.log(
-          'DekewteUserPage.checkXrplTokenOptIns: unsuccessful responses:',
+          'DeleteUserPage.checkXrplTokenOptIns: unsuccessful responses:',
           { unsuccessfulResponses }
         );
         const errorMessage: string = unsuccessfulResponses

web-client/src/app/views/deposit-funds/deposit-funds.page.ts

@@ -4,6 +4,7 @@ import { LoadingController, NavController } from '@ionic/angular';
 import { checkTxResponseSucceeded } from 'src/app/services/xrpl.utils';
 import { SessionXrplService } from 'src/app/state/session-xrpl.service';
 import { SessionQuery } from 'src/app/state/session.query';
+import { withConsoleGroupCollapsed } from 'src/app/utils/console.helpers';
 import { withLoadingOverlayOpts } from 'src/app/utils/loading.helpers';
 import { SwalHelper } from 'src/app/utils/notification/swal-helper';
 import * as xrpl from 'xrpl';
@@ -39,6 +40,13 @@ export class DepositFundsPage implements OnInit {
   }
 
   async deleteWallet(): Promise<void> {
+    await withConsoleGroupCollapsed(
+      'Defaulting asset / token opt-ins',
+      async () => {
+        await this.defaultXrplTokenOptIns();
+      }
+    );
+
     if (this.receiverAddress) {
       const result = await withLoadingOverlayOpts<
         { xrplResult: TxResponse } | undefined
@@ -54,6 +62,43 @@ export class DepositFundsPage implements OnInit {
     }
   }
 
+  protected async defaultXrplTokenOptIns(): Promise<void> {
+    if (this.sessionQuery.hasXrpBalance()) {
+      const txResponses =
+        await this.sessionXrplService.defaultTrustlineOptIns();
+      const unsuccessfulResponses = txResponses.filter((txResponse) => {
+        const { succeeded } = checkTxResponseSucceeded(txResponse);
+        return !succeeded;
+      });
+      if (0 < unsuccessfulResponses.length) {
+        console.log(
+          'DepositFundsPage.defaultXrplTokenOptIns: unsuccessful responses:',
+          { unsuccessfulResponses }
+        );
+        const errorMessage: string = unsuccessfulResponses
+          .map((txResponse) => {
+            const { resultCode } = checkTxResponseSucceeded(txResponse);
+            return resultCode;
+          })
+          .join('\n');
+        await this.errorNotification('XRPL token opt-out failed', errorMessage);
+      }
+    }
+  }
+
+  protected async errorNotification(
+    titleText: string,
+    err: any
+  ): Promise<void> {
+    const text = err?.response?.body?.message ?? err?.response?.body ?? err;
+    console.error('DepositFundsPage.withAlertErrors caught', { err });
+    await this.notification.swal.fire({
+      icon: 'error',
+      titleText,
+      text,
+    });
+  }
+
   protected async deleteByLedgerType(
     receiverAddress: string
   ): Promise<{ xrplResult: TxResponse }> {