test(sdk-coin-near): prebuildTransactionTxRequests

TICKET: WP-5782

Author: SimonVutovB

modules/sdk-coin-near/test/unit/tokenEnablementValidation.ts

@@ -11,6 +11,7 @@ describe('NEAR Token Enablement Validation', function () {
   let bitgo: TestBitGoAPI;
   let basecoin: Near;
   let wallet: Wallet;
+  let tssWallet: Wallet;
 
   before(function () {
     bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });
@@ -28,6 +29,18 @@ describe('NEAR Token Enablement Validation', function () {
       },
     };
     wallet = new Wallet(bitgo, basecoin, walletData);
+
+    const tssWalletData = {
+      id: '5b34252f1bf34993006eae97',
+      coin: 'tnear',
+      type: 'hot',
+      multisigType: 'tss',
+      keys: ['5b3424f91bf34993006eae94', '5b3424f91bf34993006eae95', '5b3424f91bf34993006eae96'],
+      coinSpecific: {
+        baseAddress: testData.accounts.account1.address,
+      },
+    };
+    tssWallet = new Wallet(bitgo, basecoin, tssWalletData);
   });
 
   const createValidTxParams = () => ({
@@ -421,4 +434,241 @@ describe('NEAR Token Enablement Validation', function () {
     result.failure.should.have.length(1);
     result.failure[0].message.should.containEql('transaction beneficiary mismatch with user expectation');
   });
+
+  describe('TSS Wallet Tests (prebuildTransactionTxRequests flow)', function () {
+    it('should properly validate token enablement through TSS wallet flow', async function () {
+      const bgUrl = common.Environments['test'].uri;
+
+      // Mock the /txrequests endpoint (used by TSS wallets)
+      const txRequestNock = nock(bgUrl)
+        .post(`/api/v2/wallet/${tssWallet.id()}/txrequests`)
+        .reply((uri, requestBody: any) => {
+          // Validate the request structure
+          requestBody.intent.should.have.property('intentType');
+          requestBody.intent.intentType.should.equal('enableToken');
+          requestBody.intent.should.have.property('enableTokens');
+          requestBody.intent.enableTokens.should.deepEqual([{ name: 'tnear:tnep24dp' }]);
+
+          return [
+            200,
+            {
+              txRequestId: 'test-request-id',
+              apiVersion: 'full',
+              transactions: [
+                {
+                  state: 'pending',
+                  unsignedTx: {
+                    serializedTxHex: testData.rawTx.selfStorageDeposit.unsigned,
+                    signableHex: testData.rawTx.selfStorageDeposit.unsigned,
+                    derivationPath: 'm/0',
+                    feeInfo: {
+                      fee: 1160407,
+                      feeString: '1160407',
+                    },
+                  },
+                  signatureShares: [],
+                },
+              ],
+            },
+          ];
+        });
+
+      const result = await tssWallet.buildTokenEnablements({
+        enableTokens: [
+          {
+            name: 'tnear:tnep24dp',
+          },
+        ],
+      });
+
+      txRequestNock.isDone().should.equal(true);
+      result.should.have.length(1);
+      result[0].should.have.property('txRequestId');
+      result[0].txRequestId!.should.equal('test-request-id');
+    });
+
+    it('should reject spoofed transaction in TSS wallet flow', async function () {
+      const bgUrl = common.Environments['test'].uri;
+
+      // Platform returns a fungible token transfer instead of storage deposit
+      const txRequestNock = nock(bgUrl)
+        .post(`/api/v2/wallet/${tssWallet.id()}/txrequests`)
+        .reply(200, {
+          txRequestId: 'test-request-id',
+          apiVersion: 'full',
+          transactions: [
+            {
+              state: 'pending',
+              unsignedTx: {
+                serializedTxHex: testData.rawTx.fungibleTokenTransfer.unsigned,
+                signableHex: testData.rawTx.fungibleTokenTransfer.unsigned,
+                derivationPath: 'm/0',
+                feeInfo: {
+                  fee: 1160407,
+                  feeString: '1160407',
+                },
+              },
+              signatureShares: [],
+            },
+          ],
+        });
+
+      const buildResult = await tssWallet.buildTokenEnablements({
+        enableTokens: [
+          {
+            name: 'tnear:tnep24dp',
+          },
+        ],
+      });
+
+      txRequestNock.isDone().should.equal(true);
+
+      // Now verify the transaction - it should fail validation
+      const txPrebuild = buildResult[0] as any;
+      const txParams = {
+        type: 'enabletoken' as const,
+        recipients: [
+          {
+            address: testData.accounts.account1.address,
+            amount: '0',
+            tokenName: 'tnear:tnep24dp',
+          },
+        ],
+      };
+
+      // For TSS, txHex is at the top level of prebuild result
+      const verifyOptions: VerifyTransactionOptions = {
+        txParams,
+        txPrebuild: txPrebuild,
+        wallet: tssWallet as any,
+        verification: { verifyTokenEnablement: true },
+        walletType: 'tss',
+      };
+
+      await basecoin
+        .verifyTransaction(verifyOptions)
+        .should.be.rejectedWith(/Invalid transaction type on token enablement/);
+    });
+
+    it('should detect wrong receiver contract in TSS wallet flow', async function () {
+      const bgUrl = common.Environments['test'].uri;
+
+      // Platform returns a regular transfer (wrong receiver)
+      const txRequestNock = nock(bgUrl)
+        .post(`/api/v2/wallet/${tssWallet.id()}/txrequests`)
+        .reply(200, {
+          txRequestId: 'test-request-id',
+          apiVersion: 'full',
+          transactions: [
+            {
+              state: 'pending',
+              unsignedTx: {
+                serializedTxHex: testData.rawTx.transfer.unsigned,
+                signableHex: testData.rawTx.transfer.unsigned,
+                derivationPath: 'm/0',
+                feeInfo: {
+                  fee: 1160407,
+                  feeString: '1160407',
+                },
+              },
+              signatureShares: [],
+            },
+          ],
+        });
+
+      const buildResult = await tssWallet.buildTokenEnablements({
+        enableTokens: [
+          {
+            name: 'tnear:tnep24dp',
+          },
+        ],
+      });
+
+      txRequestNock.isDone().should.equal(true);
+
+      // Verify should detect the wrong transaction
+      const txPrebuild = buildResult[0] as any;
+      const verifyOptions: VerifyTransactionOptions = {
+        txParams: {
+          type: 'enabletoken' as const,
+          recipients: [
+            {
+              address: testData.accounts.account1.address,
+              amount: '0',
+              tokenName: 'tnear:tnep24dp',
+            },
+          ],
+        },
+        txPrebuild: txPrebuild,
+        wallet: tssWallet as any,
+        verification: { verifyTokenEnablement: true },
+        walletType: 'tss',
+      };
+
+      await basecoin
+        .verifyTransaction(verifyOptions)
+        .should.be.rejectedWith(
+          /Invalid transaction type on token enablement|Error on token enablements: receiver contract mismatch/
+        );
+    });
+
+    it('should validate correct storage deposit in TSS wallet flow', async function () {
+      const bgUrl = common.Environments['test'].uri;
+
+      // Platform returns correct storage deposit transaction
+      const txRequestNock = nock(bgUrl)
+        .post(`/api/v2/wallet/${tssWallet.id()}/txrequests`)
+        .reply(200, {
+          txRequestId: 'test-request-id',
+          apiVersion: 'full',
+          transactions: [
+            {
+              state: 'pending',
+              unsignedTx: {
+                serializedTxHex: testData.rawTx.selfStorageDeposit.unsigned,
+                signableHex: testData.rawTx.selfStorageDeposit.unsigned,
+                derivationPath: 'm/0',
+                feeInfo: {
+                  fee: 1160407,
+                  feeString: '1160407',
+                },
+              },
+              signatureShares: [],
+            },
+          ],
+        });
+
+      const buildResult = await tssWallet.buildTokenEnablements({
+        enableTokens: [
+          {
+            name: 'tnear:tnep24dp',
+          },
+        ],
+      });
+
+      txRequestNock.isDone().should.equal(true);
+
+      // Verify should pass for valid transaction
+      const txPrebuild = buildResult[0] as any;
+      const verifyOptions: VerifyTransactionOptions = {
+        txParams: {
+          type: 'enabletoken' as const,
+          recipients: [
+            {
+              address: testData.accounts.account1.address,
+              amount: '0',
+              tokenName: 'tnear:tnep24dp',
+            },
+          ],
+        },
+        txPrebuild: txPrebuild,
+        wallet: tssWallet as any,
+        verification: { verifyTokenEnablement: true },
+        walletType: 'tss',
+      };
+
+      const result = await basecoin.verifyTransaction(verifyOptions);
+      result.should.equal(true);
+    });
+  });
 });