@fhevm/sdk 1.1.0-alpha.5 → 1.1.0-alpha.7

package/core/kms/{kmsDelegatedUserDecryptEip712Types.ts → kmsDelegatedUserDecryptEip712V1Types.ts}

@@ -1,10 +1,11 @@
-import type { KmsDelegateUserDecryptEip712Types } from '../types/kms.js';
+import type { KmsDelegatedUserDecryptEip712V1Types } from '../types/kms.js';
 
 ////////////////////////////////////////////////////////////////////////////////
-// KmsDelegateUserDecryptEIP712Types
+// KmsDelegatedUserDecryptEip712V1Types
 ////////////////////////////////////////////////////////////////////////////////
 
-export const kmsDelegatedUserDecryptEip712Types: KmsDelegateUserDecryptEip712Types = {
+// Careful: do not change any fields in this structure
+export const kmsDelegatedUserDecryptEip712V1Types: KmsDelegatedUserDecryptEip712V1Types = {
   EIP712Domain: [
     { name: 'name', type: 'string' },
     { name: 'version', type: 'string' },
@@ -24,8 +25,8 @@ export const kmsDelegatedUserDecryptEip712Types: KmsDelegateUserDecryptEip712Typ
   ] as const,
 } as const;
 
-Object.freeze(kmsDelegatedUserDecryptEip712Types);
-Object.freeze(kmsDelegatedUserDecryptEip712Types.EIP712Domain);
-Object.freeze(kmsDelegatedUserDecryptEip712Types.DelegatedUserDecryptRequestVerification);
-kmsDelegatedUserDecryptEip712Types.EIP712Domain.forEach(Object.freeze);
-kmsDelegatedUserDecryptEip712Types.DelegatedUserDecryptRequestVerification.forEach(Object.freeze);
+Object.freeze(kmsDelegatedUserDecryptEip712V1Types);
+Object.freeze(kmsDelegatedUserDecryptEip712V1Types.EIP712Domain);
+Object.freeze(kmsDelegatedUserDecryptEip712V1Types.DelegatedUserDecryptRequestVerification);
+kmsDelegatedUserDecryptEip712V1Types.EIP712Domain.forEach(Object.freeze);
+kmsDelegatedUserDecryptEip712V1Types.DelegatedUserDecryptRequestVerification.forEach(Object.freeze);

package/core/kms/kmsPublicDecryptEip712Types.ts

@@ -1,7 +1,7 @@
 import type { KmsPublicDecryptEip712Types } from '../types/kms.js';
 
 ////////////////////////////////////////////////////////////////////////////////
-// KmsPublicDecryptEIP712Types
+// KmsPublicDecryptEip712Types
 ////////////////////////////////////////////////////////////////////////////////
 
 export const kmsPublicDecryptEip712Types: KmsPublicDecryptEip712Types = {

package/core/kms/{kmsUserDecryptEip712Types.ts → kmsUserDecryptEip712V1Types.ts}

@@ -1,10 +1,11 @@
-import type { KmsUserDecryptEip712Types } from '../types/kms.js';
+import type { KmsUserDecryptEip712V1Types } from '../types/kms.js';
 
 ////////////////////////////////////////////////////////////////////////////////
-// KmsUserDecryptEIP712Types
+// KmsUserDecryptEip712V1Types
 ////////////////////////////////////////////////////////////////////////////////
 
-export const kmsUserDecryptEip712Types: KmsUserDecryptEip712Types = {
+// Careful: do not change any fields in this structure
+export const kmsUserDecryptEip712V1Types: KmsUserDecryptEip712V1Types = {
   EIP712Domain: [
     { name: 'name', type: 'string' },
     { name: 'version', type: 'string' },
@@ -23,8 +24,8 @@ export const kmsUserDecryptEip712Types: KmsUserDecryptEip712Types = {
   ] as const,
 } as const;
 
-Object.freeze(kmsUserDecryptEip712Types);
-Object.freeze(kmsUserDecryptEip712Types.EIP712Domain);
-Object.freeze(kmsUserDecryptEip712Types.UserDecryptRequestVerification);
-kmsUserDecryptEip712Types.EIP712Domain.forEach(Object.freeze);
-kmsUserDecryptEip712Types.UserDecryptRequestVerification.forEach(Object.freeze);
+Object.freeze(kmsUserDecryptEip712V1Types);
+Object.freeze(kmsUserDecryptEip712V1Types.EIP712Domain);
+Object.freeze(kmsUserDecryptEip712V1Types.UserDecryptRequestVerification);
+kmsUserDecryptEip712V1Types.EIP712Domain.forEach(Object.freeze);
+kmsUserDecryptEip712V1Types.UserDecryptRequestVerification.forEach(Object.freeze);

package/core/kms/kmsUserDecryptEip712V2Types.ts

@@ -1,9 +1,10 @@
 import type { KmsUserDecryptEip712V2Types } from '../types/kms.js';
 
 ////////////////////////////////////////////////////////////////////////////////
-// KmsUserDecryptEIP712V2Types (RFC-016)
+// KmsUserDecryptEip712V2Types (RFC-016)
 ////////////////////////////////////////////////////////////////////////////////
 
+// Careful: do not change any fields in this structure
 export const kmsUserDecryptEip712V2Types: KmsUserDecryptEip712V2Types = {
   EIP712Domain: [
     { name: 'name', type: 'string' },

package/core/kms/publicDecrypt.ts

@@ -73,7 +73,7 @@ export async function publicDecrypt(context: Context, parameters: Parameters): P
   // 5. Call relayer
   const {
     orderedAbiEncodedClearValues,
-    kmsPublicDecryptEIP712Signatures,
+    kmsPublicDecryptEip712Signatures,
     extraData: relayerExtraData,
   } = await context.runtime.relayer.fetchPublicDecrypt(context, {
     payload: {
@@ -97,7 +97,7 @@ export async function publicDecrypt(context: Context, parameters: Parameters): P
     originToken,
     orderedHandles: orderedHandles,
     orderedAbiEncodedClearValues,
-    kmsPublicDecryptEIP712Signatures,
+    kmsPublicDecryptEip712Signatures,
     kmsSignersContext: reconciledKmsSignersContext,
   });
 

package/core/kms/utils.ts

@@ -26,35 +26,3 @@ export function assertKmsDecryptionBitLimit(handles: readonly Handle[]): UintNum
 
   return total as UintNumber;
 }
-
-export function assertKmsEIP712DeadlineValidity(
-  {
-    startTimestamp,
-    durationDays,
-  }: {
-    startTimestamp: bigint | number | string;
-    durationDays: bigint | number | string;
-  },
-  maxDurationDays: UintNumber,
-): void {
-  if (durationDays === 0) {
-    throw Error('durationDays is zero');
-  }
-
-  const durationDaysBigInt = BigInt(durationDays);
-  if (durationDaysBigInt > BigInt(maxDurationDays)) {
-    throw Error(`durationDays is above max duration of ${maxDurationDays}`);
-  }
-
-  const startTimestampBigInt = BigInt(startTimestamp);
-
-  const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
-  if (startTimestampBigInt > currentTimestamp) {
-    throw Error('startTimestamp is set in the future');
-  }
-
-  const durationInSeconds = durationDaysBigInt * BigInt(24 * 60 * 60);
-  if (startTimestampBigInt + durationInSeconds < currentTimestamp) {
-    throw Error('request has expired');
-  }
-}

package/core/kms/verifyKmsPublicDecryptEip712-p.ts

@@ -19,7 +19,7 @@ type Context = {
 type Parameters = {
   readonly orderedHandles: readonly Handle[];
   readonly orderedAbiEncodedClearValues: BytesHex;
-  readonly kmsPublicDecryptEIP712Signatures: readonly Bytes65Hex[];
+  readonly kmsPublicDecryptEip712Signatures: readonly Bytes65Hex[];
   readonly kmsSignersContext: KmsSignersContext;
 };
 
@@ -28,7 +28,7 @@ type Parameters = {
 export async function verifyKmsPublicDecryptEip712(context: Context, parameters: Parameters): Promise<void> {
   const { kmsSignersContext, orderedHandles: orderedEncryptedValues, orderedAbiEncodedClearValues } = parameters;
 
-  // TODO:  use createKmsPublicDecryptEIP712 instead!
+  // TODO:  use createKmsPublicDecryptEip712 instead!
 
   const extraData: BytesHex = kmsSignersContextToExtraData(kmsSignersContext);
 
@@ -66,7 +66,7 @@ export async function verifyKmsPublicDecryptEip712(context: Context, parameters:
     domain,
     types: kmsPublicDecryptEip712Types,
     primaryType: 'PublicDecryptVerification',
-    signatures: parameters.kmsPublicDecryptEIP712Signatures,
+    signatures: parameters.kmsPublicDecryptEip712Signatures,
     message,
   });
 

package/core/modules/decrypt/module/api-p.ts

@@ -76,7 +76,7 @@ type TypedPlaintextWasmType = TypedPlaintext & {
   readonly [__TypedPlaintextWasm]: never;
 };
 
-type KmsEIP712DomainWasmType = Readonly<
+type KmsEip712DomainWasmType = Readonly<
   Omit<KmsEip712Domain, 'chainId' | 'verifyingContract'> & {
     readonly chain_id: Uint8Array;
     readonly verifying_contract: ChecksummedAddress;
@@ -297,16 +297,16 @@ export async function decryptAndReconstruct(
     kmsLib,
   );
 
-  // KmsEIP712Domain
-  const kmsEIP712Domain: KmsEip712Domain = metadata.eip712Domain;
+  // KmsEip712Domain
+  const kmsEip712Domain: KmsEip712Domain = metadata.eip712Domain;
   const clientAddress: ChecksummedAddress = metadata.eip712SignerAddress;
 
   // To be modified! use uint64ToBytes32 instead
-  const eip712DomainWasmArg: KmsEIP712DomainWasmType = {
-    name: kmsEIP712Domain.name,
-    version: kmsEIP712Domain.version,
-    chain_id: uint32ToBytes32(kmsEIP712Domain.chainId), // gateway chainId
-    verifying_contract: kmsEIP712Domain.verifyingContract,
+  const eip712DomainWasmArg: KmsEip712DomainWasmType = {
+    name: kmsEip712Domain.name,
+    version: kmsEip712Domain.version,
+    chain_id: uint32ToBytes32(kmsEip712Domain.chainId), // gateway chainId
+    verifying_contract: kmsEip712Domain.verifyingContract,
     salt: null,
   };
 

package/core/modules/decrypt/module/init-p.ts

@@ -6,95 +6,171 @@ import type {
   TkmsModuleInfo,
 } from '../types.js';
 import type { KmsLibApi, TkmsVersion } from '../../../../wasm/tkms/KmsLibApi.js';
-import type { KmsAssetMetadata } from '../../../../wasm/tkms/loadKmsLib.js';
-import { isBrowserLike } from '../../../base/isomorphicWorker.js';
+import type { KmsAssetMetadata, KmsAssets } from '../../../../wasm/tkms/loadKmsLib.js';
+import { isBrowserLike } from '../../../base/environment.js';
 import { isomorphicCompileVerifiedWasm, isomorphicCompileWasmFromBase64 } from '../../../base/wasm.js';
 import { assertIsFhevmRuntime } from '../../../runtime/CoreFhevmRuntime-p.js';
-import { wasmBaseUrl } from '../../../../wasm/wasmBaseUrl.js';
 import { kmsAssetsWithVersion, loadKmsLib, loadKmsWasmBase64 } from '../../../../wasm/tkms/loadKmsLib.js';
+import { isomorphicFileUrlExists } from '../../../base/isomorphicFs.js';
 
 ////////////////////////////////////////////////////////////////////////////////
 
-const ownerUidByVersion = new Map<TkmsVersion, string>();
-const cachedTkmsModulePromiseByVersion = new Map<TkmsVersion, Promise<KmsLibApi>>();
-const moduleInfoByVersion = new Map<TkmsVersion, TkmsModuleInfo>();
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Pure JS file (not compiled by tsc) — provides cross-platform base URL
-// for resolving WASM paths. Uses import.meta.url in ESM, __filename in CJS.
-
 // (Node only) Path relative to src/wasm/ where wasmBaseUrl is anchored
-const nodeDefaultLocateFile = (file: string): URL => {
+const nodeDefaultLocateFile = async (file: string): Promise<URL> => {
+  // Pure JS file (not compiled by tsc) — provides cross-platform base URL
+  // for resolving WASM paths. Uses import.meta.url in ESM, __filename in CJS.
+  const { wasmBaseUrl } = await import('../../../../wasm/wasmBaseUrl.js');
   return new URL(`./tkms/${file}`, wasmBaseUrl);
 };
 
+////////////////////////////////////////////////////////////////////////////////
+
+type KmsAssetResolution = 'user' | 'node' | 'none';
+
 type ResolvedKmsAsset = KmsAssetMetadata & {
   readonly url: URL | undefined;
+  readonly resolution: KmsAssetResolution;
 };
 
-function _resolveKmsAsset(asset: KmsAssetMetadata, locateFile: FhevmRuntimeConfig['locateFile']): ResolvedKmsAsset {
+type ResolvedKmsAssets = {
+  readonly wasm: ResolvedKmsAsset;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+async function _resolveSingleKmsAsset(
+  asset: KmsAssetMetadata,
+  locateFile: FhevmRuntimeConfig['locateFile'],
+): Promise<ResolvedKmsAsset> {
   let url: URL | undefined;
+  let resolution: KmsAssetResolution = 'none';
 
   if (locateFile !== undefined) {
-    url = locateFile(asset.filename);
+    const located = locateFile(asset.filename) as unknown;
+    if (located === null || located === undefined) {
+      url = undefined;
+    } else if (located instanceof URL) {
+      url = located;
+    } else {
+      throw new TypeError(
+        `Invalid locateFile result for TKMS asset '${asset.filename}': expected URL, null, or undefined.`,
+      );
+    }
+    resolution = 'user';
   } else if (!isBrowserLike()) {
-    url = nodeDefaultLocateFile(asset.localRelativePath);
+    url = await nodeDefaultLocateFile(asset.localRelativePath);
+    resolution = 'node';
+  }
+
+  return Object.freeze({ ...asset, url, resolution });
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+async function _resolveKmsAssets(
+  assets: KmsAssets,
+  locateFile: FhevmRuntimeConfig['locateFile'],
+): Promise<{ readonly wasm: ResolvedKmsAsset }> {
+  let wasm = await _resolveSingleKmsAsset(assets.wasm, locateFile);
+
+  // Only auto-derived ('node') file:// URLs need on-disk validation; the mode is
+  // shared across all assets, so checking one is enough to know the set's mode.
+  if (wasm.resolution === 'node') {
+    const allExist = await isomorphicFileUrlExists(wasm.url);
+    if (!allExist) {
+      wasm = Object.freeze({ ...wasm, url: undefined });
+    }
   }
 
-  return Object.freeze({ ...asset, url });
+  return { wasm };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+function _logResolvedKmsAssets(resolvedAssets: ResolvedKmsAssets, logger: FhevmRuntimeConfig['logger']): void {
+  const { wasm } = resolvedAssets;
+  if (wasm.resolution === 'user') {
+    logger?.debug?.(`resolve tkms wasm filename using 'locateFile' function: ${wasm.filename} -> url: ${wasm.url}`);
+  } else if (wasm.resolution === 'node') {
+    if (wasm.url === undefined) {
+      // Auto-derived assets were missing on disk (e.g. a bundler such as Turbopack
+      // relocated the package) and were cleared by _resolveTkmsAssets -> base64.
+      logger?.debug?.(
+        `tkms auto-derived assets not found on disk (bundler relocation?); using embedded base64 ` +
+          `(wasm: ${wasm.localRelativePath})`,
+      );
+    } else {
+      logger?.debug?.(`resolve tkms wasm local path: ${wasm.localRelativePath} -> url: ${wasm.url}`);
+    }
+  } else {
+    // 'none': browser zero-config (no 'locateFile', not Node) -> embedded base64.
+    logger?.debug?.(`resolve tkms assets using embedded base64 (browser, no 'locateFile')`);
+  }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
 type ResolvedTkmsModuleConfig = {
   readonly version: TkmsVersion;
-  readonly wasm: ResolvedKmsAsset;
+  readonly assets: ResolvedKmsAssets;
   readonly logger: FhevmRuntimeConfig['logger'];
 };
 
 const resolvedTkmsModuleConfigByVersion = new Map<TkmsVersion, ResolvedTkmsModuleConfig>();
+const resolvingTkmsModuleConfigPromiseByVersion = new Map<TkmsVersion, Promise<ResolvedTkmsModuleConfig>>();
 
 /**
  * @internal
- * Returns the existing resolved config, or resolves it from the runtime config.
+ * Returns the existing resolved config for a TKMS version, or resolves it from
+ * the runtime config.
  */
-function _getOrResolveTkmsModuleConfig(runtime: FhevmRuntime, tkmsVersion: TkmsVersion): ResolvedTkmsModuleConfig {
-  let resolvedTkmsModuleConfig = resolvedTkmsModuleConfigByVersion.get(tkmsVersion);
+async function _getOrResolveTkmsModuleConfig(
+  runtime: FhevmRuntime,
+  tkmsVersion: TkmsVersion,
+): Promise<ResolvedTkmsModuleConfig> {
+  const resolvedTkmsModuleConfig = resolvedTkmsModuleConfigByVersion.get(tkmsVersion);
   if (resolvedTkmsModuleConfig !== undefined) {
     return resolvedTkmsModuleConfig;
   }
 
-  resolvedTkmsModuleConfig = _resolveTkmsModuleConfig(runtime.config, tkmsVersion);
-
-  resolvedTkmsModuleConfigByVersion.set(tkmsVersion, resolvedTkmsModuleConfig);
+  let resolvingTkmsModuleConfigPromise = resolvingTkmsModuleConfigPromiseByVersion.get(tkmsVersion);
+  if (resolvingTkmsModuleConfigPromise === undefined) {
+    resolvingTkmsModuleConfigPromise = _resolveTkmsModuleConfig(runtime.config, tkmsVersion)
+      .then((cfg) => {
+        resolvedTkmsModuleConfigByVersion.set(tkmsVersion, cfg);
+        return cfg;
+      })
+      .catch((error: unknown) => {
+        resolvingTkmsModuleConfigPromiseByVersion.delete(tkmsVersion);
+        throw error;
+      });
+
+    resolvingTkmsModuleConfigPromiseByVersion.set(tkmsVersion, resolvingTkmsModuleConfigPromise);
+  }
 
-  return resolvedTkmsModuleConfig;
+  return resolvingTkmsModuleConfigPromise;
 }
 
-function _resolveTkmsModuleConfig(parameters: FhevmRuntimeConfig, version: TkmsVersion): ResolvedTkmsModuleConfig {
+async function _resolveTkmsModuleConfig(
+  parameters: FhevmRuntimeConfig,
+  version: TkmsVersion,
+): Promise<ResolvedTkmsModuleConfig> {
   const { locateFile } = parameters;
 
   const assets = kmsAssetsWithVersion(version);
-  const wasm = _resolveKmsAsset(assets.wasm, locateFile);
 
-  if (locateFile !== undefined) {
-    parameters.logger?.debug(`resolve kms wasm filename: ${wasm.filename} -> url: ${wasm.url}`);
-  } else {
-    /*
-      if run in Node only, use defaultLocateFile!
-    */
-    if (!isBrowserLike()) {
-      parameters.logger?.debug(`resolve kms wasm local path: ${wasm.localRelativePath} -> url: ${wasm.url}`);
-    }
-  }
+  const resolvedAssets = await _resolveKmsAssets(assets, locateFile);
+
+  _logResolvedKmsAssets(resolvedAssets, parameters.logger);
 
   // if wasmUrl is undefined, use base64 code instead
   const cfg = {
     version,
-    wasm,
+    assets: resolvedAssets,
     logger: parameters.logger,
   };
 
-  parameters.logger?.debug(JSON.stringify(cfg, null, 2));
+  //parameters.logger?.debug?.(JSON.stringify(cfg, null, 2));
 
   return cfg;
 }
@@ -103,6 +179,12 @@ function _resolveTkmsModuleConfig(parameters: FhevmRuntimeConfig, version: TkmsV
 // initTkmsModule
 ////////////////////////////////////////////////////////////////////////////////
 
+const ownerUidByVersion = new Map<TkmsVersion, string>();
+const cachedTkmsModulePromiseByVersion = new Map<TkmsVersion, Promise<KmsLibApi>>();
+const moduleInfoByVersion = new Map<TkmsVersion, TkmsModuleInfo>();
+
+////////////////////////////////////////////////////////////////////////////////
+
 type TkmsInitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 type TkmsLibInitAsyncParameters = {
@@ -121,40 +203,47 @@ export async function initTkmsModule(runtime: FhevmRuntime, parameters: InitTkms
 
   ownerUidByVersion.set(parameters.tkmsVersion, runtime.uid);
 
-  // Cache the TKMS initialization promise once and keep it cached even if it
-  // rejects.
+  // Cache the whole initialization promise before the first await. Several
+  // clients may call initTkmsModule concurrently during startup.
   //
-  // Retry is not supported:
-  // -----------------------
-  // The underlying KMS/WASM bindings
-  // keep module-level state that cannot be reset reliably after a partial
-  // initialization failure; later callers should observe the original error
-  // instead of retrying against half-initialized state.
+  // Retry is not supported
 
   let cachedTkmsModulePromise = cachedTkmsModulePromiseByVersion.get(parameters.tkmsVersion);
   if (cachedTkmsModulePromise === undefined) {
-    // resolve is sync
-    const cfg = _getOrResolveTkmsModuleConfig(runtime, parameters.tkmsVersion);
-    cachedTkmsModulePromise = _initTkmsModule(cfg);
+    cachedTkmsModulePromise = (async () => {
+      // resolve is async
+      const cfg = await _getOrResolveTkmsModuleConfig(runtime, parameters.tkmsVersion);
+      return await _initTkmsModule(cfg);
+    })();
+
     cachedTkmsModulePromiseByVersion.set(parameters.tkmsVersion, cachedTkmsModulePromise);
   }
 
   return cachedTkmsModulePromise;
 }
 
+async function _compileWasmModule(cfg: ResolvedTkmsModuleConfig): Promise<WebAssembly.Module> {
+  let wasmModule;
+
+  if (cfg.assets.wasm.url !== undefined) {
+    cfg.logger?.debug?.(`compile tkms verified wasm at: ${cfg.assets.wasm.url}`);
+    wasmModule = await isomorphicCompileVerifiedWasm(cfg.assets.wasm.url, cfg.assets.wasm.sha256);
+  } else {
+    const { tkmsWasmBase64, tkmsWasmBase64CompressionFormat } = await loadKmsWasmBase64(cfg.version);
+    cfg.logger?.debug?.(
+      `compile tkms wasm from embedded base64 (compression:${tkmsWasmBase64CompressionFormat ?? 'none'})`,
+    );
+    wasmModule = await isomorphicCompileWasmFromBase64(tkmsWasmBase64, tkmsWasmBase64CompressionFormat);
+  }
+
+  return wasmModule;
+}
+
 async function _initTkmsModule(cfg: ResolvedTkmsModuleConfig): Promise<KmsLibApi> {
   const kmsLib = await loadKmsLib(cfg.version);
 
   // Compile WASM module (see matrix in types.ts)
-  let wasmModule;
-  if (cfg.wasm.url !== undefined) {
-    cfg.logger?.debug(`compile verified wasm at: ${cfg.wasm.url}`);
-    wasmModule = await isomorphicCompileVerifiedWasm(cfg.wasm.url, cfg.wasm.sha256);
-  } else {
-    const { tkmsWasmBase64, tkmsWasmBase64IsGzipped } = await loadKmsWasmBase64(cfg.version);
-    cfg.logger?.debug(`compile wasm from embedded base64 (compression:${tkmsWasmBase64IsGzipped})`);
-    wasmModule = await isomorphicCompileWasmFromBase64(tkmsWasmBase64, tkmsWasmBase64IsGzipped ? 'gzip' : undefined);
-  }
+  const wasmModule = await _compileWasmModule(cfg);
 
   const input: TkmsLibInitAsyncParameters = { module_or_path: wasmModule };
 
@@ -171,7 +260,7 @@ async function _initTkmsModule(cfg: ResolvedTkmsModuleConfig): Promise<KmsLibApi
   moduleInfoByVersion.set(
     cfg.version,
     Object.freeze({
-      wasmUrl: cfg.wasm.url ? new URL(cfg.wasm.url) : undefined,
+      wasmUrl: cfg.assets.wasm.url ? new URL(cfg.assets.wasm.url) : undefined,
       version: wasmInfo.version,
       name: wasmInfo.name,
       memory,