@dynamic-labs-wallet/core 1.1.33 → 1.1.35

package/index.esm.js

@@ -5,7 +5,7 @@ import { WaasChainEnum } from '@dynamic-labs/sdk-api-core/models/WaasChainEnum';
 export { WaasChainEnum } from '@dynamic-labs/sdk-api-core/models/WaasChainEnum';
 export { WaasPolicyConstraintCondition } from '@dynamic-labs/sdk-api-core/models/WaasPolicyConstraintCondition';
 export { WaasPolicyRuleType } from '@dynamic-labs/sdk-api-core/models/WaasPolicyRuleType';
-import axios from 'axios';
+import axios, { isAxiosError } from 'axios';
 export { isAxiosError } from 'axios';
 export { classifyForwardMpcError, isAttestationError, isForwardMpcError } from '@dynamic-labs-wallet/forward-mpc-client/utils';
 
@@ -153,6 +153,7 @@ const FEATURE_FLAGS = {
     ENABLE_FORWARD_MPC_CLIENT_FLAG: 'enable-forward-mpc-client',
     ENABLE_HTTP_WAAS_TRANSPORT: 'enable-http-waas-transport',
     ENABLE_HTTP_WAAS_TRANSPORT_SIGNMESSAGE: 'enable-http-waas-transport-signmessage',
+    ENABLE_HTTP_WAAS_TRANSPORT_EXPORT: 'enable-http-waas-transport-export',
     ENABLE_ROOM_CACHE_FLAG: 'enable-mpc-room-cache',
     ENABLE_SHARE_SET_RESHARE: 'enable-share-set-reshare',
     ENABLE_TRON_MPC_FLAG: 'enable-tron-mpc',
@@ -1279,6 +1280,155 @@ const getElapsedTime = (startTime)=>{
     };
 };
 
