@dynamic-labs-wallet/browser 1.0.91 → 1.0.93

package/index.esm.js

@@ -1,7 +1,7 @@
-import { BitcoinAddressType, MPC_RELAY_PROD_API_URL, getMPCChainConfig, parseNamespacedVersion, WalletApiError, BackupLocation, ENCRYPTED_SHARES_STORAGE_SUFFIX, Logger, NETWORK_ERROR_STATUS, handleAxiosError, WalletOperation, WalletReadyState, classifyForwardMpcError, isRecoveredForwardMpcConnectionChurn, FEATURE_FLAGS, ThresholdSignatureScheme, getClientThreshold, MPC_CONFIG, getTSSConfig, serializeMessageForForwardMPC, isEvmCompatibleChain, serializeError, getReshareConfig, getRequiredExternalKeyShareId, verifiedCredentialNameToChainEnum, AuthMode, NoopLogger, DynamicApiClient, BusinessAccountClient, getEnvironmentFromUrl, IFRAME_DOMAIN_MAP } from '@dynamic-labs-wallet/core';
+import { BitcoinAddressType, MPC_RELAY_PROD_API_URL, DEFAULT_ED25519_VARIANT, getMPCChainConfig, parseNamespacedVersion, WalletApiError, BackupLocation, ENCRYPTED_SHARES_STORAGE_SUFFIX, Logger, NETWORK_ERROR_STATUS, handleAxiosError, WalletOperation, WalletReadyState, classifyForwardMpcError, isRecoveredForwardMpcConnectionChurn, FEATURE_FLAGS, ThresholdSignatureScheme, getClientThreshold, MPC_CONFIG, getTSSConfig, serializeMessageForForwardMPC, isEvmCompatibleChain, serializeError, getReshareConfig, getRequiredExternalKeyShareId, verifiedCredentialNameToChainEnum, AuthMode, NoopLogger, DynamicApiClient, BusinessAccountClient, getEnvironmentFromUrl, IFRAME_DOMAIN_MAP } from '@dynamic-labs-wallet/core';
 export * from '@dynamic-labs-wallet/core';
 export { Logger } from '@dynamic-labs-wallet/core';
-import { EdBls12377, BIP340, ExportableEd25519, Ecdsa, MessageHash, EcdsaSignature, EcdsaKeygenResult, ExportableEd25519KeygenResult, BIP340KeygenResult } from '#internal/web';
+import { EdBls12377, BIP340, Ed25519, ExportableEd25519, Ecdsa, MessageHash, EcdsaSignature, EcdsaKeygenResult, ExportableEd25519KeygenResult, Ed25519KeygenResult, BIP340KeygenResult } from '#internal/web';
 export { BIP340, BIP340InitKeygenResult, BIP340KeygenResult, Ecdsa, EcdsaInitKeygenResult, EcdsaKeygenResult, EcdsaPublicKey, EcdsaSignature, Ed25519, Ed25519InitKeygenResult, Ed25519KeygenResult, EdBls12377, EdBls12377KeygenResult, MessageHash } from '#internal/web';
 import { v4, validate } from 'uuid';
 import { SigningAlgorithm } from '@dynamic-labs-wallet/primitives';
@@ -10,6 +10,8 @@ import loadArgon2idWasm from 'argon2id';
 import { AxiosError } from 'axios';
 import gte from 'semver/functions/gte';
 import PQueue from 'p-queue';
