Add callback for guarded transcations (#1701) (#1702)

* Add callback for guarded transcations

* Update changelog

* Remove log

* Fix ts-ignore

* Update tests

* Update type

* Update props

* Update readme

* Update

Author: mgavrila

CHANGELOG.md

@@ -5,7 +5,11 @@ All notable changes will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased] 
+## [Unreleased]
+
+## [[5.5.1](https://github.com/multiversx/mx-sdk-dapp/pull/1702)] - 2025-12-04
+
+- [Exposed setIsSigningUiEnabled and added callback for signTransactions](https://github.com/multiversx/mx-sdk-dapp/pull/1701)
 - [Extend tests for actions](https://github.com/multiversx/mx-sdk-dapp/pull/1699)
 - [Extended tests](https://github.com/multiversx/mx-sdk-dapp/pull/1698)
 - [IframeProviderStrategy tests](https://github.com/multiversx/mx-sdk-dapp/pull/1695)

README.md

@@ -5,7 +5,6 @@
 [![Integration tests](https://github.com/multiversx/mx-sdk-dapp/actions/workflows/run-template-dapps-integration.yml/badge.svg)](https://github.com/multiversx/mx-sdk-dapp/actions/workflows/run-template-dapps-integration.yml)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/multiversx/mx-sdk-dapp)
 
-
 MultiversX Front-End SDK for JavaScript and TypeScript (written in TypeScript).
 
 ## Introduction
@@ -304,6 +303,47 @@ const provider = getAccountProvider();
 const signedTransactions = await provider.signTransactions(transactions);
 ```
 
+#### 4.1.1 Signing Options
+
+The `signTransactions` method accepts an optional second parameter with signing options:
+
+```typescript
+import type { SignTransactionsOptionsType } from '@multiversx/sdk-dapp/out/providers/DappProvider/helpers/signTransactions/signTransactionsWithProvider';
+
+const options: SignTransactionsOptionsType = {
+  skipGuardian?: boolean;  // Skip guardian validation for guarded accounts
+  callback?: (signedTransactions: Transaction[]) => Promise<Transaction[]>; // Post-signing callback
+};
+
+const signedTransactions = await provider.signTransactions(transactions, options);
+```
+
+**Available options:**
+
+- `skipGuardian` (`boolean`): Optional. When `true`, skips the guardian co-signing step for guarded accounts. Useful for transactions that don't require guardian approval.
+
+- `callback` (`(signedTransactions: Transaction[]) => Promise<Transaction[]>`): Optional. A callback function that receives the signed transactions after all transactions have been signed by the user, but before guardian validation. This allows you to modify, filter, or perform additional processing on the signed transactions. The returned transactions will proceed to guardian validation (if applicable).
+
+**Example: Using the callback option**
+
+The `callback` option is particularly useful for:
+
+- **Guarded accounts**: Processing signed transactions before they are sent to the guardian service for co-signing
+- **Custom validation**: Adding additional validation logic after user signing
+- **Logging/Analytics**: Recording signed transactions before final submission
+
+```typescript
+const signedTransactions = await provider.signTransactions(transactions, {
+  callback: async (signedTxs) => {
+    // Example: Log signed transactions before guardian processing
+    console.log('User signed transactions:', signedTxs);
+
+    // Return the transactions to proceed with guardian validation
+    return signedTxs;
+  }
+});
+```
+
 #### 4.2 Sending and tracking transactions
 
 Then, to send the transactions, you need to use the `TransactionManager` class and pass in the `signedTransactions` to the `send` method. You can then track the transactions by using the `track` method. This will create a toast notification with the transaction hash and its status.
@@ -589,24 +629,27 @@ import { TransactionManagerTrackOptionsType } from '@multiversx/sdk-dapp/out/man
 
 const options: TransactionManagerTrackOptionsType = {
   disableToasts: false, // `false` by default
-  transactionsDisplayInfo: { // optional. If left `undefined`, it will use the default messages
+  transactionsDisplayInfo: {
+    // optional. If left `undefined`, it will use the default messages
     errorMessage: 'Failed adding stake',
     successMessage: 'Stake successfully added',
     receivedMessage: 'Stake successfully added', // optional, add it in case of multiple transactions
-    processingMessage: 'Staking in progress',
+    processingMessage: 'Staking in progress'
     // submittedMessage: 'Stake submitted',
-    // timedOutMessage: 'Transaction timed out', 
+    // timedOutMessage: 'Transaction timed out',
     // invalidMessage: 'Invalid transaction',
   },
   sessionInformation: {
     // `undefined` by default. Use to perform additional actions based on the session information
     stakeAmount: '1000000000000000000000000'
   },
-  onSuccess: async(sessionId) => { // optional
+  onSuccess: async (sessionId) => {
+    // optional
     // overrides the the global `onSuccess` callback set in the `initApp` method for the current session only
     console.log('Session successful', sessionId);
   },
-  onFail: async(sessionId) => { // optional
+  onFail: async (sessionId) => {
+    // optional
     console.log('Session failed', sessionId);
   }
 };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiversx/sdk-dapp",
-  "version": "5.5.0",
+  "version": "5.5.1",
   "description": "A library to hold the main logic for a dapp on the MultiversX blockchain",
   "author": "MultiversX",
   "license": "MIT",

src/providers/DappProvider/helpers/signTransactions/signTransactionsWithProvider.ts

@@ -15,6 +15,7 @@ import { computeNonces } from '../computeNonces/computeNonces';
 
 export type SignTransactionsOptionsType = {
   skipGuardian?: boolean;
+  callback?: (signedTransactions: Transaction[]) => Promise<Transaction[]>;
 };
 
 type SignTransactionsType = {
@@ -53,7 +54,7 @@ export async function signTransactionsWithProvider({
       : transactionsWithComputedNonce;
 
   const signedTransactions: Transaction[] =
-    (await provider.signTransactions(transactionsToSign)) ?? [];
+    (await provider.signTransactions(transactionsToSign, options)) ?? [];
 
   setAccountNonce(nonce + signedTransactions.length);
 

src/providers/strategies/BaseProviderStrategy/BaseProviderStrategy.ts

@@ -4,6 +4,7 @@ import { Transaction, Message } from 'lib/sdkCore';
 import { IDAppProviderOptions, IDAppProviderAccount } from 'lib/sdkDappUtils';
 import { PendingTransactionsEventsEnum } from 'managers/internal/PendingTransactionsStateManager';
 import { getAddress } from 'methods/account/getAddress';
+import { SignTransactionsOptionsType } from 'providers/DappProvider/helpers/signTransactions/signTransactionsWithProvider';
 import { IProvider, ProviderType } from 'providers/types/providerFactory.types';
 import { providerSettingsSelector } from 'store/selectors/configSelectors';
 import { getState } from 'store/store';
@@ -47,7 +48,7 @@ export abstract class BaseProviderStrategy<
 
   signTransaction(
     _transaction: Transaction,
-    _options?: IDAppProviderOptions
+    _options?: SignTransactionsOptionsType
   ): Promise<Transaction | null> {
     throw new Error('Method not implemented.');
   }

src/providers/strategies/CrossWindowProviderStrategy/CrossWindowProviderStrategy.ts

@@ -2,6 +2,7 @@ import { providerLabels } from 'constants/providerFactory.constants';
 import { Message, Transaction } from 'lib/sdkCore';
 import { IDAppProviderAccount } from 'lib/sdkDappUtils';
 import { CrossWindowProvider } from 'lib/sdkWebWalletCrossWindowProvider';
+import { SignTransactionsOptionsType } from 'providers/DappProvider/helpers/signTransactions/signTransactionsWithProvider';
 import {
   ProviderTypeEnum,
   ProviderType
@@ -11,7 +12,6 @@ import { getState } from 'store/store';
 import { ProviderErrorsEnum } from 'types/provider.types';
 import { BaseProviderStrategy } from '../BaseProviderStrategy/BaseProviderStrategy';
 import { signMessage } from '../helpers/signMessage/signMessage';
-import { guardTransactions } from '../helpers/signTransactions/helpers/guardTransactions/guardTransactions';
 
 type CrossWindowProviderProps = {
   address?: string;
@@ -76,7 +76,10 @@ export class CrossWindowProviderStrategy extends BaseProviderStrategy {
     this.provider.cancelAction();
   };
 
-  signTransactions = async (transactions: Transaction[]) => {
+  signTransactions = async (
+    transactions: Transaction[],
+    _options?: SignTransactionsOptionsType
+  ) => {
     if (!this.provider) {
       throw new Error(ProviderErrorsEnum.notInitialized);
     }
@@ -87,10 +90,7 @@ export class CrossWindowProviderStrategy extends BaseProviderStrategy {
       const signedTransactions: Transaction[] =
         (await this.provider.signTransactions(transactions)) ?? [];
 
-      const optionallyGuardedTransactions =
-        await guardTransactions(signedTransactions);
-
-      return optionallyGuardedTransactions;
+      return signedTransactions;
     } catch (error) {
       await onClose({ shouldCancelAction: true });
 

src/providers/strategies/CrossWindowProviderStrategy/tests/CrossWindowProviderStrategy.test.ts

@@ -143,21 +143,18 @@ describe('CrossWindowProviderStrategy tests', () => {
     expect(result).toBe(true);
   });
 
-  it('signTransactions resolves guarded transactions and closes UI', async () => {
+  it('signTransactions resolves signed transactions and closes UI', async () => {
     const handlers = buildHandlers();
     mockGetPendingTransactionsHandlers.mockResolvedValue(handlers);
     const signedTx = [{ hash: 'signed' } as any];
-    const guardedTx = [{ hash: 'guarded' } as any];
     mockCrossWindowProvider.signTransactions.mockResolvedValue(signedTx);
-    mockGuardTransactions.mockResolvedValue(guardedTx);
 
     const strategy = new CrossWindowProviderStrategy();
     const result = await strategy.signTransactions([{} as any]);
 
     expect(mockCrossWindowProvider.signTransactions).toHaveBeenCalled();
-    expect(mockGuardTransactions).toHaveBeenCalledWith(signedTx);
     expect(handlers.manager.closeUI).toHaveBeenCalled();
-    expect(result).toBe(guardedTx);
+    expect(result).toEqual(signedTx);
   });
 
   it('signTransactions cancels action on error', async () => {

src/providers/strategies/ExtensionProviderStrategy/ExtensionProviderStrategy.ts

@@ -2,6 +2,7 @@ import { ExtensionProvider } from '@multiversx/sdk-extension-provider/out/extens
 import { providerLabels } from 'constants/providerFactory.constants';
 import { Message, Transaction } from 'lib/sdkCore';
 import { IDAppProviderAccount } from 'lib/sdkDappUtils';
+import { SignTransactionsOptionsType } from 'providers/DappProvider/helpers/signTransactions/signTransactionsWithProvider';
 import {
   ProviderTypeEnum,
   ProviderType
@@ -58,7 +59,10 @@ export class ExtensionProviderStrategy extends BaseProviderStrategy {
     this.provider.cancelAction();
   };
 
-  signTransactions = async (transactions: Transaction[]) => {
+  signTransactions = async (
+    transactions: Transaction[],
+    _options?: SignTransactionsOptionsType
+  ) => {
     if (!this.provider) {
       throw new Error(ProviderErrorsEnum.notInitialized);
     }

src/providers/strategies/IframeProviderStrategy/IframeProviderStrategy.ts

@@ -2,6 +2,7 @@ import { providerLabels } from 'constants/providerFactory.constants';
 import { Message, Transaction } from 'lib/sdkCore';
 import { IDAppProviderAccount } from 'lib/sdkDappUtils';
 import { IframeProvider } from 'lib/sdkWebWalletIframeProvider';
+import { SignTransactionsOptionsType } from 'providers/DappProvider/helpers/signTransactions/signTransactionsWithProvider';
 import {
   ProviderTypeEnum,
   ProviderType
@@ -85,7 +86,10 @@ export class IframeProviderStrategy extends BaseProviderStrategy {
     this.provider.cancelAction();
   };
 
-  signTransactions = async (transactions: Transaction[]) => {
+  signTransactions = async (
+    transactions: Transaction[],
+    options?: SignTransactionsOptionsType
+  ) => {
     if (!this.provider) {
       throw new Error(ProviderErrorsEnum.notInitialized);
     }
@@ -95,7 +99,8 @@ export class IframeProviderStrategy extends BaseProviderStrategy {
     try {
       const signedTransactions = await signTransactions({
         transactions,
-        handleSign: this.provider.signTransactions.bind(this.provider)
+        handleSign: this.provider.signTransactions.bind(this.provider),
+        options
       });
 
       return signedTransactions;

src/providers/strategies/LedgerProviderStrategy/LedgerProviderStrategy.ts

@@ -5,6 +5,7 @@ import { Message, Transaction } from 'lib/sdkCore';
 import { IDAppProviderAccount } from 'lib/sdkDappUtils';
 import { LedgerConnectStateManager } from 'managers/internal/LedgerConnectStateManager/LedgerConnectStateManager';
 import { getIsLoggedIn } from 'methods/account/getIsLoggedIn';
+import { SignTransactionsOptionsType } from 'providers/DappProvider/helpers/signTransactions/signTransactionsWithProvider';
 import {
   ProviderTypeEnum,
   ProviderType
@@ -151,7 +152,10 @@ export class LedgerProviderStrategy extends BaseProviderStrategy {
     await ledgerConnectManager.init(anchor);
   };
 
-  signTransactions = async (transactions: Transaction[]) => {
+  signTransactions = async (
+    transactions: Transaction[],
+    options?: SignTransactionsOptionsType
+  ) => {
     if (!this.provider) {
       throw new Error(ProviderErrorsEnum.notInitialized);
     }
@@ -160,7 +164,8 @@ export class LedgerProviderStrategy extends BaseProviderStrategy {
 
     const signedTransactions = await signTransactions({
       transactions,
-      handleSign: this.provider.signTransactions.bind(this.provider)
+      handleSign: this.provider.signTransactions.bind(this.provider),
+      options
     });
 
     return signedTransactions;