feat(sdk-core): add automatic signature cleanup for Express TSS signing

Fixes Express API gap where re-signing partially signed Full TxRequests
would fail. The /signtxtss route now automatically detects and cleans up
partial signature shares before attempting to sign.

Changes:
- Add ensureCleanSigSharesAndSignTransaction() to Wallet class
- Update Express handleV2SignTSSWalletTx() to use new method
- Add comprehensive unit tests for signature cleanup logic
- Check signature shares presence instead of transaction state

Benefits:
- Fixes re-signing failures for partially signed transactions
- Backward compatible with existing signing flows
- No API changes required
- Keeps tssUtils properly encapsulated

Ticket: COIN-5989

Author: dpkjnr

modules/bitgo/test/v2/unit/wallet.ts

@@ -3765,6 +3765,123 @@ describe('V2 Wallet:', function () {
       });
     });
 
+    describe('ensureCleanSigSharesAndSignTransaction', function () {
+      const exampleSignedTx = {
+        txHex: '0x123',
+        txid: '0x456',
+        status: 'signed',
+      };
+
+      const partiallySignedTxRequest: TxRequest = {
+        txRequestId: 'test-tx-id',
+        walletId: 'test-wallet-id',
+        walletType: 'hot',
+        version: 1,
+        state: 'initialized',
+        date: '2025-10-15',
+        userId: 'user-123',
+        intent: {},
+        policiesChecked: false,
+        unsignedTxs: [],
+        apiVersion: 'full',
+        latest: true,
+        transactions: [
+          {
+            state: 'pendingSignature',
+            unsignedTx: {
+              serializedTxHex: 'abc123',
+              signableHex: 'def456',
+              derivationPath: 'm/0',
+            },
+            signatureShares: [
+              {
+                from: 'user',
+                to: 'bitgo',
+                share: 'partial-share-data',
+              },
+            ],
+          },
+        ],
+      };
+
+      const cleanTxRequest: TxRequest = {
+        ...partiallySignedTxRequest,
+        transactions: [
+          {
+            state: 'initialized',
+            unsignedTx: {
+              serializedTxHex: 'abc123',
+              signableHex: 'def456',
+              derivationPath: 'm/0',
+            },
+            signatureShares: [],
+          },
+        ],
+      };
+
+      afterEach(async function () {
+        sandbox.restore();
+      });
+
+      it('should delete signature shares for partially signed Full TxRequest before signing', async function () {
+        const getTxRequestSpy = sandbox.stub(TssUtils.prototype, 'getTxRequest');
+        getTxRequestSpy.resolves(partiallySignedTxRequest);
+
+        const deleteSignatureSharesSpy = sandbox.stub(TssUtils.prototype, 'deleteSignatureShares');
+        deleteSignatureSharesSpy.resolves([]);
+
+        const signTransactionSpy = sandbox.stub(tssSolWallet, 'signTransaction');
+        signTransactionSpy.resolves(exampleSignedTx);
+
+        const signedTx = await tssSolWallet.ensureCleanSigSharesAndSignTransaction({
+          txRequestId: 'test-tx-id',
+          walletPassphrase: 'passphrase',
+        });
+
+        sandbox.assert.calledOnce(getTxRequestSpy);
+        sandbox.assert.calledOnce(deleteSignatureSharesSpy);
+        sandbox.assert.calledOnce(signTransactionSpy);
+        signedTx.should.deepEqual(exampleSignedTx);
+      });
+
+      it('should not delete signature shares for clean Full TxRequest', async function () {
+        const getTxRequestSpy = sandbox.stub(TssUtils.prototype, 'getTxRequest');
+        getTxRequestSpy.resolves(cleanTxRequest);
+
+        const deleteSignatureSharesSpy = sandbox.stub(TssUtils.prototype, 'deleteSignatureShares');
+
+        const signTransactionSpy = sandbox.stub(tssSolWallet, 'signTransaction');
+        signTransactionSpy.resolves(exampleSignedTx);
+
+        const signedTx = await tssSolWallet.ensureCleanSigSharesAndSignTransaction({
+          txRequestId: 'test-tx-id',
+          walletPassphrase: 'passphrase',
+        });
+
+        sandbox.assert.calledOnce(getTxRequestSpy);
+        sandbox.assert.notCalled(deleteSignatureSharesSpy);
+        sandbox.assert.calledOnce(signTransactionSpy);
+        signedTx.should.deepEqual(exampleSignedTx);
+      });
+
+      it('should sign transaction directly when no txRequestId provided', async function () {
+        const getTxRequestSpy = sandbox.stub(TssUtils.prototype, 'getTxRequest');
+        const deleteSignatureSharesSpy = sandbox.stub(TssUtils.prototype, 'deleteSignatureShares');
+
+        const signTransactionSpy = sandbox.stub(tssSolWallet, 'signTransaction');
+        signTransactionSpy.resolves(exampleSignedTx);
+
+        const signedTx = await tssSolWallet.ensureCleanSigSharesAndSignTransaction({
+          walletPassphrase: 'passphrase',
+        });
+
+        sandbox.assert.notCalled(getTxRequestSpy);
+        sandbox.assert.notCalled(deleteSignatureSharesSpy);
+        sandbox.assert.calledOnce(signTransactionSpy);
+        signedTx.should.deepEqual(exampleSignedTx);
+      });
+    });
+
     describe('Message Signing', function () {
       const txHash = '0xrrrsss1b';
       const messageRaw = 'hello world';

modules/express/src/clientRoutes.ts

@@ -499,8 +499,9 @@ export async function handleV2SignTSSWalletTx(req: ExpressApiRouteRequest<'expre
   const bitgo = req.bitgo;
   const coin = bitgo.coin(req.decoded.coin);
   const wallet = await coin.wallets().get({ id: req.decoded.id });
+
   try {
-    return await wallet.signTransaction(createTSSSendParams(req, wallet));
+    return await wallet.ensureCleanSigSharesAndSignTransaction(createTSSSendParams(req, wallet));
   } catch (error) {
     console.error('error while signing wallet transaction ', error);
     throw error;

modules/sdk-core/src/bitgo/wallet/wallet.ts

@@ -3566,6 +3566,48 @@ export class Wallet implements IWallet {
     return ret;
   }
 
+  /**
+   * Ensures signature shares are in a clean state before signing a transaction.
+   * Automatically detects if a TxRequest is a partially signed Full TxRequest and deletes stale signatures.
+   * Use this for Express API and other integrations that need automatic cleanup of partial signatures.
+   *
+   * @param params - signing options
+   * @returns signed transaction
+   */
+  public async ensureCleanSigSharesAndSignTransaction(
+    params: WalletSignTransactionOptions = {}
+  ): Promise<SignedTransaction | TxRequest> {
+    const txRequestId = params.txRequestId || params.txPrebuild?.txRequestId;
+
+    if (txRequestId && this.tssUtils && this.multisigType() === 'tss') {
+      const txRequest = await this.tssUtils.getTxRequest(txRequestId);
+
+      // Check if txRequest is Full (not Lite)
+      const isFull =
+        txRequest.apiVersion === 'full' ||
+        (txRequest.transactions?.length > 0) ||
+        (txRequest.messages?.length > 0);
+
+      if (isFull) {
+        // Check if there are any partial signature shares present
+        // Signature shares array is populated during signing and cleared when complete
+        let isPartiallySigned = false;
+
+        if (txRequest.transactions && txRequest.transactions.length > 0) {
+          isPartiallySigned = txRequest.transactions.some((tx) => (tx.signatureShares ?? []).length > 0);
+        } else if (txRequest.messages && txRequest.messages.length > 0) {
+          isPartiallySigned = txRequest.messages.some((msg) => (msg.signatureShares ?? []).length > 0);
+        }
+
+        if (isPartiallySigned) {
+          await this.tssUtils.deleteSignatureShares(txRequestId);
+        }
+      }
+    }
+
+    return this.signTransaction(params);
+  }
+
   /**
    * Signs a transaction from a TSS ECDSA wallet using external signer.
    *