@metamask/snaps-cli 3.0.5 → 4.0.1

package/CHANGELOG.md

@@ -6,6 +6,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [4.0.1]
+### Fixed
+- Fix missing `global` during snap evaluation ([#2072](https://github.com/MetaMask/snaps/pull/2072))
+
+## [4.0.0]
+### Changed
+- **BREAKING:** Synchronously initialize WASM modules ([#2024](https://github.com/MetaMask/snaps/pull/2024))
+  - When the `experimental.wasm` flag in the Snaps CLI is enabled, the WASM module will now be synchronously initialized, rather than being inlined as a Uint8Array.
+
 ## [3.0.5]
 ### Fixed
 - Include Snap icon in allowed server paths ([#2003](https://github.com/MetaMask/snaps/pull/2003))
@@ -86,7 +95,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - The version of the package no longer needs to match the version of all other
     MetaMask Snaps packages.
 
-[Unreleased]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-cli@3.0.5...HEAD
+[Unreleased]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-cli@4.0.1...HEAD
+[4.0.1]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-cli@4.0.0...@metamask/snaps-cli@4.0.1
+[4.0.0]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-cli@3.0.5...@metamask/snaps-cli@4.0.0
 [3.0.5]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-cli@3.0.4...@metamask/snaps-cli@3.0.5
 [3.0.4]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-cli@3.0.3...@metamask/snaps-cli@3.0.4
 [3.0.3]: https://github.com/MetaMask/snaps/compare/@metamask/snaps-cli@3.0.2...@metamask/snaps-cli@3.0.3

package/README.md

@@ -422,7 +422,7 @@ can be imported in the snap, for example:
 ```typescript
 import program from './program.wasm';
 
-const module = await WebAssembly.instantiate(program, {});
+// Program is initialised synchronously.
 // ...
 ```
 

package/dist/cjs/webpack/loaders/wasm.js

@@ -1,36 +1,90 @@
-"use strict";
+/* eslint-disable no-restricted-globals */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, /**
- * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes
- * it possible to import the WASM module directly, and use it with the
- * `WebAssembly.instantiate` function.
- *
- * This is useful, because snaps are not allowed to import assets from outside
- * of their package. This loader allows you to inline the WASM module as a
- * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getImports: function() {
+        return getImports;
+    },
+    getModuleImports: function() {
+        return getModuleImports;
+    },
+    getExports: function() {
+        return getExports;
+    },
+    default: function() {
+        return _default;
+    },
+    raw: function() {
+        return raw;
+    }
+});
+const _utils = require("@metamask/utils");
+function getImports(importMap) {
+    return Object.entries(importMap).map(([moduleName, exportNames])=>`import { ${exportNames.join(', ')} } from ${JSON.stringify(moduleName)};`).join('\n');
+}
+function getModuleImports(importMap) {
+    return Object.entries(importMap).map(([moduleName, exportNames])=>`${JSON.stringify(moduleName)}: { ${exportNames.join(', ')} },`).join('\n');
+}
+function getExports(descriptors) {
+    return descriptors.map((descriptor)=>{
+        if (descriptor.name === 'default') {
+            return `export default exports[${JSON.stringify(descriptor.name)}];`;
+        }
+        return `export const ${descriptor.name} = exports[${JSON.stringify(descriptor.name)}];`;
+    }).join('\n');
+}
+/**
+ * A Webpack loader that synchronously loads the WASM module. This makes it
+ * possible to import the WASM module directly.
  *
- * @param source - The WASM module as a string.
- * @returns A string that exports the WASM module as a `Uint8Array`.
+ * @param source - The WASM module as `Uint8Array`.
+ * @returns The WASM module as a JavaScript string.
  * @example
  * ```ts
- * import wasm from './program.wasm';
+ * import * as wasm from './program.wasm';
  *
- * const { instance } = await WebAssembly.instantiate(wasm, {});
  * // Do something with the WASM module...
  * ```
- */ "default", {
-    enumerable: true,
-    get: function() {
-        return loader;
+ */ // Note: This function needs to be defined like this, so that Webpack can bind
+// `this` to the loader context, and TypeScript can infer the type of `this`.
+const loader = async function loader(source) {
+    (0, _utils.assert)(source instanceof Uint8Array, 'Expected source to be a Uint8Array.');
+    const bytes = new Uint8Array(source);
+    const wasmModule = await WebAssembly.compile(bytes);
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    const exports1 = WebAssembly.Module.exports(wasmModule);
+    const imports = WebAssembly.Module.imports(wasmModule).reduce((target, descriptor)=>{
+        var _target, _descriptor_module;
+        (_target = target)[_descriptor_module = descriptor.module] ?? (_target[_descriptor_module] = []);
+        target[descriptor.module].push(descriptor.name);
+        return target;
+    }, {});
+    // Add the WASM import as a dependency so that Webpack will watch it for
+    // changes.
+    for (const name of Object.keys(imports)){
+        this.addDependency(name);
     }
-});
-const _utils = require("@metamask/utils");
-function loader(source) {
-    (0, _utils.assert)(typeof source === 'string', 'Expected source to be a string.');
-    const bytes = (0, _utils.stringToBytes)(source);
-    return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;
-}
+    return `
+    ${getImports(imports)}
+
+    const bytes = new Uint8Array(${JSON.stringify(Array.from(source))});
+    const module = new WebAssembly.Module(bytes);
+    const instance = new WebAssembly.Instance(module, {
+      ${getModuleImports(imports)}
+    });
+
+    const exports = instance.exports;
+    ${getExports(exports1)}
+  `;
+};
+const _default = loader;
+const raw = true;
 
 //# sourceMappingURL=wasm.js.map

package/dist/cjs/webpack/loaders/wasm.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/webpack/loaders/wasm.ts"],"sourcesContent":["import { assert, stringToBytes } from '@metamask/utils';\n\n/**\n * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes\n * it possible to import the WASM module directly, and use it with the\n * `WebAssembly.instantiate` function.\n *\n * This is useful, because snaps are not allowed to import assets from outside\n * of their package. This loader allows you to inline the WASM module as a\n * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.\n *\n * @param source - The WASM module as a string.\n * @returns A string that exports the WASM module as a `Uint8Array`.\n * @example\n * ```ts\n * import wasm from './program.wasm';\n *\n * const { instance } = await WebAssembly.instantiate(wasm, {});\n * // Do something with the WASM module...\n * ```\n */\nexport default function loader(source: unknown) {\n  assert(typeof source === 'string', 'Expected source to be a string.');\n\n  const bytes = stringToBytes(source);\n  return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;\n}\n"],"names":["loader","source","assert","bytes","stringToBytes","JSON","stringify","Array","from"],"mappings":";;;;+BAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD;;;eAAwBA;;;uBArBc;AAqBvB,SAASA,OAAOC,MAAe;IAC5CC,IAAAA,aAAM,EAAC,OAAOD,WAAW,UAAU;IAEnC,MAAME,QAAQC,IAAAA,oBAAa,EAACH;IAC5B,OAAO,CAAC,8BAA8B,EAAEI,KAAKC,SAAS,CAACC,MAAMC,IAAI,CAACL,QAAQ,EAAE,CAAC;AAC/E"}
+{"version":3,"sources":["../../../../src/webpack/loaders/wasm.ts"],"sourcesContent":["/* eslint-disable no-restricted-globals */\n\nimport { assert } from '@metamask/utils';\nimport type { LoaderDefinitionFunction } from 'webpack';\n\n/**\n * Get the imports code for the WASM module. This code imports each of the\n * imports from the WASM module.\n *\n * @param importMap - The import map for the WASM module.\n * @returns The imports code for the WASM module.\n */\nexport function getImports(importMap: Record<string, string[]>) {\n  return Object.entries(importMap)\n    .map(\n      ([moduleName, exportNames]) =>\n        `import { ${exportNames.join(', ')} } from ${JSON.stringify(\n          moduleName,\n        )};`,\n    )\n    .join('\\n');\n}\n\n/**\n * Get the imports code to use in `WebAssembly.Instance`. This code adds each of\n * the imports to the `imports` object.\n *\n * @param importMap - The import map for the WASM module.\n * @returns The imports code for the WASM module.\n */\nexport function getModuleImports(importMap: Record<string, string[]>) {\n  return Object.entries(importMap)\n    .map(\n      ([moduleName, exportNames]) =>\n        `${JSON.stringify(moduleName)}: { ${exportNames.join(', ')} },`,\n    )\n    .join('\\n');\n}\n\n/**\n * Get the exports code for the WASM module. This code exports each of the\n * exports from the WASM module as a variable. This function assumes that the\n * exports are available in a variable named `exports`.\n *\n * @param descriptors - The export descriptors from the WASM module.\n * @returns The exports code for the WASM module.\n */\nexport function getExports(descriptors: WebAssembly.ModuleExportDescriptor[]) {\n  return descriptors\n    .map((descriptor) => {\n      if (descriptor.name === 'default') {\n        return `export default exports[${JSON.stringify(descriptor.name)}];`;\n      }\n\n      return `export const ${descriptor.name} = exports[${JSON.stringify(\n        descriptor.name,\n      )}];`;\n    })\n    .join('\\n');\n}\n\n/**\n * A Webpack loader that synchronously loads the WASM module. This makes it\n * possible to import the WASM module directly.\n *\n * @param source - The WASM module as `Uint8Array`.\n * @returns The WASM module as a JavaScript string.\n * @example\n * ```ts\n * import * as wasm from './program.wasm';\n *\n * // Do something with the WASM module...\n * ```\n */\n// Note: This function needs to be defined like this, so that Webpack can bind\n// `this` to the loader context, and TypeScript can infer the type of `this`.\nconst loader: LoaderDefinitionFunction = async function loader(\n  source: unknown,\n) {\n  assert(source instanceof Uint8Array, 'Expected source to be a Uint8Array.');\n\n  const bytes = new Uint8Array(source);\n  const wasmModule = await WebAssembly.compile(bytes);\n\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  const exports = WebAssembly.Module.exports(wasmModule);\n  const imports = WebAssembly.Module.imports(wasmModule).reduce<\n    Record<string, string[]>\n  >((target, descriptor) => {\n    target[descriptor.module] ??= [];\n    target[descriptor.module].push(descriptor.name);\n\n    return target;\n  }, {});\n\n  // Add the WASM import as a dependency so that Webpack will watch it for\n  // changes.\n  for (const name of Object.keys(imports)) {\n    this.addDependency(name);\n  }\n\n  return `\n    ${getImports(imports)}\n\n    const bytes = new Uint8Array(${JSON.stringify(Array.from(source))});\n    const module = new WebAssembly.Module(bytes);\n    const instance = new WebAssembly.Instance(module, {\n      ${getModuleImports(imports)}\n    });\n\n    const exports = instance.exports;\n    ${getExports(exports)}\n  `;\n};\n\nexport default loader;\n\n// By setting `raw` to `true`, we are telling Webpack to provide the source as a\n// `Uint8Array` instead of converting it to a string. This allows us to avoid\n// having to convert the source back to a `Uint8Array` in the loader.\nexport const raw = true;\n"],"names":["getImports","getModuleImports","getExports","raw","importMap","Object","entries","map","moduleName","exportNames","join","JSON","stringify","descriptors","descriptor","name","loader","source","assert","Uint8Array","bytes","wasmModule","WebAssembly","compile","exports","Module","imports","reduce","target","module","push","keys","addDependency","Array","from"],"mappings":"AAAA,wCAAwC;;;;;;;;;;;IAYxBA,UAAU;eAAVA;;IAkBAC,gBAAgB;eAAhBA;;IAiBAC,UAAU;eAAVA;;IAoEhB,OAAsB;eAAtB;;IAKaC,GAAG;eAAHA;;;uBAtHU;AAUhB,SAASH,WAAWI,SAAmC;IAC5D,OAAOC,OAAOC,OAAO,CAACF,WACnBG,GAAG,CACF,CAAC,CAACC,YAAYC,YAAY,GACxB,CAAC,SAAS,EAAEA,YAAYC,IAAI,CAAC,MAAM,QAAQ,EAAEC,KAAKC,SAAS,CACzDJ,YACA,CAAC,CAAC,EAEPE,IAAI,CAAC;AACV;AASO,SAAST,iBAAiBG,SAAmC;IAClE,OAAOC,OAAOC,OAAO,CAACF,WACnBG,GAAG,CACF,CAAC,CAACC,YAAYC,YAAY,GACxB,CAAC,EAAEE,KAAKC,SAAS,CAACJ,YAAY,IAAI,EAAEC,YAAYC,IAAI,CAAC,MAAM,GAAG,CAAC,EAElEA,IAAI,CAAC;AACV;AAUO,SAASR,WAAWW,WAAiD;IAC1E,OAAOA,YACJN,GAAG,CAAC,CAACO;QACJ,IAAIA,WAAWC,IAAI,KAAK,WAAW;YACjC,OAAO,CAAC,uBAAuB,EAAEJ,KAAKC,SAAS,CAACE,WAAWC,IAAI,EAAE,EAAE,CAAC;QACtE;QAEA,OAAO,CAAC,aAAa,EAAED,WAAWC,IAAI,CAAC,WAAW,EAAEJ,KAAKC,SAAS,CAChEE,WAAWC,IAAI,EACf,EAAE,CAAC;IACP,GACCL,IAAI,CAAC;AACV;AAEA;;;;;;;;;;;;CAYC,GACD,8EAA8E;AAC9E,6EAA6E;AAC7E,MAAMM,SAAmC,eAAeA,OACtDC,MAAe;IAEfC,IAAAA,aAAM,EAACD,kBAAkBE,YAAY;IAErC,MAAMC,QAAQ,IAAID,WAAWF;IAC7B,MAAMI,aAAa,MAAMC,YAAYC,OAAO,CAACH;IAE7C,wDAAwD;IACxD,MAAMI,WAAUF,YAAYG,MAAM,CAACD,OAAO,CAACH;IAC3C,MAAMK,UAAUJ,YAAYG,MAAM,CAACC,OAAO,CAACL,YAAYM,MAAM,CAE3D,CAACC,QAAQd;YACTc,SAAOd;QAAPc,CAAAA,UAAAA,OAAM,CAACd,qBAAAA,WAAWe,MAAM,CAAC,KAAzBD,OAAM,CAACd,mBAAkB,GAAK,EAAE;QAChCc,MAAM,CAACd,WAAWe,MAAM,CAAC,CAACC,IAAI,CAAChB,WAAWC,IAAI;QAE9C,OAAOa;IACT,GAAG,CAAC;IAEJ,wEAAwE;IACxE,WAAW;IACX,KAAK,MAAMb,QAAQV,OAAO0B,IAAI,CAACL,SAAU;QACvC,IAAI,CAACM,aAAa,CAACjB;IACrB;IAEA,OAAO,CAAC;IACN,EAAEf,WAAW0B,SAAS;;iCAEO,EAAEf,KAAKC,SAAS,CAACqB,MAAMC,IAAI,CAACjB,SAAS;;;MAGhE,EAAEhB,iBAAiByB,SAAS;;;;IAI9B,EAAExB,WAAWsB,UAAS;EACxB,CAAC;AACH;MAEA,WAAeR;AAKR,MAAMb,MAAM"}

package/dist/esm/webpack/loaders/wasm.js

@@ -1,26 +1,85 @@
-import { assert, stringToBytes } from '@metamask/utils';
+/* eslint-disable no-restricted-globals */ import { assert } from '@metamask/utils';
 /**
- * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes
- * it possible to import the WASM module directly, and use it with the
- * `WebAssembly.instantiate` function.
+ * Get the imports code for the WASM module. This code imports each of the
+ * imports from the WASM module.
  *
- * This is useful, because snaps are not allowed to import assets from outside
- * of their package. This loader allows you to inline the WASM module as a
- * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.
+ * @param importMap - The import map for the WASM module.
+ * @returns The imports code for the WASM module.
+ */ export function getImports(importMap) {
+    return Object.entries(importMap).map(([moduleName, exportNames])=>`import { ${exportNames.join(', ')} } from ${JSON.stringify(moduleName)};`).join('\n');
+}
+/**
+ * Get the imports code to use in `WebAssembly.Instance`. This code adds each of
+ * the imports to the `imports` object.
+ *
+ * @param importMap - The import map for the WASM module.
+ * @returns The imports code for the WASM module.
+ */ export function getModuleImports(importMap) {
+    return Object.entries(importMap).map(([moduleName, exportNames])=>`${JSON.stringify(moduleName)}: { ${exportNames.join(', ')} },`).join('\n');
+}
+/**
+ * Get the exports code for the WASM module. This code exports each of the
+ * exports from the WASM module as a variable. This function assumes that the
+ * exports are available in a variable named `exports`.
  *
- * @param source - The WASM module as a string.
- * @returns A string that exports the WASM module as a `Uint8Array`.
+ * @param descriptors - The export descriptors from the WASM module.
+ * @returns The exports code for the WASM module.
+ */ export function getExports(descriptors) {
+    return descriptors.map((descriptor)=>{
+        if (descriptor.name === 'default') {
+            return `export default exports[${JSON.stringify(descriptor.name)}];`;
+        }
+        return `export const ${descriptor.name} = exports[${JSON.stringify(descriptor.name)}];`;
+    }).join('\n');
+}
+/**
+ * A Webpack loader that synchronously loads the WASM module. This makes it
+ * possible to import the WASM module directly.
+ *
+ * @param source - The WASM module as `Uint8Array`.
+ * @returns The WASM module as a JavaScript string.
  * @example
  * ```ts
- * import wasm from './program.wasm';
+ * import * as wasm from './program.wasm';
  *
- * const { instance } = await WebAssembly.instantiate(wasm, {});
  * // Do something with the WASM module...
  * ```
- */ export default function loader(source) {
-    assert(typeof source === 'string', 'Expected source to be a string.');
-    const bytes = stringToBytes(source);
-    return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;
-}
+ */ // Note: This function needs to be defined like this, so that Webpack can bind
+// `this` to the loader context, and TypeScript can infer the type of `this`.
+const loader = async function loader(source) {
+    assert(source instanceof Uint8Array, 'Expected source to be a Uint8Array.');
+    const bytes = new Uint8Array(source);
+    const wasmModule = await WebAssembly.compile(bytes);
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    const exports = WebAssembly.Module.exports(wasmModule);
+    const imports = WebAssembly.Module.imports(wasmModule).reduce((target, descriptor)=>{
+        var _target, _descriptor_module;
+        (_target = target)[_descriptor_module = descriptor.module] ?? (_target[_descriptor_module] = []);
+        target[descriptor.module].push(descriptor.name);
+        return target;
+    }, {});
+    // Add the WASM import as a dependency so that Webpack will watch it for
+    // changes.
+    for (const name of Object.keys(imports)){
+        this.addDependency(name);
+    }
+    return `
+    ${getImports(imports)}
+
+    const bytes = new Uint8Array(${JSON.stringify(Array.from(source))});
+    const module = new WebAssembly.Module(bytes);
+    const instance = new WebAssembly.Instance(module, {
+      ${getModuleImports(imports)}
+    });
+
+    const exports = instance.exports;
+    ${getExports(exports)}
+  `;
+};
+export default loader;
+// By setting `raw` to `true`, we are telling Webpack to provide the source as a
+// `Uint8Array` instead of converting it to a string. This allows us to avoid
+// having to convert the source back to a `Uint8Array` in the loader.
+export const raw = true;
 
 //# sourceMappingURL=wasm.js.map

package/dist/esm/webpack/loaders/wasm.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/webpack/loaders/wasm.ts"],"sourcesContent":["import { assert, stringToBytes } from '@metamask/utils';\n\n/**\n * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes\n * it possible to import the WASM module directly, and use it with the\n * `WebAssembly.instantiate` function.\n *\n * This is useful, because snaps are not allowed to import assets from outside\n * of their package. This loader allows you to inline the WASM module as a\n * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.\n *\n * @param source - The WASM module as a string.\n * @returns A string that exports the WASM module as a `Uint8Array`.\n * @example\n * ```ts\n * import wasm from './program.wasm';\n *\n * const { instance } = await WebAssembly.instantiate(wasm, {});\n * // Do something with the WASM module...\n * ```\n */\nexport default function loader(source: unknown) {\n  assert(typeof source === 'string', 'Expected source to be a string.');\n\n  const bytes = stringToBytes(source);\n  return `export default new Uint8Array(${JSON.stringify(Array.from(bytes))});`;\n}\n"],"names":["assert","stringToBytes","loader","source","bytes","JSON","stringify","Array","from"],"mappings":"AAAA,SAASA,MAAM,EAAEC,aAAa,QAAQ,kBAAkB;AAExD;;;;;;;;;;;;;;;;;;CAkBC,GACD,eAAe,SAASC,OAAOC,MAAe;IAC5CH,OAAO,OAAOG,WAAW,UAAU;IAEnC,MAAMC,QAAQH,cAAcE;IAC5B,OAAO,CAAC,8BAA8B,EAAEE,KAAKC,SAAS,CAACC,MAAMC,IAAI,CAACJ,QAAQ,EAAE,CAAC;AAC/E"}
+{"version":3,"sources":["../../../../src/webpack/loaders/wasm.ts"],"sourcesContent":["/* eslint-disable no-restricted-globals */\n\nimport { assert } from '@metamask/utils';\nimport type { LoaderDefinitionFunction } from 'webpack';\n\n/**\n * Get the imports code for the WASM module. This code imports each of the\n * imports from the WASM module.\n *\n * @param importMap - The import map for the WASM module.\n * @returns The imports code for the WASM module.\n */\nexport function getImports(importMap: Record<string, string[]>) {\n  return Object.entries(importMap)\n    .map(\n      ([moduleName, exportNames]) =>\n        `import { ${exportNames.join(', ')} } from ${JSON.stringify(\n          moduleName,\n        )};`,\n    )\n    .join('\\n');\n}\n\n/**\n * Get the imports code to use in `WebAssembly.Instance`. This code adds each of\n * the imports to the `imports` object.\n *\n * @param importMap - The import map for the WASM module.\n * @returns The imports code for the WASM module.\n */\nexport function getModuleImports(importMap: Record<string, string[]>) {\n  return Object.entries(importMap)\n    .map(\n      ([moduleName, exportNames]) =>\n        `${JSON.stringify(moduleName)}: { ${exportNames.join(', ')} },`,\n    )\n    .join('\\n');\n}\n\n/**\n * Get the exports code for the WASM module. This code exports each of the\n * exports from the WASM module as a variable. This function assumes that the\n * exports are available in a variable named `exports`.\n *\n * @param descriptors - The export descriptors from the WASM module.\n * @returns The exports code for the WASM module.\n */\nexport function getExports(descriptors: WebAssembly.ModuleExportDescriptor[]) {\n  return descriptors\n    .map((descriptor) => {\n      if (descriptor.name === 'default') {\n        return `export default exports[${JSON.stringify(descriptor.name)}];`;\n      }\n\n      return `export const ${descriptor.name} = exports[${JSON.stringify(\n        descriptor.name,\n      )}];`;\n    })\n    .join('\\n');\n}\n\n/**\n * A Webpack loader that synchronously loads the WASM module. This makes it\n * possible to import the WASM module directly.\n *\n * @param source - The WASM module as `Uint8Array`.\n * @returns The WASM module as a JavaScript string.\n * @example\n * ```ts\n * import * as wasm from './program.wasm';\n *\n * // Do something with the WASM module...\n * ```\n */\n// Note: This function needs to be defined like this, so that Webpack can bind\n// `this` to the loader context, and TypeScript can infer the type of `this`.\nconst loader: LoaderDefinitionFunction = async function loader(\n  source: unknown,\n) {\n  assert(source instanceof Uint8Array, 'Expected source to be a Uint8Array.');\n\n  const bytes = new Uint8Array(source);\n  const wasmModule = await WebAssembly.compile(bytes);\n\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  const exports = WebAssembly.Module.exports(wasmModule);\n  const imports = WebAssembly.Module.imports(wasmModule).reduce<\n    Record<string, string[]>\n  >((target, descriptor) => {\n    target[descriptor.module] ??= [];\n    target[descriptor.module].push(descriptor.name);\n\n    return target;\n  }, {});\n\n  // Add the WASM import as a dependency so that Webpack will watch it for\n  // changes.\n  for (const name of Object.keys(imports)) {\n    this.addDependency(name);\n  }\n\n  return `\n    ${getImports(imports)}\n\n    const bytes = new Uint8Array(${JSON.stringify(Array.from(source))});\n    const module = new WebAssembly.Module(bytes);\n    const instance = new WebAssembly.Instance(module, {\n      ${getModuleImports(imports)}\n    });\n\n    const exports = instance.exports;\n    ${getExports(exports)}\n  `;\n};\n\nexport default loader;\n\n// By setting `raw` to `true`, we are telling Webpack to provide the source as a\n// `Uint8Array` instead of converting it to a string. This allows us to avoid\n// having to convert the source back to a `Uint8Array` in the loader.\nexport const raw = true;\n"],"names":["assert","getImports","importMap","Object","entries","map","moduleName","exportNames","join","JSON","stringify","getModuleImports","getExports","descriptors","descriptor","name","loader","source","Uint8Array","bytes","wasmModule","WebAssembly","compile","exports","Module","imports","reduce","target","module","push","keys","addDependency","Array","from","raw"],"mappings":"AAAA,wCAAwC,GAExC,SAASA,MAAM,QAAQ,kBAAkB;AAGzC;;;;;;CAMC,GACD,OAAO,SAASC,WAAWC,SAAmC;IAC5D,OAAOC,OAAOC,OAAO,CAACF,WACnBG,GAAG,CACF,CAAC,CAACC,YAAYC,YAAY,GACxB,CAAC,SAAS,EAAEA,YAAYC,IAAI,CAAC,MAAM,QAAQ,EAAEC,KAAKC,SAAS,CACzDJ,YACA,CAAC,CAAC,EAEPE,IAAI,CAAC;AACV;AAEA;;;;;;CAMC,GACD,OAAO,SAASG,iBAAiBT,SAAmC;IAClE,OAAOC,OAAOC,OAAO,CAACF,WACnBG,GAAG,CACF,CAAC,CAACC,YAAYC,YAAY,GACxB,CAAC,EAAEE,KAAKC,SAAS,CAACJ,YAAY,IAAI,EAAEC,YAAYC,IAAI,CAAC,MAAM,GAAG,CAAC,EAElEA,IAAI,CAAC;AACV;AAEA;;;;;;;CAOC,GACD,OAAO,SAASI,WAAWC,WAAiD;IAC1E,OAAOA,YACJR,GAAG,CAAC,CAACS;QACJ,IAAIA,WAAWC,IAAI,KAAK,WAAW;YACjC,OAAO,CAAC,uBAAuB,EAAEN,KAAKC,SAAS,CAACI,WAAWC,IAAI,EAAE,EAAE,CAAC;QACtE;QAEA,OAAO,CAAC,aAAa,EAAED,WAAWC,IAAI,CAAC,WAAW,EAAEN,KAAKC,SAAS,CAChEI,WAAWC,IAAI,EACf,EAAE,CAAC;IACP,GACCP,IAAI,CAAC;AACV;AAEA;;;;;;;;;;;;CAYC,GACD,8EAA8E;AAC9E,6EAA6E;AAC7E,MAAMQ,SAAmC,eAAeA,OACtDC,MAAe;IAEfjB,OAAOiB,kBAAkBC,YAAY;IAErC,MAAMC,QAAQ,IAAID,WAAWD;IAC7B,MAAMG,aAAa,MAAMC,YAAYC,OAAO,CAACH;IAE7C,wDAAwD;IACxD,MAAMI,UAAUF,YAAYG,MAAM,CAACD,OAAO,CAACH;IAC3C,MAAMK,UAAUJ,YAAYG,MAAM,CAACC,OAAO,CAACL,YAAYM,MAAM,CAE3D,CAACC,QAAQb;YACTa,SAAOb;QAAPa,CAAAA,UAAAA,OAAM,CAACb,qBAAAA,WAAWc,MAAM,CAAC,KAAzBD,OAAM,CAACb,mBAAkB,GAAK,EAAE;QAChCa,MAAM,CAACb,WAAWc,MAAM,CAAC,CAACC,IAAI,CAACf,WAAWC,IAAI;QAE9C,OAAOY;IACT,GAAG,CAAC;IAEJ,wEAAwE;IACxE,WAAW;IACX,KAAK,MAAMZ,QAAQZ,OAAO2B,IAAI,CAACL,SAAU;QACvC,IAAI,CAACM,aAAa,CAAChB;IACrB;IAEA,OAAO,CAAC;IACN,EAAEd,WAAWwB,SAAS;;iCAEO,EAAEhB,KAAKC,SAAS,CAACsB,MAAMC,IAAI,CAAChB,SAAS;;;MAGhE,EAAEN,iBAAiBc,SAAS;;;;IAI9B,EAAEb,WAAWW,SAAS;EACxB,CAAC;AACH;AAEA,eAAeP,OAAO;AAEtB,gFAAgF;AAChF,6EAA6E;AAC7E,qEAAqE;AACrE,OAAO,MAAMkB,MAAM,KAAK"}

package/dist/types/webpack/loaders/wasm.d.ts

@@ -1,20 +1,42 @@
+import type { LoaderDefinitionFunction } from 'webpack';
 /**
- * A Webpack loader that inlines the WASM module as a `Uint8Array`. This makes
- * it possible to import the WASM module directly, and use it with the
- * `WebAssembly.instantiate` function.
+ * Get the imports code for the WASM module. This code imports each of the
+ * imports from the WASM module.
  *
- * This is useful, because snaps are not allowed to import assets from outside
- * of their package. This loader allows you to inline the WASM module as a
- * `Uint8Array`, which can then be passed to `WebAssembly.instantiate`.
+ * @param importMap - The import map for the WASM module.
+ * @returns The imports code for the WASM module.
+ */
+export declare function getImports(importMap: Record<string, string[]>): string;
+/**
+ * Get the imports code to use in `WebAssembly.Instance`. This code adds each of
+ * the imports to the `imports` object.
+ *
+ * @param importMap - The import map for the WASM module.
+ * @returns The imports code for the WASM module.
+ */
+export declare function getModuleImports(importMap: Record<string, string[]>): string;
+/**
+ * Get the exports code for the WASM module. This code exports each of the
+ * exports from the WASM module as a variable. This function assumes that the
+ * exports are available in a variable named `exports`.
+ *
+ * @param descriptors - The export descriptors from the WASM module.
+ * @returns The exports code for the WASM module.
+ */
+export declare function getExports(descriptors: WebAssembly.ModuleExportDescriptor[]): string;
+/**
+ * A Webpack loader that synchronously loads the WASM module. This makes it
+ * possible to import the WASM module directly.
  *
- * @param source - The WASM module as a string.
- * @returns A string that exports the WASM module as a `Uint8Array`.
+ * @param source - The WASM module as `Uint8Array`.
+ * @returns The WASM module as a JavaScript string.
  * @example
  * ```ts
- * import wasm from './program.wasm';
+ * import * as wasm from './program.wasm';
  *
- * const { instance } = await WebAssembly.instantiate(wasm, {});
  * // Do something with the WASM module...
  * ```
  */
-export default function loader(source: unknown): string;
+declare const loader: LoaderDefinitionFunction;
+export default loader;
+export declare const raw = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask/snaps-cli",
-  "version": "3.0.5",
+  "version": "4.0.1",
   "description": "A CLI for developing MetaMask Snaps.",
   "repository": {
     "type": "git",
@@ -54,8 +54,8 @@
     "@babel/plugin-transform-runtime": "^7.13.2",
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.23.2",
-    "@metamask/snaps-sdk": "^1.2.0",
-    "@metamask/snaps-utils": "^5.0.0",
+    "@metamask/snaps-sdk": "^1.3.2",
+    "@metamask/snaps-utils": "^5.1.2",
     "@metamask/snaps-webpack-plugin": "^3.1.1",
     "@metamask/utils": "^8.2.1",
     "@swc/core": "1.3.78",
@@ -98,7 +98,7 @@
   },
   "devDependencies": {
     "@lavamoat/allow-scripts": "^2.5.1",
-    "@metamask/auto-changelog": "^3.4.3",
+    "@metamask/auto-changelog": "^3.4.4",
     "@metamask/eslint-config": "^12.1.0",
     "@metamask/eslint-config-jest": "^12.1.0",
     "@metamask/eslint-config-nodejs": "^12.1.0",