+/**
+ * Thrown when sign-and-broadcast answers 413: the request body is over the server's 640kb limit,
+ * which multiple large messages plus calldata can reach.
+ */ class SignAndBroadcastRequestTooLargeError extends Error {
+    constructor(){
+        super('The sign-and-broadcast request is too large. Send less calldata or fewer fee attempts.');
+        this.name = 'SignAndBroadcastRequestTooLargeError';
+    }
+}
+
+class WalletApiError extends Error {
+    constructor(status, message, code){
+        super(message);
+        this.name = 'WalletApiError';
+        this.status = status;
+        this.code = code;
+    }
+}
+const getResponseRecord = (error)=>{
+    var _error_response;
+    const data = (_error_response = error.response) == null ? void 0 : _error_response.data;
+    return data && typeof data === 'object' ? data : undefined;
+};
+// The Key Share Service returns its machine-readable cause under `error_code`; other
+// backends use `code` or a bare `error`. Exported for callers that must skip handleAxiosError's own logging.
+const extractServerErrorCode = (error)=>{
+    const record = getResponseRecord(error);
+    const candidates = [
+        record == null ? void 0 : record['code'],
+        record == null ? void 0 : record['error_code'],
+        record == null ? void 0 : record['error']
+    ];
+    return candidates.find((value)=>typeof value === 'string');
+};
+const INTERNAL_SERVER_ERROR_MESSAGE = 'Internal server error';
+/**
+ * `status` for a request that never received an HTTP response at all — the
+ * client lost connectivity, the request was aborted, DNS/TLS failed, or CORS
+ * blocked it. 0 matches the XHR/`fetch` convention for "no response".
+ *
+ * This used to be reported as `500 Internal server error`, which made a
+ * client-side network failure indistinguishable from a backend fault: the
+ * "Backend 500s" monitor counted 1,395 events on a day when the API returned
+ * only 33 real 5xx responses.
+ */ const NETWORK_ERROR_STATUS = 0;
+const NETWORK_ERROR_CODE = 'NETWORK_ERROR';
+const NETWORK_ERROR_MESSAGE = 'Network error - no response received';
+const STATUS_MESSAGES = {
+    400: 'Invalid request',
+    403: 'Forbidden',
+    422: 'Unprocessable content',
+    429: 'Rate limited',
+    500: INTERNAL_SERVER_ERROR_MESSAGE
+};
+const MISSING_AUTH_MESSAGE = 'Authorization header or cookie missing';
+// A 401 can mean the request carried no credentials, or carried credentials the
+// backend rejected — the two need different messages. The Authorization header
+// is readable so we can confirm its presence; the auth cookie is httpOnly, so we
+// can only report whether cookie mode was enabled (`withCredentials`), not that a
+// cookie was actually attached.
+const getRequestCredentials = (error)=>{
+    var _error_config, _error_config1;
+    const requestHeaders = (_error_config = error.config) == null ? void 0 : _error_config.headers;
+    var _requestHeaders_Authorization;
+    const hasAuthorizationHeader = Boolean((_requestHeaders_Authorization = requestHeaders == null ? void 0 : requestHeaders['Authorization']) != null ? _requestHeaders_Authorization : requestHeaders == null ? void 0 : requestHeaders['authorization']);
+    const usesCookieAuth = Boolean((_error_config1 = error.config) == null ? void 0 : _error_config1.withCredentials);
+    return {
+        hasAuthorizationHeader,
+        usesCookieAuth
+    };
+};
+const resolveUnauthorizedMessage = (error)=>{
+    const { hasAuthorizationHeader, usesCookieAuth } = getRequestCredentials(error);
+    if (!hasAuthorizationHeader && !usesCookieAuth) {
+        return MISSING_AUTH_MESSAGE;
+    }
+    const credentialDescriptions = [];
+    if (hasAuthorizationHeader) {
+        credentialDescriptions.push('Authorization header present');
+    }
+    if (usesCookieAuth) {
+        credentialDescriptions.push('withCredentials enabled (cookie auth)');
+    }
+    return `Unauthorized (${credentialDescriptions.join(', ')})`;
+};
+const resolveStatusMessage = (status, error)=>{
+    if (status === 401) {
+        return resolveUnauthorizedMessage(error);
+    }
+    if (status && STATUS_MESSAGES[status]) {
+        return STATUS_MESSAGES[status];
+    }
+    return undefined;
+};
+const handleAxiosError = (error, message, context, /**
+   * Optional severity hint from the caller, for failures the caller knows are
+   * expected (e.g. a business-rule rejection). It can only *lower* severity to
+   * `warn` — a caller must not be able to escalate, and a genuine 5xx has to
+   * stay at `error` regardless of what the call site believes.
+   *
+   * Without this the hint that `logError` accepts was silently discarded for
+   * every AxiosError, which is the most common error type in the SDK.
+   */ options)=>{
+    var _error_config, _error_config1, _error_response, _error_response1, _error_response2;
+    const requestUrl = (_error_config = error.config) == null ? void 0 : _error_config.url;
+    const requestBaseUrl = (_error_config1 = error.config) == null ? void 0 : _error_config1.baseURL;
+    // The HTTP status MUST NOT be logged as a top-level `status` field: Datadog
+    // reserves `status` for the log level and its remapper turns a numeric value
+    // into `info`, silently burying every 4xx/5xx we emit here. `http.status_code`
+    // is Datadog's standard attribute, so the level survives and these logs join
+    // against edge/CDN logs on the same field.
+    const logPayload = _extends({
+        message,
+        error: (_error_response = error.response) == null ? void 0 : _error_response.data,
+        http: {
+            status_code: (_error_response1 = error.response) == null ? void 0 : _error_response1.status
+        }
+    }, requestBaseUrl && {
+        requestBaseUrl
+    }, requestUrl && {
+        requestUrl
+    }, {
+        context
+    });
+    const status = (_error_response2 = error.response) == null ? void 0 : _error_response2.status;
+    // A 429 (Too Many Requests) is a transient rate-limit signal, not a code or
+    // logic failure — and a request that never got a response is a client-side
+    // connectivity problem, not a server fault. Both are logged at `warn` so they
+    // don't pollute error dashboards or trigger PagerDuty. The 429 case covers
+    // both Cloudflare WAF blocks and application-level rate limiting.
+    const inferredLevel = status === 429 || status === undefined ? 'warn' : 'error';
+    // A 5xx is a server fault: no call site is entitled to downgrade it, however
+    // expected it believes the failure to be. The hint only applies below 500.
+    const isServerFault = status !== undefined && status >= 500;
+    const logLevel = (options == null ? void 0 : options.level) === 'warn' && !isServerFault ? 'warn' : inferredLevel;
+    Logger[logLevel]('[DynamicWaasWalletClient] Axios error: ', logPayload);
+    // No response at all: report it as such rather than laundering it into a 500.
+    if (status === undefined) {
+        throw new WalletApiError(NETWORK_ERROR_STATUS, NETWORK_ERROR_MESSAGE, NETWORK_ERROR_CODE);
+    }
+    var _resolveStatusMessage;
+    // Preserve the real status. Collapsing every unmapped code to 500 made a 404
+    // (backup not found) and a 504 (gateway timeout) both surface as
+    // "Internal server error", so neither the caller nor a monitor could tell a
+    // missing resource from an outage.
+    const resolvedMessage = (_resolveStatusMessage = resolveStatusMessage(status, error)) != null ? _resolveStatusMessage : `Request failed with status ${status}`;
+    throw new WalletApiError(status, resolvedMessage, extractServerErrorCode(error));
+};
+
 const getRequiredExternalKeyShareId = (ks)=>{
     if (!ks.externalKeyShareId) {
         throw new Error(`Missing externalKeyShareId for key share (id: ${ks.id}, keygenId: ${ks.keygenId})`);
@@ -1293,7 +1443,7 @@ const getRequiredExternalKeyShareId = (ks)=>{
  * before it is posted and surfaces in Datadog exactly as the recovery path does.
  */ const assertDynamicLocationsHaveExternalKeyShareId = (locations)=>locations.filter((location)=>location.location === BackupLocation.DYNAMIC).forEach((location)=>getRequiredExternalKeyShareId(location));
 
-var version = "1.1.33";
+var version = "1.1.35";
 
 /**
  * Reads the Authorization header off an axios request config, which stores
@@ -1458,6 +1608,29 @@ const createWalletAccountRequestBody = ({ chainName, clientKeygenIds, thresholdS
         businessAccountId
     } : {});
 };
+const MAX_SERVER_MESSAGE_LENGTH = 200;
+/**
+ * A rejected sign-and-broadcast as a `WalletApiError` that names the server's reason and code, since the generic status text says nothing about which check failed. A failure with no response (timeout, no connection) passes through.
+ *
+ * @param error - What the request threw.
+ */ const toSignAndBroadcastApiError = (error)=>{
+    if (!isAxiosError(error) || !error.response) {
+        return error;
+    }
+    const { status, data } = error.response;
+    const code = extractServerErrorCode(error);
+    const record = data && typeof data === 'object' ? data : undefined;
+    const serverMessage = [
+        record == null ? void 0 : record['error'],
+        record == null ? void 0 : record['message']
+    ].find((candidate)=>typeof candidate === 'string' && candidate.length > 0 && candidate !== code);
+    const detail = [
+        serverMessage == null ? void 0 : serverMessage.slice(0, MAX_SERVER_MESSAGE_LENGTH),
+        code && `code: ${code}`
+    ].filter(Boolean).join(', ');
+    const suffix = detail ? ` (${detail})` : '';
+    return new WalletApiError(status, `Sign and broadcast failed with status ${status}${suffix}`, code);
+};
 class DynamicApiClient extends BaseClient {
     async getBackupRelayToken({ traceContext }) {
         const { data } = await this.apiClient.get(`${this.waasRoutePrefix}/keyShares/backup/token`, {
@@ -1586,6 +1759,74 @@ class DynamicApiClient extends BaseClient {
             traceContext
         });
     }
+    /**
+   * Starts a sign-and-broadcast: Dynamic opens one signing room per message, you sign in each, and Dynamic then sends the transaction. The signature never comes back.
+   *
+   * @param params.walletId - The wallet that signs.
+   * @param params.shareSetId - Which of the wallet's key sets to use. Defaults to its active one.
+   * @param params.messages - The transaction once per fee attempt, in fee order, as the bytes to sign (RLP hex on EVM, message bytes on Solana). Not hashed.
+   * @param params.contexts - What each message does in readable form (chain, recipient, amount), one per message in the same order. Dynamic checks each against the wallet and its policies.
+   * @param params.broadcastOptions - Solana send settings: other required signers' signatures, and skipping the pre-send dry run.
+   * @param params.isFormatted - `true` if each message is already a hash. `false` for a serialized transaction.
+   * @param params.requestedCertainty - How sure to be before calling it confirmed: `fast`, `safe` or `final`, or `chain:` plus a chain-specific value. Defaults to `safe`.
+   * @param params.externalReference - Your own label, returned on every event. Not unique.
+   * @param params.roomIds - Signing rooms you already opened, one per message. Send all or none; Dynamic opens them when omitted.
+   * @param params.approvalQuorum - Approvers' consent for a governed wallet, sent on the retry after `intent_required`.
+   * @param params.idempotencyKey - Makes a retry safe: the same key replays the stored answer instead of sending twice.
+   * @param params.dynamicRequestId - Id of this one request, to match client and server logs.
+   * @param params.traceContext - Ties this call's logs to the server's, across retries. Created when omitted.
+   * @param params.mfaToken - Proof of the user's multi-factor check, when the wallet needs one.
+   * @param params.elevatedAccessToken - Proof of a recent re-login, when the wallet needs one.
+   * @param params.onError - Called with the failure's message, never the raw error.
+   * @returns The transaction record: its id, its status, and the signing rooms while signing is pending.
+   * @throws SignAndBroadcastRequestTooLargeError when the body is over the server limit.
+   * @throws SigningConsentRequiredError when a governed wallet needs approvers' consent first.
+   * @throws WalletApiError when the server rejects it, with its reason and code.
+   */ async signAndBroadcast({ dynamicRequestId, walletId, shareSetId, contexts, broadcastOptions, messages, isFormatted, requestedCertainty, externalReference, roomIds, approvalQuorum, idempotencyKey, onError, mfaToken, elevatedAccessToken, traceContext }) {
+        try {
+            return await requestJson({
+                apiClient: this.apiClient,
+                dynamicRequestId,
+                idempotencyKey,
+                endpoint: `${this.waasRoutePrefix}/${walletId}/transactions/signAndBroadcast`,
+                body: _extends({
+                    messages,
+                    contexts
+                }, broadcastOptions ? {
+                    broadcastOptions
+                } : {}, {
+                    isFormatted
+                }, requestedCertainty ? {
+                    requestedCertainty
+                } : {}, externalReference ? {
+                    externalReference
+                } : {}, roomIds ? {
+                    roomIds
+                } : {}, approvalQuorum ? {
+                    approvalQuorum
+                } : {}, shareSetId ? {
+                    shareSetId
+                } : {}),
+                timeoutMs: 20000,
+                timeoutMessage: 'Sign and broadcast timed out',
+                onError,
+                mfaToken,
+                elevatedAccessToken,
+                traceContext
+            });
+        } catch (error) {
+            const response = error.response;
+            if ((response == null ? void 0 : response.status) === 413) {
+                throw new SignAndBroadcastRequestTooLargeError();
+            }
+            // A governed wallet with nothing signed yet answers 422 intent_required, as plain signing's stream does.
+            const intentRequired = (response == null ? void 0 : response.status) === 422 ? asIntentRequiredFrom422Body(response.data) : undefined;
+            if (intentRequired) {
+                throw new SigningConsentRequiredError(intentRequired);
+            }
+            throw toSignAndBroadcastApiError(error);
+        }
+    }
     async refreshWalletAccountShares({ dynamicRequestId, walletId, shareSetId, onError, onCeremonyComplete, mfaToken, elevatedAccessToken, traceContext }) {
         return createEventStreamPromise({
             apiClient: this.apiClient,
@@ -1653,6 +1894,35 @@ class DynamicApiClient extends BaseClient {
         });
     }
     /**
+   * Plain-JSON (non-SSE) variant of `exportKey`. Hits the same
+   * `/privateKey/export` endpoint; the `x-idempotency-key` header tells the
+   * backend (when `enable-http-waas-transport-export` is on) to respond with
+   * the OpenRoomResponse synchronously instead of streaming `room_created`
+   * over SSE.
+   */ async requestExportKeyJson({ mfaToken, elevatedAccessToken, dynamicRequestId, walletId, shareSetId, exportId, bitcoinConfig, onError, traceContext, idempotencyKey, timeoutMs }) {
+        const { addressType } = bitcoinConfig || {};
+        const requestBody = _extends({
+            exportId
+        }, addressType ? {
+            addressType
+        } : {}, shareSetId ? {
+            shareSetId
+        } : {});
+        return requestJson({
+            apiClient: this.apiClient,
+            dynamicRequestId,
+            idempotencyKey,
+            endpoint: `${this.waasRoutePrefix}/${walletId}/privateKey/export`,
+            body: requestBody,
+            timeoutMs: timeoutMs != null ? timeoutMs : 20000,
+            timeoutMessage: 'Key export timed out',
+            onError,
+            mfaToken,
+            elevatedAccessToken,
+            traceContext
+        });
+    }
+    /**
    * Kick off the Aleo view-key export MPC ceremony. Returns the MPC room once
    * redcoast + wallet-service have joined; the client then joins the same
    * room via Sodot's `exportViewKey` to receive the view key.
@@ -2808,143 +3078,37 @@ const prepareRawMessageSigningPayload = (chainName, message)=>{
     return typeof formatted === 'string' ? formatted : Buffer.from(formatted).toString('hex');
 };
 
-class WalletApiError extends Error {
-    constructor(status, message, code){
-        super(message);
-        this.name = 'WalletApiError';
-        this.status = status;
-        this.code = code;
+/** Returns the context as plain JSON, with each bigint (which `JSON.stringify` throws on) turned into a string. */ const toJsonSafeContext = (context)=>{
+    try {
+        return JSON.parse(JSON.stringify(context, (_key, value)=>typeof value === 'bigint' ? String(value) : value));
+    } catch (error) {
+        throw new Error(`Could not serialize the signing context: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error
+        });
     }
-}
-const getResponseRecord = (error)=>{
-    var _error_response;
-    const data = (_error_response = error.response) == null ? void 0 : _error_response.data;
-    return data && typeof data === 'object' ? data : undefined;
-};
-// The Key Share Service returns its machine-readable cause under `error_code`; other
-// backends use `code` or a bare `error`. Exported for callers that must skip handleAxiosError's own logging.
-const extractServerErrorCode = (error)=>{
-    const record = getResponseRecord(error);
-    const candidates = [
-        record == null ? void 0 : record['code'],
-        record == null ? void 0 : record['error_code'],
-        record == null ? void 0 : record['error']
-    ];
-    return candidates.find((value)=>typeof value === 'string');
 };
-const INTERNAL_SERVER_ERROR_MESSAGE = 'Internal server error';
+
 /**
- * `status` for a request that never received an HTTP response at all — the
- * client lost connectivity, the request was aborted, DNS/TLS failed, or CORS
- * blocked it. 0 matches the XHR/`fetch` convention for "no response".
- *
- * This used to be reported as `500 Internal server error`, which made a
- * client-side network failure indistinguishable from a backend fault: the
- * "Backend 500s" monitor counted 1,395 events on a day when the API returned
- * only 33 real 5xx responses.
- */ const NETWORK_ERROR_STATUS = 0;
-const NETWORK_ERROR_CODE = 'NETWORK_ERROR';
-const NETWORK_ERROR_MESSAGE = 'Network error - no response received';
-const STATUS_MESSAGES = {
-    400: 'Invalid request',
-    403: 'Forbidden',
-    422: 'Unprocessable content',
-    429: 'Rate limited',
-    500: INTERNAL_SERVER_ERROR_MESSAGE
-};
-const MISSING_AUTH_MESSAGE = 'Authorization header or cookie missing';
-// A 401 can mean the request carried no credentials, or carried credentials the
-// backend rejected — the two need different messages. The Authorization header
-// is readable so we can confirm its presence; the auth cookie is httpOnly, so we
-// can only report whether cookie mode was enabled (`withCredentials`), not that a
-// cookie was actually attached.
-const getRequestCredentials = (error)=>{
-    var _error_config, _error_config1;
-    const requestHeaders = (_error_config = error.config) == null ? void 0 : _error_config.headers;
-    var _requestHeaders_Authorization;
-    const hasAuthorizationHeader = Boolean((_requestHeaders_Authorization = requestHeaders == null ? void 0 : requestHeaders['Authorization']) != null ? _requestHeaders_Authorization : requestHeaders == null ? void 0 : requestHeaders['authorization']);
-    const usesCookieAuth = Boolean((_error_config1 = error.config) == null ? void 0 : _error_config1.withCredentials);
-    return {
-        hasAuthorizationHeader,
-        usesCookieAuth
-    };
-};
-const resolveUnauthorizedMessage = (error)=>{
-    const { hasAuthorizationHeader, usesCookieAuth } = getRequestCredentials(error);
-    if (!hasAuthorizationHeader && !usesCookieAuth) {
-        return MISSING_AUTH_MESSAGE;
-    }
-    const credentialDescriptions = [];
-    if (hasAuthorizationHeader) {
-        credentialDescriptions.push('Authorization header present');
-    }
-    if (usesCookieAuth) {
-        credentialDescriptions.push('withCredentials enabled (cookie auth)');
-    }
-    return `Unauthorized (${credentialDescriptions.join(', ')})`;
-};
-const resolveStatusMessage = (status, error)=>{
-    if (status === 401) {
-        return resolveUnauthorizedMessage(error);
-    }
-    if (status && STATUS_MESSAGES[status]) {
-        return STATUS_MESSAGES[status];
-    }
-    return undefined;
-};
-const handleAxiosError = (error, message, context, /**
-   * Optional severity hint from the caller, for failures the caller knows are
-   * expected (e.g. a business-rule rejection). It can only *lower* severity to
-   * `warn` — a caller must not be able to escalate, and a genuine 5xx has to
-   * stay at `error` regardless of what the call site believes.
-   *
-   * Without this the hint that `logError` accepts was silently discarded for
-   * every AxiosError, which is the most common error type in the SDK.
-   */ options)=>{
-    var _error_config, _error_config1, _error_response, _error_response1, _error_response2;
-    const requestUrl = (_error_config = error.config) == null ? void 0 : _error_config.url;
-    const requestBaseUrl = (_error_config1 = error.config) == null ? void 0 : _error_config1.baseURL;
-    // The HTTP status MUST NOT be logged as a top-level `status` field: Datadog
-    // reserves `status` for the log level and its remapper turns a numeric value
-    // into `info`, silently burying every 4xx/5xx we emit here. `http.status_code`
-    // is Datadog's standard attribute, so the level survives and these logs join
-    // against edge/CDN logs on the same field.
-    const logPayload = _extends({
-        message,
-        error: (_error_response = error.response) == null ? void 0 : _error_response.data,
-        http: {
-            status_code: (_error_response1 = error.response) == null ? void 0 : _error_response1.status
-        }
-    }, requestBaseUrl && {
-        requestBaseUrl
-    }, requestUrl && {
-        requestUrl
-    }, {
-        context
+ * Returns a trace context that always has an id, so a retrying operation can hand the same one to each attempt.
+ * The id is 32 lowercase hex characters, a valid W3C trace id the server can continue.
+ */ const withTraceId = (traceContext)=>{
+    var _traceContext_traceId, _traceContext_startTime;
+    return _extends({}, traceContext, {
+        traceId: (_traceContext_traceId = traceContext == null ? void 0 : traceContext.traceId) != null ? _traceContext_traceId : v4().replaceAll('-', ''),
+        startTime: (_traceContext_startTime = traceContext == null ? void 0 : traceContext.startTime) != null ? _traceContext_startTime : Date.now()
     });
-    const status = (_error_response2 = error.response) == null ? void 0 : _error_response2.status;
-    // A 429 (Too Many Requests) is a transient rate-limit signal, not a code or
-    // logic failure — and a request that never got a response is a client-side
-    // connectivity problem, not a server fault. Both are logged at `warn` so they
-    // don't pollute error dashboards or trigger PagerDuty. The 429 case covers
-    // both Cloudflare WAF blocks and application-level rate limiting.
-    const inferredLevel = status === 429 || status === undefined ? 'warn' : 'error';
-    // A 5xx is a server fault: no call site is entitled to downgrade it, however
-    // expected it believes the failure to be. The hint only applies below 500.
-    const isServerFault = status !== undefined && status >= 500;
-    const logLevel = (options == null ? void 0 : options.level) === 'warn' && !isServerFault ? 'warn' : inferredLevel;
-    Logger[logLevel]('[DynamicWaasWalletClient] Axios error: ', logPayload);
-    // No response at all: report it as such rather than laundering it into a 500.
-    if (status === undefined) {
-        throw new WalletApiError(NETWORK_ERROR_STATUS, NETWORK_ERROR_MESSAGE, NETWORK_ERROR_CODE);
-    }
-    var _resolveStatusMessage;
-    // Preserve the real status. Collapsing every unmapped code to 500 made a 404
-    // (backup not found) and a 504 (gateway timeout) both surface as
-    // "Internal server error", so neither the caller nor a monitor could tell a
-    // missing resource from an outage.
-    const resolvedMessage = (_resolveStatusMessage = resolveStatusMessage(status, error)) != null ? _resolveStatusMessage : `Request failed with status ${status}`;
-    throw new WalletApiError(status, resolvedMessage, extractServerErrorCode(error));
 };
 
-export { AuthMode, BITCOIN_ADDRESS_TYPE_CONFIG, BITCOIN_DERIVATION_PATHS, BROWSER_SDK_ROUTE_PREFIX, BackupLocation, BitcoinAddressType, BitcoinNetwork, BusinessAccountClient, BusinessAccountMemberRole, BusinessAccountSignerType, CreateRoomPartiesOptions, DEFAULT_ED25519_VARIANT, DELEGATED_SHARE_COUNT, DYNAMIC_AUTH_BASE_API_URL_MAP, DYNAMIC_AUTH_DEV_BASE_API_URL, DYNAMIC_AUTH_PREPROD_BASE_API_URL, DYNAMIC_AUTH_PROD_BASE_API_URL, DYNAMIC_CLIENT_RELAY_REDCOAST_API_KEY_MAP, DYNAMIC_CLIENT_RELAY_REDCOAST_APP_ID_MAP, DYNAMIC_FORWARD_MPC_DEV_ENCLAVE_URL, DYNAMIC_FORWARD_MPC_ENCLAVE_ATTESTATION_CONFIG_MAP, DYNAMIC_FORWARD_MPC_ENCLAVE_URL_MAP, DYNAMIC_FORWARD_MPC_PREPROD_ENCLAVE_URL, DYNAMIC_FORWARD_MPC_PROD_ENCLAVE_URL, DYNAMIC_KEYSHARES_RELAY_MAP, DYNAMIC_KEYSHARES_RELAY_PREPROD_BASE_API_URL, DYNAMIC_KEYSHARES_RELAY_PROD_BASE_API_URL, DynamicApiClient, DynamicClientSessionSignature, DynamicElevatedAccessTokenHeader, DynamicForwardMPCHeader, DynamicMfaTokenHeader, DynamicRequestIdHeader, DynamicSessionPublicKeyHeader, DynamicTraceElapsedTimeHeader, DynamicTraceIdHeader, ENCRYPTED_SHARES_STORAGE_SUFFIX, ENVIRONMENT_ENUM, EVM_COMPATIBLE_CHAINS, FEATURE_FLAGS, IFRAME_DOMAIN_MAP, Logger, MIDNIGHT_DERIVATION_PATHS, MPC_CHAIN_CONFIG, MPC_CONFIG, MPC_RELAY_DEV_API_URL, MPC_RELAY_PREPROD_API_URL, MPC_RELAY_PROD_API_URL, MPC_RELAY_URL_MAP, NETWORK_ERROR_CODE, NETWORK_ERROR_STATUS, NoopLogger, PREPROD_RELAY_API_KEY, PREPROD_RELAY_APP_ID, PROD_RELAY_API_KEY, PROD_RELAY_APP_ID, RELAY_API_KEY_HEADER, RELAY_APP_ID_HEADER, SDK_NAMESPACE, SERVER_SDK_ROUTE_PREFIX, SOLANA_RPC_URL, SigningConsentRequiredError, SuccessEventType, ThresholdSignatureScheme, URL_PATTERNS, WalletApiError, WalletOperation, WalletReadyState, assertDynamicLocationsHaveExternalKeyShareId, buildForwardMpcEnclaveUrl, chain, chainEnumToVerifiedCredentialName, createRejectablePromise, createSigningIntent, extractServerErrorCode, formatNamespacedVersion, formatRawMessageForSigning, getBitcoinChainConfig, getClientThreshold, getDynamicServerThreshold, getEnvironmentFromUrl, getMPCChainConfig, getRequiredExternalKeyShareId, getReshareConfig, getServerWalletReshareConfig, getTSSConfig, getVersionNamespace, getVersionWithoutNamespace, handleAxiosError, invokeCeremonyComplete, isBusinessAccountActionRequired, isEvmCompatibleChain, isRecoveredForwardMpcConnectionChurn, normalizeAndValidatePrivateKey, parseNamespacedVersion, prepareRawMessageSigningPayload, sanitizeBusinessAccountSignedIntent, serializeError, serializeMessageForForwardMPC, verifiedCredentialNameToChainEnum };
+/** The ids a caller can quote to support so one failed attempt can be found in client and server logs. */ /** Sets `traceId` and `requestId` on a thrown error so apps can quote them, keeping any id already set. */ const attachRequestIds = (error, { traceId, requestId })=>{
+    var _target, _target1;
+    if (!error || typeof error !== 'object' || !Object.isExtensible(error)) {
+        return;
+    }
+    const target = error;
+    var _traceId;
+    (_traceId = (_target = target).traceId) != null ? _traceId : _target.traceId = traceId;
+    var _requestId;
+    (_requestId = (_target1 = target).requestId) != null ? _requestId : _target1.requestId = requestId;
+};
+
+export { AuthMode, BITCOIN_ADDRESS_TYPE_CONFIG, BITCOIN_DERIVATION_PATHS, BROWSER_SDK_ROUTE_PREFIX, BackupLocation, BitcoinAddressType, BitcoinNetwork, BusinessAccountClient, BusinessAccountMemberRole, BusinessAccountSignerType, CreateRoomPartiesOptions, DEFAULT_ED25519_VARIANT, DELEGATED_SHARE_COUNT, DYNAMIC_AUTH_BASE_API_URL_MAP, DYNAMIC_AUTH_DEV_BASE_API_URL, DYNAMIC_AUTH_PREPROD_BASE_API_URL, DYNAMIC_AUTH_PROD_BASE_API_URL, DYNAMIC_CLIENT_RELAY_REDCOAST_API_KEY_MAP, DYNAMIC_CLIENT_RELAY_REDCOAST_APP_ID_MAP, DYNAMIC_FORWARD_MPC_DEV_ENCLAVE_URL, DYNAMIC_FORWARD_MPC_ENCLAVE_ATTESTATION_CONFIG_MAP, DYNAMIC_FORWARD_MPC_ENCLAVE_URL_MAP, DYNAMIC_FORWARD_MPC_PREPROD_ENCLAVE_URL, DYNAMIC_FORWARD_MPC_PROD_ENCLAVE_URL, DYNAMIC_KEYSHARES_RELAY_MAP, DYNAMIC_KEYSHARES_RELAY_PREPROD_BASE_API_URL, DYNAMIC_KEYSHARES_RELAY_PROD_BASE_API_URL, DynamicApiClient, DynamicClientSessionSignature, DynamicElevatedAccessTokenHeader, DynamicForwardMPCHeader, DynamicMfaTokenHeader, DynamicRequestIdHeader, DynamicSessionPublicKeyHeader, DynamicTraceElapsedTimeHeader, DynamicTraceIdHeader, ENCRYPTED_SHARES_STORAGE_SUFFIX, ENVIRONMENT_ENUM, EVM_COMPATIBLE_CHAINS, FEATURE_FLAGS, IFRAME_DOMAIN_MAP, Logger, MIDNIGHT_DERIVATION_PATHS, MPC_CHAIN_CONFIG, MPC_CONFIG, MPC_RELAY_DEV_API_URL, MPC_RELAY_PREPROD_API_URL, MPC_RELAY_PROD_API_URL, MPC_RELAY_URL_MAP, NETWORK_ERROR_CODE, NETWORK_ERROR_STATUS, NoopLogger, PREPROD_RELAY_API_KEY, PREPROD_RELAY_APP_ID, PROD_RELAY_API_KEY, PROD_RELAY_APP_ID, RELAY_API_KEY_HEADER, RELAY_APP_ID_HEADER, SDK_NAMESPACE, SERVER_SDK_ROUTE_PREFIX, SOLANA_RPC_URL, SignAndBroadcastRequestTooLargeError, SigningConsentRequiredError, SuccessEventType, ThresholdSignatureScheme, URL_PATTERNS, WalletApiError, WalletOperation, WalletReadyState, assertDynamicLocationsHaveExternalKeyShareId, attachRequestIds, buildForwardMpcEnclaveUrl, chain, chainEnumToVerifiedCredentialName, createRejectablePromise, createSigningIntent, extractServerErrorCode, formatNamespacedVersion, formatRawMessageForSigning, getBitcoinChainConfig, getClientThreshold, getDynamicServerThreshold, getEnvironmentFromUrl, getMPCChainConfig, getRequiredExternalKeyShareId, getReshareConfig, getServerWalletReshareConfig, getTSSConfig, getVersionNamespace, getVersionWithoutNamespace, handleAxiosError, invokeCeremonyComplete, isBusinessAccountActionRequired, isEvmCompatibleChain, isRecoveredForwardMpcConnectionChurn, normalizeAndValidatePrivateKey, parseNamespacedVersion, prepareRawMessageSigningPayload, sanitizeBusinessAccountSignedIntent, serializeError, serializeMessageForForwardMPC, toJsonSafeContext, verifiedCredentialNameToChainEnum, withTraceId };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dynamic-labs-wallet/core",
-  "version": "1.1.33",
+  "version": "1.1.35",
   "license": "MIT",
   "type": "module",
   "dependencies": {
     "@dynamic-labs/sdk-api-core": "0.50.0",
-    "@dynamic-labs-wallet/primitives": "1.1.33",
+    "@dynamic-labs-wallet/primitives": "1.1.35",
     "axios": "1.20.0",
     "uuid": "11.1.0"
   },

package/src/api/api.d.ts

@@ -1,8 +1,8 @@
 import type { ForwardMPCClientV2 } from '@dynamic-labs-wallet/forward-mpc-client';
-import type { BackupKeySharesToLocationsRequest, CreateRoomsRequest, CreateRoomsWithoutWalletIdRequest, CreateWaasAccountRequest, ExportAleoViewKeyRequest, ExportWaasWalletPrivateKeyRequest, ImportWaasPrivateKeyRequest, InlineObject1, InlineObject2, InlineObject4, InlineResponse2003, InlineResponse2005, NoncesResponse, ReshareRequest as ApiReshareRequest, SignMessageWithWaasRequest, SignMessageEvmTransaction, SignMessageEvmUserOperation, SignMessageSvmTransaction } from '#internal/sdk-api-core';
+import type { BackupKeySharesToLocationsRequest, CreateRoomsRequest, CreateRoomsWithoutWalletIdRequest, CreateWaasAccountRequest, ExportAleoViewKeyRequest, ExportWaasWalletPrivateKeyRequest, ImportWaasPrivateKeyRequest, InlineObject1, InlineObject2, InlineObject4, InlineResponse2003, InlineResponse2005, NoncesResponse, ReshareRequest as ApiReshareRequest, SignMessageWithWaasRequest, SignMessageContext, SignMessageEvmTransaction, SignMessageEvmUserOperation, SignMessageSvmTransaction } from '#internal/sdk-api-core';
 import { type CeremonyCompleteCallback, type SlowDeliveryMeta } from '../eventStream/utils.js';
 import { ThresholdSignatureScheme } from '../mpc/constants.js';
-import { AuthMode, type AddBusinessAccountMemberRequest, type GetBusinessAccountRequest, type RequestWithTraceContext, type ApprovalQuorumRequestContext, type BackupLocationWithExternalKeyShareId, type BitcoinConfig, type EncryptedDelegatedKeyShareEnvelope, type ILogger, type KeygenCompleteResponse, type LinkWalletToBusinessAccountRequest, type OpenRoomResponse, type ReshareResponse, type RevokeDelegationResponse, type ShareSetType, type TraceContext, type WaasWalletResponse } from '../types.js';
+import { AuthMode, type AddBusinessAccountMemberRequest, type GetBusinessAccountRequest, type RequestWithTraceContext, type ApprovalQuorumRequestContext, type BackupLocationWithExternalKeyShareId, type BitcoinConfig, type EncryptedDelegatedKeyShareEnvelope, type ILogger, type KeygenCompleteResponse, type LinkWalletToBusinessAccountRequest, type OpenRoomResponse, type ReshareResponse, type RevokeDelegationResponse, type ShareSetType, type SignAndBroadcastResponse, type SignAndBroadcastOptions, type TraceContext, type WaasWalletResponse } from '../types.js';
 import { type BusinessAccountActionRequired, type CreateBusinessAccountSdkRequest, type BusinessAccount, type BusinessAccountDetail, type BusinessAccountList, type BusinessAccountMember, type BusinessAccountSigner, type BusinessAccountSignedIntent, type BusinessAccountSignerType, type TargetSignerIdentity } from '../businessAccounts/types.js';
 import { BaseClient } from './client.js';
 import type { AleoFeemasterPolicyResponse, AleoScannerPublicKeyResponse, BackupKeySharesResponse, GetAvailableEVMGaslessRelayerResponse, GetEVMSponsoredTransactionStatusResponse, SponsorEVMTransactionRequest, SponsorEVMTransactionResponse, SponsorSVMTransactionRequest, SponsorSVMTransactionResponse, StoreEncryptedBackupResponse, WalletAdditionalAddressRequest } from './types.js';
@@ -116,6 +116,48 @@ export declare class DynamicApiClient extends BaseClient {
     requestSignMessageJson({ dynamicRequestId, walletId, shareSetId, message, onError, isFormatted, mfaToken, elevatedAccessToken, roomId, context, approvalQuorum, idempotencyKey, forwardMPCClientEnabled, traceContext, bitcoinConfig, }: SignMessageApiRequest & {
         idempotencyKey: string;
     }): Promise<OpenRoomResponse>;
+    /**
+     * Starts a sign-and-broadcast: Dynamic opens one signing room per message, you sign in each, and Dynamic then sends the transaction. The signature never comes back.
+     *
+     * @param params.walletId - The wallet that signs.
+     * @param params.shareSetId - Which of the wallet's key sets to use. Defaults to its active one.
+     * @param params.messages - The transaction once per fee attempt, in fee order, as the bytes to sign (RLP hex on EVM, message bytes on Solana). Not hashed.
+     * @param params.contexts - What each message does in readable form (chain, recipient, amount), one per message in the same order. Dynamic checks each against the wallet and its policies.
+     * @param params.broadcastOptions - Solana send settings: other required signers' signatures, and skipping the pre-send dry run.
+     * @param params.isFormatted - `true` if each message is already a hash. `false` for a serialized transaction.
+     * @param params.requestedCertainty - How sure to be before calling it confirmed: `fast`, `safe` or `final`, or `chain:` plus a chain-specific value. Defaults to `safe`.
+     * @param params.externalReference - Your own label, returned on every event. Not unique.
+     * @param params.roomIds - Signing rooms you already opened, one per message. Send all or none; Dynamic opens them when omitted.
+     * @param params.approvalQuorum - Approvers' consent for a governed wallet, sent on the retry after `intent_required`.
+     * @param params.idempotencyKey - Makes a retry safe: the same key replays the stored answer instead of sending twice.
+     * @param params.dynamicRequestId - Id of this one request, to match client and server logs.
+     * @param params.traceContext - Ties this call's logs to the server's, across retries. Created when omitted.
+     * @param params.mfaToken - Proof of the user's multi-factor check, when the wallet needs one.
+     * @param params.elevatedAccessToken - Proof of a recent re-login, when the wallet needs one.
+     * @param params.onError - Called with the failure's message, never the raw error.
+     * @returns The transaction record: its id, its status, and the signing rooms while signing is pending.
+     * @throws SignAndBroadcastRequestTooLargeError when the body is over the server limit.
+     * @throws SigningConsentRequiredError when a governed wallet needs approvers' consent first.
+     * @throws WalletApiError when the server rejects it, with its reason and code.
+     */
+    signAndBroadcast({ dynamicRequestId, walletId, shareSetId, contexts, broadcastOptions, messages, isFormatted, requestedCertainty, externalReference, roomIds, approvalQuorum, idempotencyKey, onError, mfaToken, elevatedAccessToken, traceContext, }: {
+        dynamicRequestId?: string;
+        walletId: string;
+        shareSetId?: string;
+        contexts: SignMessageContext[];
+        broadcastOptions?: SignAndBroadcastOptions;
+        messages: string[];
+        isFormatted?: boolean;
+        requestedCertainty?: string;
+        externalReference?: string;
+        roomIds?: string[];
+        approvalQuorum?: ApprovalQuorumRequestContext;
+        idempotencyKey: string;
+        onError?: (error: Error) => void;
+        mfaToken?: string;
+        elevatedAccessToken?: string;
+        traceContext?: TraceContext;
+    }): Promise<SignAndBroadcastResponse>;
     refreshWalletAccountShares({ dynamicRequestId, walletId, shareSetId, onError, onCeremonyComplete, mfaToken, elevatedAccessToken, traceContext, }: {
         dynamicRequestId?: string;
         walletId: string;
@@ -152,6 +194,24 @@ export declare class DynamicApiClient extends BaseClient {
         onError?: (error: Error) => void;
         traceContext?: TraceContext;
     }): Promise<import("@dynamic-labs/sdk-api-core").OpenRoomResponseWithServerKeygenIds>;
+    /**
+     * Plain-JSON (non-SSE) variant of `exportKey`. Hits the same
+     * `/privateKey/export` endpoint; the `x-idempotency-key` header tells the
+     * backend (when `enable-http-waas-transport-export` is on) to respond with
+     * the OpenRoomResponse synchronously instead of streaming `room_created`
+     * over SSE.
+     */
+    requestExportKeyJson({ mfaToken, elevatedAccessToken, dynamicRequestId, walletId, shareSetId, exportId, bitcoinConfig, onError, traceContext, idempotencyKey, timeoutMs, }: Omit<ExportWaasWalletPrivateKeyRequest, 'addressType'> & {
+        mfaToken?: string;
+        elevatedAccessToken?: string;
+        dynamicRequestId?: string;
+        walletId: string;
+        bitcoinConfig?: BitcoinConfig;
+        onError?: (error: Error) => void;
+        traceContext?: TraceContext;
+        idempotencyKey: string;
+        timeoutMs?: number;
+    }): Promise<OpenRoomResponse>;
     /**
      * Kick off the Aleo view-key export MPC ceremony. Returns the MPC room once
      * redcoast + wallet-service have joined; the client then joins the same