@seams/wallet 0.6.0 → 0.6.2

package/dist/types/wallet/src/core/rpcClients/relayer/walletRegistration.d.ts

@@ -661,6 +661,11 @@ export type WalletRegistrationRespondResponseV2 = {
     ecdsa?: never;
     ed25519: WalletRegistrationRespondEd25519DeferredWork;
 };
+export type WalletRegistrationNearAdmissionResponseV2 = {
+    ok: true;
+    registrationCeremonyId: string;
+    ed25519: WalletRegistrationRespondEd25519DeferredWork;
+};
 type WalletRegistrationSignerPlanKind = WalletRegistrationRespondResponseV2['kind'];
 type RespondWalletRegistrationArgsBase = {
     relayerUrl: string;
@@ -683,6 +688,7 @@ type RespondWalletRegistrationArgs = (RespondWalletRegistrationArgsBase & {
     ecdsa: WalletRegistrationRespondEcdsaRequest;
 });
 export declare function respondWalletRegistration(args: RespondWalletRegistrationArgs): Promise<WalletRegistrationRespondResponseV2>;
+export declare function authorizeWalletRegistrationNearAdmission(args: RespondWalletRegistrationArgsBase): Promise<WalletRegistrationNearAdmissionResponseV2>;
 /**
  * Refactor 94C route 3. Activate absorbs finalize: one call carries the
  * browser-verified activation facts and the Email OTP enrollment material that
@@ -783,14 +789,28 @@ export declare function activateWalletRegistration(args: ActivateWalletRegistrat
  * repeatable, so the caller reports provisioning state rather than unwinding
  * a wallet that already exists.
  */
-export type WalletRegistrationNearProvisioningResponseV2 = (Extract<WalletRegistrationFinalizeResponse, {
+type WalletRegistrationNearProvisioningFinalizeSuccessV2 = Extract<WalletRegistrationFinalizeResponse, {
     ok: true;
     kind: 'near_ed25519';
-}> & {
+}>;
+type WalletRegistrationNearProvisioningSuccessBaseV2 = {
     registrationEstablishedSession: RegistrationEstablishedSessionResultV2;
     nearProvisioning: {
         status: 'near_ready';
     };
+};
+export type WalletRegistrationNearProvisioningResponseV2 = (Extract<WalletRegistrationNearProvisioningFinalizeSuccessV2, {
+    authMethod: {
+        kind: 'passkey';
+    };
+}> & WalletRegistrationNearProvisioningSuccessBaseV2 & {
+    sessionSeal?: WalletRegistrationSessionSealResponse;
+}) | (Extract<WalletRegistrationNearProvisioningFinalizeSuccessV2, {
+    authMethod: {
+        kind: 'email_otp';
+    };
+}> & WalletRegistrationNearProvisioningSuccessBaseV2 & {
+    sessionSeal?: never;
 }) | {
     ok: false;
     code: string;
@@ -799,7 +819,13 @@ export type WalletRegistrationNearProvisioningResponseV2 = (Extract<WalletRegist
         status: 'near_failed_retryable';
     };
 };
-export declare function completeWalletRegistrationNearProvisioning(args: {
+export type WalletRegistrationSessionSealResponse = {
+    readonly ciphertext: string;
+    readonly keyVersion: string;
+    readonly expiresAtMs: number;
+    readonly remainingUses: number;
+};
+type CompleteWalletRegistrationNearProvisioningBaseArgs = {
     relayerUrl: string;
     headers?: Record<string, string>;
     registrationCeremonyId: string;
@@ -809,19 +835,32 @@ export declare function completeWalletRegistrationNearProvisioning(args: {
     ed25519: {
         activationReference: WalletRegistrationEd25519YaoActivationReference;
     };
-    auth: {
-        kind: 'passkey';
-    } | {
-        kind: 'email_otp';
-        enrollment: WalletRegistrationEmailOtpEnrollmentMaterial;
-    };
     /**
      * The custody ceremony's sealed output. For an Ed25519-only wallet this is
      * the call that establishes custody: activate had no key set to seal against.
      */
     walletCustodyCommit?: WalletCustodyCeremonyCommitPayload;
     onServerTiming?: (header: string | null) => void;
-}): Promise<WalletRegistrationNearProvisioningResponseV2>;
+};
+type CompleteWalletRegistrationNearProvisioningArgs = CompleteWalletRegistrationNearProvisioningBaseArgs & ({
+    auth: {
+        kind: 'passkey';
+    } | {
+        kind: 'email_otp';
+        enrollment: WalletRegistrationEmailOtpEnrollmentMaterial;
+    };
+    sessionSeal?: never;
+} | {
+    auth: {
+        kind: 'passkey';
+    };
+    sessionSeal: {
+        readonly thresholdSessionId: string;
+        readonly ciphertext: string;
+        readonly keyVersion?: string;
+    };
+});
+export declare function completeWalletRegistrationNearProvisioning(args: CompleteWalletRegistrationNearProvisioningArgs): Promise<WalletRegistrationNearProvisioningResponseV2>;
 type FinalizeWalletRegistrationBaseArgs = {
     relayerUrl: string;
     headers?: Record<string, string>;

package/dist/types/wallet/src/core/signingEngine/nonce/nearNonceLane.d.ts

@@ -3,6 +3,7 @@ import type { NonceLaneStatus } from '../../rpcClients/evm/nonceBackend';
 import type { TransactionContext } from '../../types/rpc';
 import type { AccessKeyView, BlockResult } from '@near-js/types';
 import { NonceDurableLeaseState, type NearNonceLane, type NearNonceLease, type NonceDurableLeaseLifecycle } from './nonceTypes';
+type NearFreshDataClient = Pick<NearClient, 'viewAccessKey' | 'viewBlock'>;
 export type NearAccessKeySubject = {
     walletId: string;
     nearAccountId: string;
@@ -184,7 +185,7 @@ export declare class NearAccountLookupFailedError extends Error {
 }
 export declare function fetchNearFreshDataForState(input: {
     state: NearNonceLaneState;
-    nearClient: NearClient;
+    nearClient: NearFreshDataClient;
     force?: boolean;
     now: () => number;
     nonceFreshnessThresholdMs: number;

package/dist/types/wallet/src/core/signingEngine/session/operationState/trace.d.ts

@@ -5,6 +5,8 @@ export declare function emitEcdsaServerTiming(operationId: string, phase: 'prepa
 export declare function emitEcdsaPresignServerTiming(presignSessionId: string, phase: 'init' | 'step', header: string | null): void;
 export type EcdsaSigningTimingStage = 'material_queue' | 'material_authorization' | 'material_load' | 'public_key_validation' | 'pool_lookup' | 'pool_restore' | 'refill_wait' | 'foreground_refill' | 'presignature_reserve' | 'prepare' | 'presignature_commit' | 'client_share' | 'finalize' | 'signature_verify' | 'sign_total' | 'transaction_assembly' | 'commit_total';
 export declare function emitEcdsaSigningTiming(operationId: string, stage: EcdsaSigningTimingStage, startedAt: number, outcome?: 'succeeded' | 'failed'): void;
+export type Ed25519SigningTimingStage = 'confirmed_to_signed' | 'prepare' | 'client_share' | 'finalize' | 'signature_total';
+export declare function emitEd25519SigningTiming(operationId: string, stage: Ed25519SigningTimingStage, startedAt: number, outcome?: 'succeeded' | 'failed'): void;
 export type SigningLaneResolutionTraceEvent = {
     event: 'signing_lane_resolved';
     lane: SigningLaneSummary;

package/dist/types/wallet/src/core/signingEngine/session/passkey/prfCache.d.ts

@@ -1,14 +1,12 @@
 import type { WarmSessionMaterialWriter, WarmSessionMaterialWriteDiagnostics } from './warmSessionMaterialWriter';
-type SigningSessionCacheTransport = Parameters<WarmSessionMaterialWriter['putWarmSessionMaterial']>[0]['transport'];
+import type { WarmSessionSealTransportState } from '../../../types/secure-confirm-worker';
 export type SigningSessionCacheEntry = {
-    thresholdSessionId: string;
-    prfFirstB64u: string;
-    expiresAtMs: number;
-    remainingUses: number;
-    transport?: SigningSessionCacheTransport;
-    diagnostics?: WarmSessionMaterialWriteDiagnostics;
-};
+    readonly thresholdSessionId: string;
+    readonly prfFirstB64u: string;
+    readonly expiresAtMs: number;
+    readonly remainingUses: number;
+    readonly diagnostics?: WarmSessionMaterialWriteDiagnostics;
+} & WarmSessionSealTransportState;
 export declare function generateSessionId(prefix: string): string;
 export declare function cacheCredentialBoundarySetupExportPrfFirst(writer: WarmSessionMaterialWriter, args: SigningSessionCacheEntry): Promise<void>;
-export {};
 //# sourceMappingURL=prfCache.d.ts.map

package/dist/types/wallet/src/core/signingEngine/session/passkey/warmSessionHydration.d.ts

@@ -1,13 +1,12 @@
-import type { WarmSessionSealTransportInput } from '../../../types/secure-confirm-worker';
+import type { WarmSessionSealTransportState } from '../../../types/secure-confirm-worker';
 import type { WarmSessionMaterialWriter, WarmSessionMaterialWriteDiagnostics } from './warmSessionMaterialWriter';
 export type HydrateWarmSigningSessionInput = {
-    thresholdSessionId: string;
-    prfFirstB64u: string;
-    expiresAtMs: number;
-    remainingUses: number;
-    transport?: WarmSessionSealTransportInput;
-    diagnostics?: WarmSessionMaterialWriteDiagnostics;
-};
+    readonly thresholdSessionId: string;
+    readonly prfFirstB64u: string;
+    readonly expiresAtMs: number;
+    readonly remainingUses: number;
+    readonly diagnostics?: WarmSessionMaterialWriteDiagnostics;
+} & WarmSessionSealTransportState;
 export type WarmSessionHydrationService = {
     hydrateSigningSession(input: HydrateWarmSigningSessionInput): Promise<void>;
 };

package/dist/types/wallet/src/core/signingEngine/session/passkey/warmSessionMaterialWriter.d.ts

@@ -1,14 +1,14 @@
-import type { WarmSessionSealTransportInput } from '../../../types/secure-confirm-worker';
+import type { WarmSessionSealTransportState } from '../../../types/secure-confirm-worker';
 import type { WarmSessionMaterialWriteDiagnostics } from '../warmCapabilities/types';
 export type { WarmSessionMaterialWriteDiagnosticBucket, WarmSessionMaterialWriteDiagnostics, } from '../warmCapabilities/types';
+export type WarmSessionMaterialWriteInput = {
+    readonly thresholdSessionId: string;
+    readonly prfFirstB64u: string;
+    readonly expiresAtMs: number;
+    readonly remainingUses: number;
+    readonly diagnostics?: WarmSessionMaterialWriteDiagnostics;
+} & WarmSessionSealTransportState;
 export interface WarmSessionMaterialWriter {
-    putWarmSessionMaterial(args: {
-        thresholdSessionId: string;
-        prfFirstB64u: string;
-        expiresAtMs: number;
-        remainingUses: number;
-        transport?: WarmSessionSealTransportInput;
-        diagnostics?: WarmSessionMaterialWriteDiagnostics;
-    }): Promise<void>;
+    putWarmSessionMaterial(args: WarmSessionMaterialWriteInput): Promise<void>;
 }
 //# sourceMappingURL=warmSessionMaterialWriter.d.ts.map

package/dist/types/wallet/src/core/signingEngine/session/warmCapabilities/public.d.ts

@@ -1,5 +1,5 @@
 import type { SigningSessionStatus } from '../../../types/seams';
-import type { WarmSessionSealTransportInput } from '../../../types/secure-confirm-worker';
+import type { WarmSessionSealTransportState } from '../../../types/secure-confirm-worker';
 import type { WarmSessionMaterialWriteDiagnostics } from './types';
 import type { ThresholdEcdsaChainTarget, WalletId } from '../../interfaces/ecdsaChainTarget';
 import { type WalletSigningSessionStatusDeps } from '../lifecycle/walletSessionStatus';
@@ -16,13 +16,12 @@ export type PersistThresholdEcdsaBootstrapForWalletTargetInput = {
     signerAuth: ThresholdEcdsaBootstrapSignerAuth;
 };
 export type HydrateSigningSessionInput = {
-    thresholdSessionId: string;
-    prfFirstB64u: string;
-    expiresAtMs: number;
-    remainingUses: number;
-    transport?: WarmSessionSealTransportInput;
-    diagnostics?: WarmSessionMaterialWriteDiagnostics;
-};
+    readonly thresholdSessionId: string;
+    readonly prfFirstB64u: string;
+    readonly expiresAtMs: number;
+    readonly remainingUses: number;
+    readonly diagnostics?: WarmSessionMaterialWriteDiagnostics;
+} & WarmSessionSealTransportState;
 export type WarmCapabilitiesPublicDeps = {
     statusReader: Pick<ThresholdWarmSessionStatusReader, 'getEd25519SigningSessionStatus'>;
     persistThresholdEcdsaBootstrapForWalletTarget: (args: PersistThresholdEcdsaBootstrapForWalletTargetInput) => Promise<void>;

package/dist/types/wallet/src/core/signingEngine/uiConfirm/PasskeyMpcSessionDurableState.d.ts

@@ -19,6 +19,9 @@ export declare class PasskeyMpcSessionDurableState {
         thresholdSessionId: string;
         transport: PasskeyWarmSessionSealTransportInput;
         diagnostics?: WarmSessionMaterialWriteDiagnostics;
+        completedSeal?: Extract<WarmSessionSealAndPersistResult, {
+            readonly ok: true;
+        }>;
     }): Promise<WarmSessionSealAndPersistResult>;
     recordPolicyResult(purpose: WarmSessionLanePurpose, thresholdSessionId: string, result: WarmSessionStatusResult | WarmSessionClaimResult): Promise<void>;
     updatePersistedPolicy(args: {

package/dist/types/wallet/src/core/signingEngine/uiConfirm/uiConfirm.types.d.ts

@@ -210,6 +210,12 @@ export interface PasskeyMpcSessionWorkerLifecyclePort {
         thresholdSessionId: string;
         prfFirstB64u: string;
     }): Promise<void>;
+    readPreparedSigningSessionHydration(input: {
+        preparationId: string;
+        thresholdSessionId: string;
+    }): Promise<{
+        readonly ciphertext: string;
+    }>;
     discardSigningSessionHydration(input: {
         preparationId: string;
         thresholdSessionId: string;

package/dist/types/wallet/src/core/signingEngine/workerManager/workers/shamir3pass/clientSealPreparation.d.ts

@@ -15,6 +15,8 @@ export declare class ClientSealPreparations {
     constructor(getRuntime: () => Promise<Shamir3PassRuntime>);
     prepare(sessionId: string, preparationId: string, secret: string): Promise<void>;
     take(sessionId: string, secret: string): Promise<PreparedClientSeal>;
+    readCiphertext(sessionId: string, preparationId: string): Promise<string>;
+    takeExact(sessionId: string, preparationId: string, secret: string): Promise<PreparedClientSeal>;
     discard(sessionId: string, preparationId: string): Promise<void>;
     clearSession(sessionId: string): void;
     clear(): void;

package/dist/types/wallet/src/core/types/secure-confirm-worker.d.ts

@@ -41,7 +41,7 @@ export interface UiConfirmManagerConfig {
     signingSessionSealGroupId?: string;
 }
 export type UserConfirmWorkerMessageType = UserConfirmWorkerMessage['type'];
-export type PasskeyMpcSessionWorkerMessageType = 'PING' | 'PREWARM_SHAMIR3PASS' | 'PREPARE_SESSION_CLIENT_SEAL' | 'DISCARD_SESSION_CLIENT_SEAL' | 'WARM_SESSION_MATERIAL_PUT' | 'WARM_SESSION_STATUS_READ' | 'WARM_SESSION_STATUS_BATCH_READ' | 'WARM_SESSION_MATERIAL_CLAIM' | 'WARM_SESSION_MATERIAL_CONSUME' | 'WARM_SESSION_VOLATILE_MATERIAL_CLEAR' | 'WARM_SESSION_VOLATILE_MATERIAL_CLEAR_ALL' | 'WARM_SESSION_SEAL_AND_PERSIST' | 'WARM_SESSION_REHYDRATE';
+export type PasskeyMpcSessionWorkerMessageType = 'PING' | 'PREWARM_SHAMIR3PASS' | 'PREPARE_SESSION_CLIENT_SEAL' | 'READ_SESSION_CLIENT_SEAL' | 'COMPLETE_SESSION_CLIENT_SEAL' | 'DISCARD_SESSION_CLIENT_SEAL' | 'WARM_SESSION_MATERIAL_PUT' | 'WARM_SESSION_STATUS_READ' | 'WARM_SESSION_STATUS_BATCH_READ' | 'WARM_SESSION_MATERIAL_CLAIM' | 'WARM_SESSION_MATERIAL_CONSUME' | 'WARM_SESSION_VOLATILE_MATERIAL_CLEAR' | 'WARM_SESSION_VOLATILE_MATERIAL_CLEAR_ALL' | 'WARM_SESSION_SEAL_AND_PERSIST' | 'WARM_SESSION_REHYDRATE';
 export type WarmSessionSealTransportInput = (EmailOtpWarmSessionSealTransportCommon & {
     curve: 'ed25519';
     authMethod: 'email_otp';
@@ -102,6 +102,20 @@ export interface WarmSessionSealAndPersistPayload {
     thresholdSessionId: string;
     transport: WarmSessionSealTransportInput;
 }
+export type PreparedWarmSessionServerSeal = {
+    readonly preparationId: string;
+    readonly ciphertext: string;
+    readonly keyVersion: string;
+    readonly expiresAtMs: number;
+    readonly remainingUses: number;
+};
+export type WarmSessionSealTransportState = {
+    readonly transport?: WarmSessionSealTransportInput;
+    readonly preparedServerSeal?: never;
+} | {
+    readonly transport: WarmSessionSealTransportInput;
+    readonly preparedServerSeal: PreparedWarmSessionServerSeal;
+};
 export interface WarmSessionRehydratePayload {
     thresholdSessionId: string;
     sealedSecretB64u: string;

package/dist/workers/passkey-mpc-session.worker.js

@@ -767,6 +767,26 @@ class ClientSealPreparations {
       throw result.error;
     return result.seal;
   }
+  async readCiphertext(sessionId, preparationId) {
+    const entry = this.entries.get(sessionId);
+    if (!entry || entry.id !== preparationId) {
+      throw new Error("Client seal preparation is unavailable");
+    }
+    const result = await entry.result;
+    if (this.entries.get(sessionId) !== entry) {
+      throw new Error("Client seal preparation was discarded");
+    }
+    if (result.kind === "failed")
+      throw result.error;
+    return result.seal.ciphertext;
+  }
+  async takeExact(sessionId, preparationId, secret) {
+    const entry = this.entries.get(sessionId);
+    if (!entry || entry.id !== preparationId) {
+      throw new Error("Client seal preparation is unavailable");
+    }
+    return await this.take(sessionId, secret);
+  }
   async discard(sessionId, preparationId) {
     const entry = this.entries.get(sessionId);
     if (!entry || entry.id !== preparationId)
@@ -849,6 +869,21 @@ function parseClientSealDiscard(value) {
   const thresholdSessionId = parseSessionString(Reflect.get(value, "thresholdSessionId"));
   return preparationId && thresholdSessionId ? { preparationId, thresholdSessionId } : null;
 }
+function parseClientSealCompletion(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const fields = Object.keys(value);
+  if (fields.length !== 4 || !fields.includes("preparationId") || !fields.includes("thresholdSessionId") || !fields.includes("transport") || !fields.includes("serverSeal")) {
+    return null;
+  }
+  const preparationId = parseSessionString(Reflect.get(value, "preparationId"));
+  const thresholdSessionId = parseSessionString(Reflect.get(value, "thresholdSessionId"));
+  const transport = parseSigningSessionSealTransport(Reflect.get(value, "transport"));
+  const serverSeal = parseSigningSessionSealRouteResult(Reflect.get(value, "serverSeal"));
+  if (!preparationId || !thresholdSessionId || !transport || !serverSeal.ok)
+    return null;
+  return { preparationId, thresholdSessionId, transport, serverSeal };
+}
 function parseWarmSessionMaterialPutPayload(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     return null;
@@ -1013,6 +1048,10 @@ function parsePasskeyMpcSessionWorkerMessage(value) {
       return { kind: "prewarm", ...id ? { id } : {} };
     case "PREPARE_SESSION_CLIENT_SEAL":
       return { kind: "prepare_client_seal", id, payload: parseClientSealPreparation(payload) };
+    case "READ_SESSION_CLIENT_SEAL":
+      return { kind: "read_client_seal", id, payload: parseClientSealDiscard(payload) };
+    case "COMPLETE_SESSION_CLIENT_SEAL":
+      return { kind: "complete_client_seal", id, payload: parseClientSealCompletion(payload) };
     case "DISCARD_SESSION_CLIENT_SEAL":
       return { kind: "discard_client_seal", id, payload: parseClientSealDiscard(payload) };
     case "WARM_SESSION_MATERIAL_PUT":
@@ -1523,24 +1562,26 @@ async function runSigningSessionSealAndPersist(args) {
   const task = (async () => {
     const diagnostics = createWarmSessionSealAndPersistDiagnostics();
     try {
-      const prepared = await clientSealPreparations.take(thresholdSessionId, activeEntry.secret.prfFirstB64u);
+      const prepared = args.kind === "prepared_response" ? await clientSealPreparations.takeExact(thresholdSessionId, args.preparationId, activeEntry.secret.prfFirstB64u) : await clientSealPreparations.take(thresholdSessionId, activeEntry.secret.prfFirstB64u);
       const { runtime, keyHandle, ciphertext: clientEncryptedCiphertext } = prepared;
       diagnostics.runtimeSetupMs = prepared.runtimeSetupMs;
       diagnostics.clientSealMs = prepared.clientSealMs;
       try {
         const serverSealRouteStartedAt = performance.now();
-        const applied = await callSigningSessionSealRoute({
+        const applied = args.kind === "prepared_response" ? args.serverSeal : await callSigningSessionSealRoute({
           operation: "apply-server-seal",
           transport: args.transport,
           thresholdSessionId,
           ciphertext: clientEncryptedCiphertext,
           keyVersion: args.transport.keyVersion
         });
-        recordWarmSessionSealAndPersistDiagnosticDuration({
-          diagnostics,
-          bucket: "serverSealRouteMs",
-          startedAt: serverSealRouteStartedAt
-        });
+        if (args.kind === "server_route") {
+          recordWarmSessionSealAndPersistDiagnosticDuration({
+            diagnostics,
+            bucket: "serverSealRouteMs",
+            startedAt: serverSealRouteStartedAt
+          });
+        }
         if (!applied.ok)
           return applied;
         const policyUpdateStartedAt = performance.now();
@@ -1740,6 +1781,40 @@ async function handleClientSealPreparation(incoming) {
     });
   }
 }
+async function handleClientSealRead(incoming) {
+  try {
+    if (!incoming.payload)
+      throw new Error("Invalid client seal read request");
+    const ciphertext = await clientSealPreparations.readCiphertext(incoming.payload.thresholdSessionId, incoming.payload.preparationId);
+    postPasskeyMpcSessionWorkerResponse(incoming.id, {
+      success: true,
+      data: { ok: true, ciphertext }
+    });
+  } catch (error) {
+    postPasskeyMpcSessionWorkerResponse(incoming.id, {
+      success: false,
+      error: error instanceof Error ? error.message : "Client seal read failed"
+    });
+  }
+}
+async function handleClientSealCompletion(incoming) {
+  const payload = incoming.payload;
+  if (!payload) {
+    postPasskeyMpcSessionWorkerResponse(incoming.id, {
+      success: false,
+      error: "Invalid client seal completion request"
+    });
+    return;
+  }
+  const result = await runSigningSessionSealAndPersist({
+    kind: "prepared_response",
+    thresholdSessionId: payload.thresholdSessionId,
+    preparationId: payload.preparationId,
+    transport: payload.transport,
+    serverSeal: payload.serverSeal
+  });
+  postPasskeyMpcSessionWorkerResponse(incoming.id, { success: true, data: result });
+}
 self.onmessage = (event) => {
   const incoming = parsePasskeyMpcSessionWorkerMessage(event.data);
   switch (incoming.kind) {
@@ -1747,6 +1822,12 @@ self.onmessage = (event) => {
     case "discard_client_seal":
       handleClientSealPreparation(incoming);
       return;
+    case "read_client_seal":
+      handleClientSealRead(incoming);
+      return;
+    case "complete_client_seal":
+      handleClientSealCompletion(incoming);
+      return;
     case "ping":
       postPasskeyMpcSessionWorkerResponse(incoming.id, { success: true, data: { ok: true } });
       return;
@@ -1877,7 +1958,10 @@ self.onmessage = (event) => {
           });
           return;
         }
-        const result = await runSigningSessionSealAndPersist(payload);
+        const result = await runSigningSessionSealAndPersist({
+          kind: "server_route",
+          ...payload
+        });
         postPasskeyMpcSessionWorkerResponse(incoming.id, { success: true, data: result });
       })();
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seams/wallet",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "type": "module",
   "description": "Seams web and runtime TypeScript SDK for NEAR and EVM-family wallets",
   "main": "./dist/esm/index.js",