feat(sdk-core): add isEddsaMpcV1SigningMaterial format detector

Export `isEddsaMpcV1SigningMaterial` from eddsaMPCv2.ts. The function
decrypts an SJCL-encrypted keycard and checks for the structural shape
of MPCv1 SigningMaterial (UShare.seed + at least one YShare.u). Returns
false on any error so callers can safely branch to the MPCv2 path.

Ticket: WCI-395
Session-Id: 4e39e4ea-4b1c-4f26-820d-5fa89c3edaf0
Task-Id: 1bc00d11-03ef-40b9-a964-9365fd15b62a

Author: Marzooqa

modules/sdk-core/src/bitgo/utils/tss/eddsa/eddsaMPCv2.ts

@@ -1,4 +1,5 @@
 import assert from 'assert';
+import * as sjcl from '@bitgo/sjcl';
 import * as pgp from 'openpgp';
 import { NonEmptyString } from 'io-ts-types';
 import {
@@ -43,6 +44,34 @@ import {
 import { BaseEddsaUtils } from './base';
 import { EddsaMPCv2KeyGenSendFn, KeyGenSenderForEnterprise } from './eddsaMPCv2KeyGenSender';
 
+/**
+ * Detects whether an encrypted keycard contains MPCv1 EdDSA signing material.
+ *
+ * Returns true iff the decrypted JSON has the structural shape of a v1
+ * SigningMaterial (UShare with a seed field + at least one YShare with a u
+ * field).  Returns false on any error — wrong passphrase, CBOR content that
+ * fails JSON.parse, or unexpected format — so callers can safely branch to
+ * the MPCv2 path without extra guards.
+ */
+export async function isEddsaMpcV1SigningMaterial(
+  encryptedKeyShare: string,
+  walletPassphrase?: string
+): Promise<boolean> {
+  try {
+    // v2 (Argon2id) envelopes are not decryptable in sdk-core (no argon2
+    // dependency), so they throw here and fall through to the catch → false.
+    const prv = sjcl.decrypt(walletPassphrase ?? '', encryptedKeyShare);
+    const signingMaterial = JSON.parse(prv);
+    return (
+      typeof signingMaterial?.uShare?.seed === 'string' &&
+      typeof signingMaterial?.bitgoYShare?.u === 'string' &&
+      (typeof signingMaterial?.backupYShare?.u === 'string' || typeof signingMaterial?.userYShare?.u === 'string')
+    );
+  } catch {
+    return false;
+  }
+}
+
 export class EddsaMPCv2Utils extends BaseEddsaUtils {
   private static readonly MPS_DSG_SIGNING_USER_GPG_KEY = 'MPS_DSG_SIGNING_USER_GPG_KEY';
   private static readonly MPS_DSG_SIGNING_ROUND1_STATE = 'MPS_DSG_SIGNING_ROUND1_STATE';

modules/sdk-core/test/unit/bitgo/utils/tss/eddsa/isEddsaMpcV1SigningMaterial.ts

@@ -0,0 +1,75 @@
+import * as assert from 'assert';
+import { randomBytes } from 'crypto';
+import * as sjcl from '@bitgo/sjcl';
+import { isEddsaMpcV1SigningMaterial } from '../../../../../../src/bitgo/utils/tss/eddsa/eddsaMPCv2';
+
+const PASSPHRASE = 'test-passphrase';
+
+/** Minimal valid MPCv1 signing material (backupYShare variant). */
+const MPCv1_MATERIAL_BACKUP = {
+  uShare: { i: 1, t: 2, n: 3, y: 'aabbcc', seed: 'deadbeef01234567', chaincode: '00' },
+  bitgoYShare: { i: 3, j: 1, y: 'aabbcc', u: 'bitgo-u-value', chaincode: '00' },
+  backupYShare: { i: 2, j: 1, y: 'aabbcc', u: 'backup-u-value', chaincode: '00' },
+};
+
+/** Minimal valid MPCv1 signing material (userYShare variant). */
+const MPCv1_MATERIAL_USER = {
+  uShare: { i: 2, t: 2, n: 3, y: 'aabbcc', seed: 'deadbeef01234567', chaincode: '00' },
+  bitgoYShare: { i: 3, j: 2, y: 'aabbcc', u: 'bitgo-u-value', chaincode: '00' },
+  userYShare: { i: 1, j: 2, y: 'aabbcc', u: 'user-u-value', chaincode: '00' },
+};
+
+/** CBOR-like binary content that would come from an MPCv2 keycard. */
+const MPCv2_CBOR_BYTES = Buffer.from([0xd9, 0x01, 0x04, 0xa3, 0x61, 0x78, 0x18, 0x00]).toString('base64');
+
+function bytesToWord(bytes: Buffer): number {
+  return bytes.reduce((num, byte) => num * 0x100 + byte, 0);
+}
+
+function encryptSjcl(plaintext: string, password: string): string {
+  const salt = randomBytes(8);
+  const iv = randomBytes(16);
+  return sjcl.encrypt(password, plaintext, {
+    salt: [bytesToWord(salt.subarray(0, 4)), bytesToWord(salt.subarray(4))],
+    iv: [
+      bytesToWord(iv.subarray(0, 4)),
+      bytesToWord(iv.subarray(4, 8)),
+      bytesToWord(iv.subarray(8, 12)),
+      bytesToWord(iv.subarray(12, 16)),
+    ],
+  });
+}
+
+describe('isEddsaMpcV1SigningMaterial', () => {
+  it('returns true for MPCv1 SJCL-encrypted keycard with backupYShare + correct passphrase', async () => {
+    const encrypted = encryptSjcl(JSON.stringify(MPCv1_MATERIAL_BACKUP), PASSPHRASE);
+    assert.strictEqual(await isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), true);
+  });
+
+  it('returns true for MPCv1 SJCL-encrypted keycard with userYShare + correct passphrase', async () => {
+    const encrypted = encryptSjcl(JSON.stringify(MPCv1_MATERIAL_USER), PASSPHRASE);
+    assert.strictEqual(await isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), true);
+  });
+
+  it('returns false for MPCv2 CBOR content wrapped in SJCL envelope + correct passphrase', async () => {
+    // CBOR binary content fails JSON.parse → structural checks never reached → false
+    const encrypted = encryptSjcl(MPCv2_CBOR_BYTES, PASSPHRASE);
+    assert.strictEqual(await isEddsaMpcV1SigningMaterial(encrypted, PASSPHRASE), false);
+  });
+
+  it('returns false for MPCv2 Argon2id envelope (v2) + correct passphrase (forward-compat)', async () => {
+    // A v2 envelope is not a valid SJCL ciphertext — sjcl.decrypt throws → catch → false
+    const fakeV2Envelope = JSON.stringify({ v: 2, m: 65536, t: 3, p: 4, salt: 'AAAA', iv: 'AAAA', ct: 'AAAA' });
+    assert.strictEqual(await isEddsaMpcV1SigningMaterial(fakeV2Envelope, PASSPHRASE), false);
+  });
+
+  it('returns false for wrong passphrase — does not throw', async () => {
+    const encrypted = encryptSjcl(JSON.stringify(MPCv1_MATERIAL_BACKUP), PASSPHRASE);
+    assert.strictEqual(await isEddsaMpcV1SigningMaterial(encrypted, 'wrong-passphrase'), false);
+  });
+
+  it('returns false for undefined passphrase — does not throw', async () => {
+    const encrypted = encryptSjcl(JSON.stringify(MPCv1_MATERIAL_BACKUP), PASSPHRASE);
+    assert.strictEqual(await isEddsaMpcV1SigningMaterial(encrypted, undefined), false);
+  });
+});