+import { ed25519 } from '@noble/curves/ed25519';
+import { hexToBytes, bytesToNumberLE } from '@noble/curves/abstract/utils';
 
 function _extends() {
     _extends = Object.assign || function assign(target) {
@@ -79,12 +81,17 @@ function _extends() {
             return undefined;
     }
 };
-const getMPCSignatureScheme = ({ signingAlgorithm, baseRelayUrl = MPC_RELAY_PROD_API_URL })=>{
+const getMPCSignatureScheme = ({ signingAlgorithm, baseRelayUrl = MPC_RELAY_PROD_API_URL, variant = DEFAULT_ED25519_VARIANT })=>{
     switch(signingAlgorithm){
         case SigningAlgorithm.ECDSA:
             return new Ecdsa(baseRelayUrl);
         case SigningAlgorithm.ED25519:
-            return new ExportableEd25519(baseRelayUrl);
+            // `Ed25519` (non-exportable) and `ExportableEd25519` are distinct protocol
+            // classes with incompatible keyshare formats. Downstream `instanceof`
+            // dispatch (createWalletAccount / importPrivateKey / derive*) always tests
+            // `ExportableEd25519` before `Ed25519` — most-specific-first — so it stays
+            // correct even if `ExportableEd25519` were a subclass of `Ed25519`.
+            return variant === 'ed25519Standard' ? new Ed25519(baseRelayUrl) : new ExportableEd25519(baseRelayUrl);
         case SigningAlgorithm.BIP340:
             return new BIP340(baseRelayUrl);
         case SigningAlgorithm.EDBLS12_377:
@@ -93,11 +100,12 @@ const getMPCSignatureScheme = ({ signingAlgorithm, baseRelayUrl = MPC_RELAY_PROD
             throw new Error(`Unsupported signing algorithm: ${signingAlgorithm}`);
     }
 };
-const getMPCSigner = ({ chainName, baseRelayUrl, bitcoinConfig })=>{
+const getMPCSigner = ({ chainName, baseRelayUrl, bitcoinConfig, variant })=>{
     const chainConfig = getMPCChainConfig(chainName, bitcoinConfig);
     const signatureScheme = getMPCSignatureScheme({
         signingAlgorithm: chainConfig.signingAlgorithm,
-        baseRelayUrl
+        baseRelayUrl,
+        variant
     });
     return signatureScheme;
 };
@@ -3378,28 +3386,34 @@ class DynamicWalletClient {
         }, this.getTraceContext(traceContext))));
         throw new Error('Timed out waiting for wallet creation ceremony to complete');
     }
-    async clientInitializeKeyGen({ chainName, thresholdSignatureScheme, bitcoinConfig }) {
+    async clientInitializeKeyGen({ chainName, thresholdSignatureScheme, bitcoinConfig, variant }) {
         // Get the mpc signer
         const mpcSigner = getMPCSigner({
             chainName,
             baseRelayUrl: this.baseMPCRelayApiUrl,
-            bitcoinConfig
+            bitcoinConfig,
+            variant
         });
         const clientThreshold = getClientThreshold(thresholdSignatureScheme);
         const keygenInitResults = await Promise.all(Array(clientThreshold).fill(null).map(()=>mpcSigner.initKeygen()));
         return keygenInitResults;
     }
-    async derivePublicKey({ chainName, keyShare, derivationPath, bitcoinConfig }) {
+    async derivePublicKey({ chainName, keyShare, derivationPath, bitcoinConfig, variant }) {
         const mpcSigner = getMPCSigner({
             chainName,
             baseRelayUrl: this.baseMPCRelayApiUrl,
-            bitcoinConfig
+            bitcoinConfig,
+            variant
         });
         let publicKey;
         if (mpcSigner instanceof Ecdsa) {
             publicKey = await mpcSigner.derivePubkey(keyShare, derivationPath);
         } else if (mpcSigner instanceof ExportableEd25519) {
             publicKey = await mpcSigner.getPubkey(keyShare);
+        } else if (mpcSigner instanceof Ed25519) {
+            // Non-exportable Ed25519 (raw-scalar-imported wallets). Derivation is not
+            // standardized for ed25519, so the root pubkey is taken with an undefined path.
+            publicKey = await mpcSigner.derivePubkey(keyShare, derivationPath);
         } else if (mpcSigner instanceof BIP340) {
             publicKey = await mpcSigner.deriveTweakPubkey(keyShare, derivationPath);
         }
@@ -3763,7 +3777,7 @@ class DynamicWalletClient {
             shouldRetry: (error)=>!isNonRetryableCeremonyError(error)
         });
     }
-    async runImportRawPrivateKeyAttempt({ chainName, privateKey, thresholdSignatureScheme, bitcoinConfig, onError, onCeremonyComplete, traceContext, legacyWalletId, password, signedSessionId }) {
+    async runImportRawPrivateKeyAttempt({ chainName, privateKey, thresholdSignatureScheme, bitcoinConfig, onError, onCeremonyComplete, traceContext, legacyWalletId, password, signedSessionId, isRawScalarImport }) {
         const dynamicRequestId = v4();
         try {
             this.assertPasswordRequired(password);
@@ -3771,15 +3785,21 @@ class DynamicWalletClient {
                 password,
                 signedSessionId
             });
+            // A raw-scalar import must run on the non-exportable `Ed25519` protocol for
+            // the whole ceremony (init keygen, import, pubkey derivation) so the produced
+            // key shares are consistent. Non-raw imports keep the default ('ed25519Exportable').
+            const variant = isRawScalarImport ? 'ed25519Standard' : undefined;
             const mpcSigner = getMPCSigner({
                 chainName,
                 baseRelayUrl: this.baseMPCRelayApiUrl,
-                bitcoinConfig
+                bitcoinConfig,
+                variant
             });
             const clientKeygenInitResults = await this.clientInitializeKeyGen({
                 chainName,
                 thresholdSignatureScheme,
-                bitcoinConfig
+                bitcoinConfig,
+                variant
             });
             const clientKeygenIds = clientKeygenInitResults.map((result)=>result.keygenId);
             this.logger.info('[DynamicWaasWalletClient] Client key generation initialized', _extends({
@@ -3797,7 +3817,9 @@ class DynamicWalletClient {
                 bitcoinConfig,
                 onError,
                 onCeremonyComplete,
-                legacyWalletId
+                legacyWalletId,
+                // Persist the protocol variant server-side so later sign/reshare read it back.
+                variant
             });
             this.logger.info('[DynamicWaasWalletClient] Server key generation initialized', _extends({
                 roomId,
@@ -3815,7 +3837,9 @@ class DynamicWalletClient {
                         ...serverKeygenIds,
                         ...otherClientKeygenIds
                     ];
-                    const importerKeygenResult = await mpcSigner.importPrivateKeyImporter(roomId, threshold, privateKey, currentInit, otherKeyGenIds);
+                    const importerKeygenResult = isRawScalarImport ? // uses the 32 bytes directly as the signing scalar instead of
+                    // SHA-512-expanding them as an RFC-8032 seed.
+                    await mpcSigner.importPrivateKeyImporter(roomId, threshold, privateKey, currentInit, otherKeyGenIds, true) : await mpcSigner.importPrivateKeyImporter(roomId, threshold, privateKey, currentInit, otherKeyGenIds);
                     return importerKeygenResult;
                 } else {
                     const recipientKeygenResult = await mpcSigner.importPrivateKeyRecipient(roomId, threshold, currentInit, [
@@ -3832,7 +3856,8 @@ class DynamicWalletClient {
                 chainName,
                 keyShare: clientKeygenResult,
                 derivationPath,
-                bitcoinConfig
+                bitcoinConfig,
+                variant
             });
             this.logger.info('[DynamicWaasWalletClient] Completed import of raw private key', _extends({
                 rawPublicKey,
@@ -3867,6 +3892,8 @@ class DynamicWalletClient {
         if (typeof message !== 'string') {
             message = `0x${Buffer.from(message).toString('hex')}`;
         }
+        // Note: the server signing party (wallet-service) selects the ed25519
+        // protocol variant from its own persisted EAC, so it is NOT threaded here.
         const serializedContext = context ? JSON.parse(JSON.stringify(context, (_key, value)=>typeof value === 'bigint' ? value.toString() : value)) : undefined;
         const useHttpTransport = this.featureFlags[FEATURE_FLAGS.ENABLE_HTTP_WAAS_TRANSPORT] === true && this.featureFlags[FEATURE_FLAGS.ENABLE_HTTP_WAAS_TRANSPORT_SIGNMESSAGE] === true;
         const params = {
@@ -3930,7 +3957,7 @@ class DynamicWalletClient {
         }
         return signatureBytes;
     }
-    async forwardMPCClientSign({ chainName, message, roomId, keyShare, derivationPath, formattedMessage, dynamicRequestId, isFormatted, traceContext, bitcoinConfig }) {
+    async forwardMPCClientSign({ chainName, message, roomId, keyShare, derivationPath, formattedMessage, dynamicRequestId, isFormatted, traceContext, bitcoinConfig, variant }) {
         try {
             const chainConfig = getMPCChainConfig(chainName, bitcoinConfig);
             const signingAlgo = chainConfig.signingAlgorithm;
@@ -3943,7 +3970,7 @@ class DynamicWalletClient {
             });
             const tweak = this.convertTweakForBIP340(bitcoinConfig == null ? void 0 : bitcoinConfig.tweak);
             this.logger.info('Forward MPC enabled, signing message with forward MPC (new)', this.getTraceContext(traceContext));
-            const { signature: signatureBytes } = await this.apiClient.forwardMPCClient.signMessage({
+            const { signature: signatureBytes } = await this.apiClient.forwardMPCClient.signMessage(_extends({
                 keyshare: keyShare,
                 message: messageToSign,
                 relayDomain: this.baseMPCRelayApiUrl || '',
@@ -3955,7 +3982,9 @@ class DynamicWalletClient {
                 traceContext,
                 userId: this.userId,
                 environmentId: this.environmentId
-            });
+            }, variant === 'ed25519Standard' ? {
+                ed25519Variant: 'standard'
+            } : {}));
             if (!(signatureBytes instanceof Uint8Array)) {
                 throw new TypeError(`Invalid signature format: expected Uint8Array, got ${typeof signatureBytes}`);
             }
@@ -3975,15 +4004,22 @@ class DynamicWalletClient {
             throw error;
         }
     }
-    async clientSign({ chainName, message, roomId: initialRoomId, keyShare, derivationPath, isFormatted, dynamicRequestId, traceContext, bitcoinConfig, refreshRoom }) {
+    async clientSign({ chainName, message, roomId: initialRoomId, keyShare, derivationPath, isFormatted, dynamicRequestId, traceContext, bitcoinConfig, variant, refreshRoom }) {
         // Reassigned when forward MPC fails and we mint a fresh room for the
         // relay-based fallback below.
         let roomId = initialRoomId;
+        // Non-exportable Ed25519 (raw-scalar import) derives its address at the
+        // root — see derivePrivateKeyFromExport's identical guard. Unlike
+        // ExportableEd25519 (which ignores this arg), Ed25519.sign() *applies* a
+        // non-undefined path, so forwarding the wallet's stored derivation path
+        // here would sign under a derived child key instead of the wallet's own.
+        const effectiveDerivationPath = variant === 'ed25519Standard' ? undefined : derivationPath;
         try {
             const mpcSigner = getMPCSigner({
                 chainName,
                 baseRelayUrl: this.baseMPCRelayApiUrl,
-                bitcoinConfig
+                bitcoinConfig,
+                variant
             });
             const formattedMessage = isFormatted ? new MessageHash(message) : formatMessage(chainName, message);
             this.logger.debug('[DynamicWaasWalletClient] Starting client sign', _extends({
@@ -4007,12 +4043,13 @@ class DynamicWalletClient {
                         message,
                         roomId,
                         keyShare,
-                        derivationPath,
+                        derivationPath: effectiveDerivationPath,
                         formattedMessage,
                         dynamicRequestId,
                         isFormatted,
                         traceContext,
-                        bitcoinConfig
+                        bitcoinConfig,
+                        variant
                     });
                 } catch (error) {
                     const errorInfo = classifyForwardMpcError(error);
@@ -4056,7 +4093,7 @@ class DynamicWalletClient {
             if (!('sign' in mpcSigner)) {
                 throw new TypeError(`Message signing is not supported for chain ${chainName} — use signTransaction instead`);
             }
-            const signature = await mpcSigner.sign(roomId, keyShare, messageToSign, derivationPath, tweak);
+            const signature = await mpcSigner.sign(roomId, keyShare, messageToSign, effectiveDerivationPath, tweak);
             return signature;
         } catch (error) {
             logError({
@@ -4140,7 +4177,8 @@ class DynamicWalletClient {
                     chainName,
                     localShares,
                     recordedKeygenIds,
-                    bitcoinConfig
+                    bitcoinConfig,
+                    variant: this.ed25519VariantForWallet(accountAddress)
                 });
                 localKeygenIds = comparison.localKeygenIds;
                 staleness = comparison.fresh ? 'fresh' : 'stale';
@@ -4206,11 +4244,14 @@ class DynamicWalletClient {
    * the server recorded for the wallet's Dynamic backups. Shared by the
    * stale-share heal (verifyAndRecoverStaleShare) and the backup preflight
    * (ensureLocalSharesAreFresh).
-   */ async compareShareGenerations({ accountAddress, chainName, localShares, recordedKeygenIds, bitcoinConfig }) {
+   */ async compareShareGenerations({ accountAddress, chainName, localShares, recordedKeygenIds, bitcoinConfig, variant }) {
         const mpcSigner = getMPCSigner({
             chainName,
             baseRelayUrl: this.baseMPCRelayApiUrl,
-            bitcoinConfig: bitcoinConfig != null ? bitcoinConfig : this.getBitcoinConfigForChain(chainName, accountAddress)
+            bitcoinConfig: bitcoinConfig != null ? bitcoinConfig : this.getBitcoinConfigForChain(chainName, accountAddress),
+            // Raw-scalar (non-exportable Ed25519) wallets: build the matching signer so
+            // getKeygenIdForShare deserializes the Ed25519 share (else "Invalid discriminant").
+            variant
         });
         const localKeygenIds = await Promise.all(localShares.map((share)=>this.getKeygenIdForShare(mpcSigner, share)));
         const recordedSet = new Set(recordedKeygenIds);
@@ -4368,6 +4409,7 @@ class DynamicWalletClient {
                     dynamicRequestId,
                     traceContext,
                     bitcoinConfig,
+                    variant: wallet.variant,
                     // On forward-MPC fallback, re-run the server sign with no roomId so a
                     // brand-new server-joined room is created for the relay ceremony.
                     refreshRoom: async ()=>{
@@ -4667,7 +4709,11 @@ class DynamicWalletClient {
             const mpcSigner = getMPCSigner({
                 chainName,
                 baseRelayUrl: this.baseMPCRelayApiUrl,
-                bitcoinConfig
+                bitcoinConfig,
+                // Raw-scalar (non-exportable Ed25519) wallets must refresh on the same
+                // protocol their shares were created with, or the ceremony fails to
+                // deserialize them ("Invalid discriminant").
+                variant: this.ed25519VariantForWallet(accountAddress)
             });
             // Ensure client key shares exist before hitting the API
             const clientKeyShares = await this.ensureClientShare(accountAddress);
@@ -4849,11 +4895,26 @@ class DynamicWalletClient {
         }
         return mpcSigner.exportID(share);
     }
-    async getExportId({ chainName, clientKeyShare, bitcoinConfig }) {
+    /**
+   * The ed25519 protocol variant for an existing wallet, read from the wallet map
+   * (sourced from `walletProperties.settings.variant`, persisted at import).
+   *
+   * It is per-wallet protocol metadata — like `thresholdSignatureScheme` or
+   * `addressType` — and the single source of truth for which signer to build when
+   * operating on a wallet's key shares. Wallets imported from a raw ed25519 scalar
+   * (e.g. Fireblocks Embedded Wallets) are `'ed25519Standard'` (non-exportable `Ed25519`);
+   * everything else is `undefined` → the default exportable protocol. Using the
+   * wrong one fails to deserialize the key share with "Invalid discriminant".
+   */ ed25519VariantForWallet(accountAddress) {
+        var _this_getWalletFromMap;
+        return (_this_getWalletFromMap = this.getWalletFromMap(accountAddress)) == null ? void 0 : _this_getWalletFromMap.variant;
+    }
+    async getExportId({ chainName, clientKeyShare, bitcoinConfig, accountAddress }) {
         const mpcSigner = getMPCSigner({
             chainName,
             baseRelayUrl: this.baseMPCRelayApiUrl,
-            bitcoinConfig
+            bitcoinConfig,
+            variant: accountAddress ? this.ed25519VariantForWallet(accountAddress) : undefined
         });
         try {
             const exportId = await this.getKeygenIdForShare(mpcSigner, clientKeyShare);
@@ -4901,7 +4962,8 @@ class DynamicWalletClient {
         return this.getExportId({
             chainName,
             clientKeyShare,
-            bitcoinConfig
+            bitcoinConfig,
+            accountAddress
         });
     }
     /**
@@ -4942,7 +5004,8 @@ class DynamicWalletClient {
         const existingClientKeygenIds = await Promise.all(existingClientKeyShares.map(async (keyShare)=>await this.getExportId({
                 chainName,
                 clientKeyShare: keyShare,
-                bitcoinConfig
+                bitcoinConfig,
+                accountAddress
             })));
         return {
             newClientInitKeygenResults,
@@ -4980,7 +5043,7 @@ class DynamicWalletClient {
             }));
     }
     /** Reshare into a new 2/2 share set for the target signer; seed it to CKS
-   *  on their behalf via a single-use grant. Does not touch the caller's set. */ async reshareToNewSignerShareSet({ chainName, accountAddress, businessAccountId, signerType = 'endUser', targetSignerIdentity, password = undefined, signedSessionId }) {
+   *  on their behalf via a single-use grant. Does not touch the caller's set. */ async reshareToNewSignerShareSet({ chainName, accountAddress, businessAccountId, signerType = 'endUser', targetSignerIdentity, password = undefined, signedSessionId, elevatedAccessToken }) {
         var _backup_keyShareIds;
         const dynamicRequestId = v4();
         const ceremonyStartTime = Date.now();
@@ -5011,7 +5074,8 @@ class DynamicWalletClient {
         const existingClientKeygenId = await this.getExportId({
             chainName,
             clientKeyShare: existingClientShare,
-            bitcoinConfig
+            bitcoinConfig,
+            accountAddress
         });
         // Gate matches internalRefresh/Reshare — SSE error rejects awaitTerminal.
         let newShareSetId;
@@ -5043,6 +5107,7 @@ class DynamicWalletClient {
             identifier: targetSignerIdentity.identifier,
             identifierType: targetSignerIdentity.identifierType,
             dynamicRequestId,
+            elevatedAccessToken,
             onError: ceremonyGate.onError,
             onCeremonyComplete: ceremonyGate.onCeremonyComplete
         });
@@ -5619,7 +5684,11 @@ class DynamicWalletClient {
             const mpcSigner = getMPCSigner({
                 chainName,
                 baseRelayUrl: this.baseMPCRelayApiUrl,
-                bitcoinConfig
+                bitcoinConfig,
+                // Raw-scalar (non-exportable Ed25519) wallets must reshare on the same
+                // protocol their shares were created with, or the ceremony fails to
+                // deserialize them ("Invalid discriminant").
+                variant: this.ed25519VariantForWallet(accountAddress)
             });
             let existingReshareResults;
             let newReshareResults;
@@ -5983,6 +6052,9 @@ class DynamicWalletClient {
         if (mpcSigner instanceof ExportableEd25519) {
             return new ExportableEd25519KeygenResult(extractedPubkey, secretShare);
         }
+        if (mpcSigner instanceof Ed25519) {
+            return new Ed25519KeygenResult(extractedPubkey, secretShare);
+        }
         return new BIP340KeygenResult(extractedPubkey, secretShare);
     }
     async exportKey({ accountAddress, chainName, bitcoinConfig, password = undefined, signedSessionId, mfaToken, elevatedAccessToken, traceContext }) {
@@ -6013,13 +6085,15 @@ class DynamicWalletClient {
             const mpcSigner = getMPCSigner({
                 chainName,
                 baseRelayUrl: this.baseMPCRelayApiUrl,
-                bitcoinConfig
+                bitcoinConfig,
+                variant: wallet.variant
             });
             const reconstructedKeyShare = await this.getReconstructedKeyShare(accountAddress, mpcSigner);
             const exportId = await this.getExportId({
                 chainName,
                 clientKeyShare: reconstructedKeyShare,
-                bitcoinConfig
+                bitcoinConfig,
+                accountAddress: wallet.accountAddress
             });
             const data = await this.apiClient.exportKey({
                 walletId: wallet.walletId,
@@ -6162,20 +6236,35 @@ class DynamicWalletClient {
         if (mpcSigner instanceof Ecdsa) {
             return mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
         } else if (mpcSigner instanceof ExportableEd25519) {
+            // ExportableEd25519's exportFullPrivateKey already returns the RFC-8032
+            // form (hex of seed||pubkey); pass it straight through.
             return keyExportRaw;
+        } else if (mpcSigner instanceof Ed25519) {
+            // Non-exportable Ed25519's exportFullPrivateKey returns an `spriv`
+            // (extended private key), NOT a raw hex key — it must be parsed to the
+            // actual private scalar. Returning the spriv verbatim makes the chain
+            // client hex-decode it into an empty buffer (blank export field).
+            //
+            // This protocol is only used for raw-scalar import, whose public key is
+            // the ROOT scalar (`A = s·B`, derived at import via derivePubkey(_, undefined)).
+            // The chain-config derivation path stored on the wallet (e.g. Solana's
+            // [44,501,0,0,0]) must NOT be applied here — deriving a child scalar would
+            // export a key that doesn't correspond to the wallet's address.
+            return mpcSigner.derivePrivateKeyFromSpriv(keyExportRaw);
         } else if (mpcSigner instanceof BIP340) {
             return mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, derivationPath);
         }
         return undefined;
     }
-    async offlineExportKey({ chainName, keyShares, derivationPath }) {
+    async offlineExportKey({ chainName, keyShares, derivationPath, variant }) {
         try {
             if (!keyShares || keyShares.length < 2) {
                 throw new Error(`Must provide at least min threshold of key shares`);
             }
             const mpcSigner = getMPCSigner({
                 chainName,
-                baseRelayUrl: this.baseMPCRelayApiUrl
+                baseRelayUrl: this.baseMPCRelayApiUrl,
+                variant
             });
             const walletKeyShares = keyShares.map((keyShare)=>{
                 if (!('pubkey' in keyShare)) {
@@ -6194,6 +6283,10 @@ class DynamicWalletClient {
                 derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, walletDerivationPath);
             } else if (mpcSigner instanceof ExportableEd25519) {
                 derivedPrivateKey = keyExportRaw;
+            } else if (mpcSigner instanceof Ed25519) {
+                // Non-exportable Ed25519 (raw-scalar) returns an `spriv`, not raw hex —
+                // parse it to the root scalar (see derivePrivateKeyFromExport).
+                derivedPrivateKey = await mpcSigner.derivePrivateKeyFromSpriv(keyExportRaw);
             } else if (mpcSigner instanceof BIP340) {
                 derivedPrivateKey = await mpcSigner.derivePrivateKeyFromXpriv(keyExportRaw, walletDerivationPath);
             }
@@ -6399,7 +6492,7 @@ class DynamicWalletClient {
    * @param thresholdSignatureScheme - The TSS scheme used
    * @param derivationPath - Optional derivation path (will be computed from chainConfig if not provided)
    * @param additionalProps - Any chain-specific additional properties to merge
-   */ initializeWalletMapEntry({ accountAddress, walletId, chainName, thresholdSignatureScheme, derivationPath, shareSetId, shareSetType, otherShareSets, additionalProps = {} }) {
+   */ initializeWalletMapEntry({ accountAddress, walletId, chainName, thresholdSignatureScheme, derivationPath, shareSetId, shareSetType, otherShareSets, variant, additionalProps = {} }) {
         this.updateWalletMap(accountAddress, _extends({
             accountAddress,
             walletId,
@@ -6413,6 +6506,8 @@ class DynamicWalletClient {
             shareSetType
         } : {}, otherShareSets ? {
             otherShareSets
+        } : {}, variant ? {
+            variant
         } : {}, {
             clientKeySharesBackupInfo: getClientKeyShareBackupInfo()
         }, additionalProps));
@@ -6632,7 +6727,7 @@ class DynamicWalletClient {
             tokenSource: googleDriveTokenSource
         } : {});
     }
-    async publishDelegatedShare({ walletId, shareSetId, delegatedShare, signedSessionId, dynamicRequestId, chainName, bitcoinConfig, isPasswordEncrypted }) {
+    async publishDelegatedShare({ walletId, shareSetId, delegatedShare, signedSessionId, dynamicRequestId, chainName, accountAddress, bitcoinConfig, isPasswordEncrypted }) {
         var _publicKey_key, _publicKey_key1, _publicKey_key2;
         const publicKey = await this.apiClient.getDelegatedEncryptionKey({
             environmentId: this.environmentId
@@ -6657,7 +6752,8 @@ class DynamicWalletClient {
             chainName,
             clientKeyShare: delegatedShare,
             bitcoinConfig,
-            walletId
+            walletId,
+            accountAddress
         });
         return {
             location: BackupLocation.DELEGATED,
@@ -6823,6 +6919,7 @@ class DynamicWalletClient {
                         signedSessionId: resolvedSignedSessionId,
                         dynamicRequestId,
                         chainName: walletData.chainName,
+                        accountAddress,
                         bitcoinConfig,
                         isPasswordEncrypted
                     }), {
@@ -6991,7 +7088,8 @@ class DynamicWalletClient {
             accountAddress,
             chainName,
             localShares,
-            recordedKeygenIds
+            recordedKeygenIds,
+            variant: walletData.variant
         });
         if (fresh) return;
         this.logger.warn('[storeEncryptedBackupByWallet] Stale local shares detected; refreshing local storage', {
@@ -8416,9 +8514,17 @@ class DynamicWalletClient {
             const user = await this.getUserWithEnvCheck(dynamicRequestId);
             const waasWallets = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.filter((vc)=>vc.walletName === 'dynamicwaas');
             for (const vc of waasWallets != null ? waasWallets : []){
+                var _props_settings, _this_getWalletFromMap;
                 const addr = vc.address;
                 const props = vc.walletProperties;
-                this.updateWalletMap(addr, {
+                var _props_settings_variant, _ref;
+                // Resolve the ed25519 protocol variant: server-surfaced (walletProperties
+                // .settings or top-level) first, then any locally-seeded value (set at raw
+                // import). Required on a fresh session (no local seed) so recover/sign
+                // rebuild the non-exportable Ed25519 signer for raw-scalar wallets instead
+                // of defaulting to exportable → "Invalid discriminant".
+                const resolvedVariant = (_ref = (_props_settings_variant = props == null ? void 0 : (_props_settings = props.settings) == null ? void 0 : _props_settings.variant) != null ? _props_settings_variant : props == null ? void 0 : props.variant) != null ? _ref : (_this_getWalletFromMap = this.getWalletFromMap(addr)) == null ? void 0 : _this_getWalletFromMap.variant;
+                this.updateWalletMap(addr, _extends({
                     walletId: vc.id,
                     chainName: verifiedCredentialNameToChainEnum[vc.chain],
                     accountAddress: addr,
@@ -8431,7 +8537,9 @@ class DynamicWalletClient {
                     shareSetId: props == null ? void 0 : props.shareSetId,
                     shareSetType: props == null ? void 0 : props.shareSetType,
                     otherShareSets: props == null ? void 0 : props.otherShareSets
-                });
+                }, resolvedVariant ? {
+                    variant: resolvedVariant
+                } : {}));
             }
             if (walletOperation !== WalletOperation.NO_OPERATION && await this.requiresRestoreBackupSharesForOperation({
                 accountAddress,
@@ -8809,8 +8917,8 @@ class DynamicWalletClient {
             this.userId = user.id;
             const waasWallets = (_user_verifiedCredentials = user.verifiedCredentials) == null ? void 0 : _user_verifiedCredentials.filter((vc)=>vc.walletName === 'dynamicwaas');
             const wallets = waasWallets.map((vc)=>{
-                var _this_getWalletFromMap, _vc_walletProperties, _vc_walletProperties1, _vc_walletProperties2, _vc_walletProperties3, _vc_walletProperties4, _vc_walletProperties5, _vc_walletProperties6;
-                var _this_getWalletFromMap_derivationPath;
+                var _this_getWalletFromMap, _vc_walletProperties, _vc_walletProperties1, _vc_walletProperties2, _vc_walletProperties3, _vc_walletProperties4, _vc_walletProperties5, _vc_walletProperties6, _vc_walletProperties_settings, _vc_walletProperties7, _vc_walletProperties8, _this_getWalletFromMap1;
+                var _this_getWalletFromMap_derivationPath, _vc_walletProperties_settings_variant, _ref;
                 return {
                     walletId: vc.id,
                     chainName: verifiedCredentialNameToChainEnum[vc.chain],
@@ -8828,14 +8936,18 @@ class DynamicWalletClient {
                     // On-sign-on settings (shouldRefreshOnNextSignOn / reshareOnNextSignOn /
                     // revokeOnNextSignOn). Surfaced so the SDK can self-drive the on-sign-on
                     // orchestration instead of the host reading these flags.
-                    settings: (_vc_walletProperties6 = vc.walletProperties) == null ? void 0 : _vc_walletProperties6.settings
+                    settings: (_vc_walletProperties6 = vc.walletProperties) == null ? void 0 : _vc_walletProperties6.settings,
+                    // Prefer the server-persisted variant (surfaced via walletProperties.settings),
+                    // then the locally-known value (set at raw import) so same-session
+                    // import → sign works before the server has surfaced it.
+                    variant: (_ref = (_vc_walletProperties_settings_variant = (_vc_walletProperties7 = vc.walletProperties) == null ? void 0 : (_vc_walletProperties_settings = _vc_walletProperties7.settings) == null ? void 0 : _vc_walletProperties_settings.variant) != null ? _vc_walletProperties_settings_variant : (_vc_walletProperties8 = vc.walletProperties) == null ? void 0 : _vc_walletProperties8.variant) != null ? _ref : (_this_getWalletFromMap1 = this.getWalletFromMap(vc.address)) == null ? void 0 : _this_getWalletFromMap1.variant
                 };
             });
             const existingWalletMap = this.walletMap;
             this.walletMap = wallets.reduce((acc, wallet)=>{
                 const normalizedAddress = normalizeAddress(wallet.accountAddress);
                 const existingWallet = existingWalletMap[normalizedAddress];
-                acc[normalizedAddress] = {
+                acc[normalizedAddress] = _extends({
                     walletId: wallet.walletId,
                     chainName: wallet.chainName,
                     accountAddress: wallet.accountAddress,
@@ -8848,7 +8960,9 @@ class DynamicWalletClient {
                     shareSetType: wallet.shareSetType,
                     businessAccountId: wallet.businessAccountId,
                     otherShareSets: wallet.otherShareSets
-                };
+                }, wallet.variant ? {
+                    variant: wallet.variant
+                } : {});
                 return acc;
             }, {});
             this.logger.info('[walletMap] getWallets: walletMap updated from API', {
@@ -9302,4 +9416,44 @@ DynamicWalletClient.roomsPersistDirty = false;
 // rooms back into the new user's storage (TOCTOU on the create→merge gap).
 DynamicWalletClient.roomsGeneration = 0;
 
-export { BACKUP_FILENAME, CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX, DynamicWalletClient, ENVIRONMENT_SETTINGS_STORAGE_KEY, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_CREATE_WALLET_ACCOUNT, ERROR_EXPORT_PRIVATE_KEY, ERROR_IMPORT_PRIVATE_KEY, ERROR_INCORRECT_PASSWORD, ERROR_KEYGEN_FAILED, ERROR_MULTIPLE_WALLETS_PER_CHAIN, ERROR_NO_KEY_SHARES_BACKED_UP, ERROR_PASSWORD_MISMATCH, ERROR_PASSWORD_REQUIRED, ERROR_PASSWORD_REQUIRED_FOR_ENCRYPTED_WALLET, ERROR_PUBLIC_KEY_MISMATCH, ERROR_REFRESH_NOT_SUPPORTED_FOR_TWO_OF_THREE, ERROR_SIGN_MESSAGE, ERROR_SIGN_TYPED_DATA, ERROR_VERIFY_MESSAGE_SIGNATURE, ERROR_VERIFY_TRANSACTION_SIGNATURE, HEAVY_QUEUE_OPERATIONS, OperationSource, RECOVER_QUEUE_OPERATIONS, ROOM_CACHE_COUNT, ROOM_EXPIRATION_TIME, SIGNED_SESSION_ID_MIN_VERSION, SIGNED_SESSION_ID_MIN_VERSION_BY_NAMESPACE, SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION, SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION_BY_NAMESPACE, SIGN_QUEUE_OPERATIONS, STORAGE_KEY, StaleLocalSharesError, WalletBusyError, WalletNotReadyError, cancelICloudAuth, createAddCloudProviderToExistingDelegationDistribution, createBackupData, createCloudProviderDistribution, createDelegationOnlyDistribution, createDelegationWithCloudProviderDistribution, createDynamicOnlyDistribution, deleteICloudBackup, downloadStringAsFile, extractPubkey, formatEvmMessage, formatMessage, formatTronMessage, getActiveCloudProviders, getBitcoinAddressTypeFromAddress, getBitcoinAddressTypeFromDerivationPath, getClientKeyShareBackupInfo, getClientKeyShareExportFileName, getDelegatedShareSet, getGoogleOAuthAccountId, getHttpStatus, getICloudBackup, getMPCSignatureScheme, getMPCSigner, hasCloudProviderBackup, hasDelegatedBackup, hasEncryptedSharesCached, initializeCloudKit, isBrowser, isHeavyQueueOperation, isHexString, isICloudAuthenticated, isNonRetryableCeremonyError, isPublicKeyMismatchError, isRecoverQueueOperation, isRoomIdAlreadyUsedError, isSignQueueOperation, isStaleClientSharesError, listICloudBackups, markCeremonyErrorNonRetryable, readEnvironmentSettings, resolveLogLevel, retryPromise, shouldReshareToSameBackups, timeoutPromise };
+/**
+ * Derive the 32-byte ed25519 public key from a **raw** 32-byte signing scalar
+ * (`A = s·B`).
+ *
+ * This is NOT the same as deriving a public key from an RFC-8032 seed: the
+ * standard ed25519 key-generation step takes a 32-byte seed and SHA-512-expands
+ * it (then clamps) to obtain the scalar. A scalar exported from an external MPC
+ * system (e.g. Fireblocks Embedded Wallets) has no preimage seed, so it must be
+ * used directly as the scalar. Using `Keypair.fromSecretKey` / `keyPairFromSeed`
+ * on such bytes would re-expand them and produce the wrong public key/address.
+ *
+ * @param scalar Raw 32-byte ed25519 scalar, little-endian, as hex (with or
+ *   without a `0x` prefix) or as raw bytes.
+ * @returns The compressed 32-byte ed25519 public key.
+ */ const getEd25519PublicKeyFromRawScalar = (scalar)=>{
+    let bytes;
+    if (typeof scalar === 'string') {
+        const hex = scalar.replace(/^0x/, '');
+        // Validate before hexToBytes so malformed input fails with a clear, own
+        // error rather than an opaque/implementation-specific one from the decoder.
+        if (!/^[0-9a-fA-F]+$/.test(hex)) {
+            throw new Error('Invalid raw ed25519 scalar: expected a hex string');
+        }
+        bytes = hexToBytes(hex);
+    } else {
+        bytes = scalar;
+    }
+    if (bytes.length !== 32) {
+        throw new Error(`Invalid raw ed25519 scalar length: ${bytes.length}, expected 32`);
+    }
+    // Interpret the scalar little-endian and reduce mod the curve order. We do NOT
+    // clamp here: the caller provides the actual signing scalar `s`, and the public
+    // key is exactly `s·B`.
+    const reduced = bytesToNumberLE(bytes) % ed25519.CURVE.n;
+    if (reduced === 0n) {
+        throw new Error('Invalid raw ed25519 scalar: reduces to zero mod the curve order');
+    }
+    return ed25519.ExtendedPoint.BASE.multiply(reduced).toRawBytes();
+};
+
+export { BACKUP_FILENAME, CLIENT_KEYSHARE_EXPORT_FILENAME_PREFIX, DynamicWalletClient, ENVIRONMENT_SETTINGS_STORAGE_KEY, ERROR_ACCOUNT_ADDRESS_REQUIRED, ERROR_CREATE_WALLET_ACCOUNT, ERROR_EXPORT_PRIVATE_KEY, ERROR_IMPORT_PRIVATE_KEY, ERROR_INCORRECT_PASSWORD, ERROR_KEYGEN_FAILED, ERROR_MULTIPLE_WALLETS_PER_CHAIN, ERROR_NO_KEY_SHARES_BACKED_UP, ERROR_PASSWORD_MISMATCH, ERROR_PASSWORD_REQUIRED, ERROR_PASSWORD_REQUIRED_FOR_ENCRYPTED_WALLET, ERROR_PUBLIC_KEY_MISMATCH, ERROR_REFRESH_NOT_SUPPORTED_FOR_TWO_OF_THREE, ERROR_SIGN_MESSAGE, ERROR_SIGN_TYPED_DATA, ERROR_VERIFY_MESSAGE_SIGNATURE, ERROR_VERIFY_TRANSACTION_SIGNATURE, HEAVY_QUEUE_OPERATIONS, OperationSource, RECOVER_QUEUE_OPERATIONS, ROOM_CACHE_COUNT, ROOM_EXPIRATION_TIME, SIGNED_SESSION_ID_MIN_VERSION, SIGNED_SESSION_ID_MIN_VERSION_BY_NAMESPACE, SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION, SIGNED_SESSION_REVERSE_CHANNEL_MIN_VERSION_BY_NAMESPACE, SIGN_QUEUE_OPERATIONS, STORAGE_KEY, StaleLocalSharesError, WalletBusyError, WalletNotReadyError, cancelICloudAuth, createAddCloudProviderToExistingDelegationDistribution, createBackupData, createCloudProviderDistribution, createDelegationOnlyDistribution, createDelegationWithCloudProviderDistribution, createDynamicOnlyDistribution, deleteICloudBackup, downloadStringAsFile, extractPubkey, formatEvmMessage, formatMessage, formatTronMessage, getActiveCloudProviders, getBitcoinAddressTypeFromAddress, getBitcoinAddressTypeFromDerivationPath, getClientKeyShareBackupInfo, getClientKeyShareExportFileName, getDelegatedShareSet, getEd25519PublicKeyFromRawScalar, getGoogleOAuthAccountId, getHttpStatus, getICloudBackup, getMPCSignatureScheme, getMPCSigner, hasCloudProviderBackup, hasDelegatedBackup, hasEncryptedSharesCached, initializeCloudKit, isBrowser, isHeavyQueueOperation, isHexString, isICloudAuthenticated, isNonRetryableCeremonyError, isPublicKeyMismatchError, isRecoverQueueOperation, isRoomIdAlreadyUsedError, isSignQueueOperation, isStaleClientSharesError, listICloudBackups, markCeremonyErrorNonRetryable, readEnvironmentSettings, resolveLogLevel, retryPromise, shouldReshareToSameBackups, timeoutPromise };

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@dynamic-labs-wallet/browser",
-  "version": "1.0.91",
+  "version": "1.0.93",
   "license": "Licensed under the Dynamic Labs, Inc. Terms Of Service (https://www.dynamic.xyz/terms-conditions)",
   "type": "module",
   "dependencies": {
-    "@dynamic-labs-wallet/core": "1.0.91",
+    "@dynamic-labs-wallet/core": "1.0.93",
     "@dynamic-labs-wallet/forward-mpc-client": "1.0.1",
-    "@dynamic-labs-wallet/primitives": "1.0.91",
+    "@dynamic-labs-wallet/primitives": "1.0.93",
     "@dynamic-labs/sdk-api-core": "^0.0.1093",
+    "@noble/curves": "1.8.0",
     "argon2id": "1.0.1",
     "axios": "1.16.0",
     "p-queue": "9.1.0",