Merge pull request #5100 from BitGo/WIN-3761

feat(sdk-coin-xrp): add support for token enablement

Author: hitansh-madan

modules/sdk-coin-xrp/src/lib/iface.ts

@@ -83,6 +83,7 @@ export interface SupplementGenerateWalletOptions {
 export type TransactionExplanation =
   | BaseTransactionExplanation
   | AccountSetTransactionExplanation
+  | TrustSetTransactionExplanation
   | SignerListSetTransactionExplanation;
 
 export interface AccountSetTransactionExplanation extends BaseTransactionExplanation {
@@ -92,6 +93,15 @@ export interface AccountSetTransactionExplanation extends BaseTransactionExplana
   };
 }
 
+export interface TrustSetTransactionExplanation extends BaseTransactionExplanation {
+  account: string;
+  limitAmount: {
+    currency: string;
+    issuer: string;
+    value: string;
+  };
+}
+
 export interface SignerListSetTransactionExplanation extends BaseTransactionExplanation {
   signerListSet: {
     signerQuorum: number;

modules/sdk-coin-xrp/src/xrp.ts

@@ -16,10 +16,11 @@ import {
   ParsedTransaction,
   ParseTransactionOptions,
   promiseProps,
+  TokenEnablementConfig,
   UnexpectedAddressError,
   VerifyTransactionOptions,
 } from '@bitgo/sdk-core';
-import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
+import { BaseCoin as StaticsBaseCoin, coins, XrpCoin } from '@bitgo/statics';
 import * as rippleBinaryCodec from 'ripple-binary-codec';
 import * as rippleKeypairs from 'ripple-keypairs';
 import * as xrpl from 'xrpl';
@@ -107,6 +108,13 @@ export class Xrp extends BaseCoin {
     return this.bitgo.get(this.url('/public/feeinfo')).result();
   }
 
+  public getTokenEnablementConfig(): TokenEnablementConfig {
+    return {
+      requiresTokenEnablement: true,
+      supportsMultipleTokenEnablements: false,
+    };
+  }
+
   /**
    * Assemble keychain and half-sign prebuilt transaction
    * @param params
@@ -222,6 +230,35 @@ export class Xrp extends BaseCoin {
           setFlag: transaction.SetFlag,
         },
       };
+    } else if (transaction.TransactionType === 'TrustSet') {
+      return {
+        displayOrder: [
+          'id',
+          'outputAmount',
+          'changeAmount',
+          'outputs',
+          'changeOutputs',
+          'fee',
+          'account',
+          'limitAmount',
+        ],
+        id: id,
+        changeOutputs: [],
+        outputAmount: 0,
+        changeAmount: 0,
+        outputs: [],
+        fee: {
+          fee: transaction.Fee,
+          feeRate: undefined,
+          size: txHex.length / 2,
+        },
+        account: transaction.Account,
+        limitAmount: {
+          currency: transaction.LimitAmount.currency,
+          issuer: transaction.LimitAmount.issuer,
+          value: transaction.LimitAmount.value,
+        },
+      };
     }
 
     const address =
@@ -254,6 +291,7 @@ export class Xrp extends BaseCoin {
    * @returns {boolean}
    */
   public async verifyTransaction({ txParams, txPrebuild }: VerifyTransactionOptions): Promise<boolean> {
+    const coinConfig = coins.get(this.getChain()) as XrpCoin;
     const explanation = await this.explainTransaction({
       txHex: txPrebuild.txHex,
     });
@@ -270,10 +308,34 @@ export class Xrp extends BaseCoin {
       return amount1.toFixed() === amount2.toFixed();
     };
 
-    if (!comparator(output, expectedOutput)) {
+    if ((txParams.type === undefined || txParams.type === 'payment') && !comparator(output, expectedOutput)) {
       throw new Error('transaction prebuild does not match expected output');
     }
 
+    if (txParams.type === 'enabletoken') {
+      if (txParams.recipients?.length !== 1) {
+        throw new Error('Only one recipient is allowed.');
+      }
+      const recipient = txParams.recipients[0];
+      if (!recipient.tokenName) {
+        throw new Error('Recipient must include a token name.');
+      }
+      const recipientCurrency = utils.getXrpCurrencyFromTokenName(recipient.tokenName).currency;
+      if (coinConfig.isToken) {
+        if (recipientCurrency !== coinConfig.currencyCode) {
+          throw new Error('Incorrect token name specified in recipients');
+        }
+      }
+      if (!('account' in explanation) || !('limitAmount' in explanation) || !explanation.limitAmount.currency) {
+        throw new Error('Explanation is missing required keys (account or limitAmount with currency)');
+      }
+      const baseAddress = explanation.account;
+      const currency = explanation.limitAmount.currency;
+
+      if (recipient.address !== baseAddress || recipientCurrency !== currency) {
+        throw new Error('Tx outputs does not match with expected txParams recipients');
+      }
+    }
     return true;
   }
 

modules/sdk-coin-xrp/test/unit/xrp.ts

@@ -10,6 +10,8 @@ import assert from 'assert';
 import * as rippleBinaryCodec from 'ripple-binary-codec';
 import sinon from 'sinon';
 import * as testData from '../resources/xrp';
+import * as _ from 'lodash';
+import { XrpToken } from '../../src';
 
 nock.disableNetConnect();
 
@@ -18,10 +20,15 @@ bitgo.safeRegister('txrp', Txrp.createInstance);
 
 describe('XRP:', function () {
   let basecoin;
+  let token;
 
   before(function () {
+    XrpToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+      bitgo.safeRegister(name, coinConstructor);
+    });
     bitgo.initializeTestVars();
     basecoin = bitgo.coin('txrp');
+    token = bitgo.coin('txrp:rlusd');
   });
 
   after(function () {
@@ -294,4 +301,71 @@ describe('XRP:', function () {
       );
     });
   });
+
+  describe('Verify Transaction', () => {
+    let newTxPrebuild;
+
+    const txPrebuild = {
+      txHex: `{"TransactionType":"TrustSet","Account":"rBSpCz8PafXTJHppDcNnex7dYnbe3tSuFG","LimitAmount":{"currency":"524C555344000000000000000000000000000000","issuer":"rnox8i6h9GoAbuwr73JtaDxXoncLLUCpXH","value":"1000000000"},"Flags":2147483648,"Fee":"45","Sequence":7}`,
+    };
+
+    before(function () {
+      newTxPrebuild = () => {
+        return _.cloneDeep(txPrebuild);
+      };
+    });
+
+    it('should verify token trustline transactions', async function () {
+      const txPrebuild = newTxPrebuild();
+
+      const txParams = {
+        recipients: [
+          {
+            address: 'rBSpCz8PafXTJHppDcNnex7dYnbe3tSuFG',
+            amount: '0',
+            tokenName: 'txrp:rlusd',
+          },
+        ],
+        type: 'enabletoken',
+      };
+
+      const validTransaction = await token.verifyTransaction({
+        txParams,
+        txPrebuild,
+      });
+      validTransaction.should.equal(true);
+    });
+
+    it('should fail verify trustline transaction with mismatch recipients', async function () {
+      const txPrebuild = newTxPrebuild();
+      const txParams = {
+        recipients: [
+          {
+            address: 'rBSpCz8PafXTJHppDadfaex7dYnbe3tSuFG',
+            amount: '0',
+            tokenName: 'txrp:rlusd',
+          },
+        ],
+        type: 'enabletoken',
+      };
+      await token
+        .verifyTransaction({ txParams, txPrebuild })
+        .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');
+    });
+
+    it('should fail to verify trustline transaction with incorrect token name', async function () {
+      const txPrebuild = newTxPrebuild();
+      const txParams = {
+        recipients: [
+          {
+            address: 'rBSpCz8PafXTJHppDcNnex7dYnbe3tSuFG',
+            amount: '0',
+            tokenName: 'txrp:usd',
+          },
+        ],
+        type: 'enabletoken',
+      };
+      await token.verifyTransaction({ txParams, txPrebuild }).should.be.rejectedWith('txrp:usd is not supported');
+    });
+  });
 });