ox 1.0.5 → 1.1.2

package/dist/wasm/Engine.js

@@ -0,0 +1,76 @@
+import * as CoreEngine from '../core/Engine.js';
+import * as Ed25519 from './Ed25519.js';
+import * as Hash from './Hash.js';
+import * as Keystore from './Keystore.js';
+import * as Mnemonic from './Mnemonic.js';
+import * as X25519 from './X25519.js';
+export { AsyncScopeError, get, InvalidSlotValueError, reset, set, UnknownPrimitiveError, UnknownSlotError, with, } from '../core/Engine.js';
+/**
+ * Compiles and installs every WASM implementation this entrypoint provides.
+ *
+ * Slot compilation starts concurrently. Nothing is installed until every slot
+ * resolves successfully.
+ *
+ * Call this once, during startup, before any crypto call. Ox resolves the
+ * engine at call time, so values computed beforehand used whatever was
+ * installed then.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine, Hash } from 'ox/wasm'
+ *
+ * await Engine.install()
+ *
+ * Hash.sha256('0xdeadbeef')
+ * ```
+ *
+ * @returns The engine that was installed.
+ */
+export async function install() {
+    return CoreEngine.install({
+        Ed25519: Ed25519.engine(),
+        Hash: Hash.engine(),
+        Keystore: Keystore.engine(),
+        Mnemonic: Mnemonic.engine(),
+        X25519: X25519.engine(),
+    });
+}
+/**
+ * Compiles every WASM implementation this entrypoint provides, without
+ * installing it.
+ *
+ * Reach for this where an engine has to exist as a value, such as a benchmark
+ * or an [`Engine.with`](/api/Engine/with) scope. Use the individual module's
+ * `engine` function to select only some slots.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine, Hash } from 'ox'
+ * import { Engine as Wasm } from 'ox/wasm'
+ *
+ * const wasm = await Wasm.engine()
+ *
+ * Engine.with(wasm, () => Hash.sha256('0xdeadbeef'))
+ * ```
+ *
+ * @returns An engine, ready to install.
+ */
+export async function engine() {
+    const [ed25519, hash, keystore, mnemonic, x25519] = await Promise.all([
+        Ed25519.engine(),
+        Hash.engine(),
+        Keystore.engine(),
+        Mnemonic.engine(),
+        X25519.engine(),
+    ]);
+    return {
+        Ed25519: ed25519,
+        Hash: hash,
+        Keystore: keystore,
+        Mnemonic: mnemonic,
+        X25519: x25519,
+    };
+}
+//# sourceMappingURL=Engine.js.map

package/dist/wasm/Engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Engine.js","sourceRoot":"","sources":["../../src/wasm/Engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAE/C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAGrC,OAAO,EACL,eAAe,EACf,GAAG,EACH,qBAAqB,EACrB,KAAK,EACL,GAAG,EACH,qBAAqB,EACrB,gBAAgB,EAChB,IAAI,GACL,MAAM,mBAAmB,CAAA;AAY1B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO;IAC3B,OAAO,UAAU,CAAC,OAAO,CAAC;QACxB,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE;QACzB,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE;QACnB,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE;QAC3B,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE;QAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;KACxB,CAAC,CAAA;AACJ,CAAC;AAWD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM;IAC1B,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QACpE,OAAO,CAAC,MAAM,EAAE;QAChB,IAAI,CAAC,MAAM,EAAE;QACb,QAAQ,CAAC,MAAM,EAAE;QACjB,QAAQ,CAAC,MAAM,EAAE;QACjB,MAAM,CAAC,MAAM,EAAE;KAChB,CAAC,CAAA;IACF,OAAO;QACL,OAAO,EAAE,OAAO;QAChB,IAAI,EAAE,IAAI;QACV,QAAQ,EAAE,QAAQ;QAClB,QAAQ,EAAE,QAAQ;QAClB,MAAM,EAAE,MAAM;KACf,CAAA;AACH,CAAC"}

package/dist/wasm/Hash.d.ts

@@ -0,0 +1,43 @@
+import type * as Engine from '../core/Engine.js';
+import type * as Errors from '../core/Errors.js';
+import * as internal from './internal/instantiate.js';
+export * from '../core/Hash.js';
+export { MemoryError } from './internal/instantiate.js';
+/**
+ * Compiles the WASM implementation of the [`Hash`](/api/Hash) primitives,
+ * without installing it.
+ *
+ * Most callers want
+ * [`Engine.install`](/wasm/crypto/Engine/install) instead, which compiles every
+ * implementation this entrypoint provides and installs them in one call. Reach
+ * for this to take the `Hash` slot on its own, or to hold the implementation
+ * without touching the installed engine.
+ *
+ * :::note
+ * Performance varies by primitive, input size, runtime, and processor. Run
+ * `pnpm bench:engines` to compare Ox's default, Node, WASM, and Alloy
+ * implementations on your target machine.
+ * :::
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Hash } from 'ox/wasm'
+ *
+ * await Engine.install({ Hash: Hash.engine() })
+ *
+ * Hash.keccak256('0xdeadbeef')
+ * ```
+ *
+ * @returns The WASM implementation of the `Hash` slot.
+ */
+export declare function engine(): Promise<engine.ReturnType>;
+export declare namespace engine {
+    /** Every `Hash` primitive this module implements. */
+    type ReturnType = {
+        [key in 'blake3' | 'hmacSha256' | 'keccak256' | 'ripemd160' | 'sha256']-?: NonNullable<Engine.Hash[key]>;
+    };
+    type ErrorType = internal.MemoryError | Errors.GlobalErrorType;
+}
+//# sourceMappingURL=Hash.d.ts.map

package/dist/wasm/Hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hash.d.ts","sourceRoot":"","sources":["../../src/wasm/Hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAIhD,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAA;AAErD,cAAc,iBAAiB,CAAA;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAKvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CA+BzD;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,qDAAqD;IACrD,KAAK,UAAU,GAAG;SACf,GAAG,IACA,QAAQ,GACR,YAAY,GACZ,WAAW,GACX,WAAW,GACX,QAAQ,CAAC,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;KAC/C,CAAA;IAED,KAAK,SAAS,GAAG,QAAQ,CAAC,WAAW,GAAG,MAAM,CAAC,eAAe,CAAA;CAC/D"}

package/dist/wasm/Hash.js

@@ -0,0 +1,64 @@
+import * as blake3 from './internal/blake3.js';
+import * as hash from './internal/hash.js';
+import * as hashes from './internal/hashes.js';
+export * from '../core/Hash.js';
+export { MemoryError } from './internal/instantiate.js';
+/** Digest sizes, in bytes. */
+const digestSize = { keccak256: 32, ripemd160: 20, sha256: 32 };
+/**
+ * Compiles the WASM implementation of the [`Hash`](/api/Hash) primitives,
+ * without installing it.
+ *
+ * Most callers want
+ * [`Engine.install`](/wasm/crypto/Engine/install) instead, which compiles every
+ * implementation this entrypoint provides and installs them in one call. Reach
+ * for this to take the `Hash` slot on its own, or to hold the implementation
+ * without touching the installed engine.
+ *
+ * :::note
+ * Performance varies by primitive, input size, runtime, and processor. Run
+ * `pnpm bench:engines` to compare Ox's default, Node, WASM, and Alloy
+ * implementations on your target machine.
+ * :::
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Hash } from 'ox/wasm'
+ *
+ * await Engine.install({ Hash: Hash.engine() })
+ *
+ * Hash.keccak256('0xdeadbeef')
+ * ```
+ *
+ * @returns The WASM implementation of the `Hash` slot.
+ */
+export async function engine() {
+    {
+        const [blake3Module, module] = await Promise.all([
+            blake3.load(),
+            hashes.load(),
+        ]);
+        // Copies `input` in, runs `hash`, and copies the digest back out.
+        function call(hash, input) {
+            const out = digestSize[hash];
+            module.reserve(input.length + out);
+            const inputPtr = module.heapBase;
+            const outPtr = inputPtr + input.length;
+            module.view().set(input, inputPtr);
+            module.exports[hash](inputPtr, input.length, outPtr);
+            // `slice`, not `subarray`: the result must not alias WASM memory, which the
+            // next call overwrites and a `grow` detaches entirely.
+            return module.view().slice(outPtr, outPtr + out);
+        }
+        return {
+            blake3: (input) => blake3.hash(blake3Module, input),
+            hmacSha256: (key, message) => hash.hmacSha256(module, key, message),
+            keccak256: (input) => call('keccak256', input),
+            ripemd160: (input) => call('ripemd160', input),
+            sha256: (input) => call('sha256', input),
+        };
+    }
+}
+//# sourceMappingURL=Hash.js.map

package/dist/wasm/Hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hash.js","sourceRoot":"","sources":["../../src/wasm/Hash.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAC9C,OAAO,KAAK,IAAI,MAAM,oBAAoB,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAG9C,cAAc,iBAAiB,CAAA;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD,8BAA8B;AAC9B,MAAM,UAAU,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM;IAC1B,CAAC;QACC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAC/C,MAAM,CAAC,IAAI,EAAE;YACb,MAAM,CAAC,IAAI,EAAE;SACd,CAAC,CAAA;QAEF,kEAAkE;QAClE,SAAS,IAAI,CACX,IAA0C,EAC1C,KAAiB;YAEjB,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,CAAA;YAC5B,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,CAAA;YAClC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAA;YAChC,MAAM,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAA;YACtC,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;YAClC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;YACpD,4EAA4E;YAC5E,uDAAuD;YACvD,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,CAAA;QAClD,CAAC;QAED,OAAO;YACL,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC;YACnD,UAAU,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC;YACnE,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC;YAC9C,SAAS,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC;YAC9C,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC;SACzC,CAAA;IACH,CAAC;AACH,CAAC"}

package/dist/wasm/Keystore.d.ts

@@ -0,0 +1,37 @@
+import type * as Engine from '../core/Engine.js';
+import type * as Errors from '../core/Errors.js';
+import * as internal from './internal/instantiate.js';
+export * from '../core/Keystore.js';
+export { MemoryError } from './internal/instantiate.js';
+/**
+ * Compiles the WASM implementation of the [`Keystore`](/api/Keystore) PBKDF2
+ * primitive, without installing it.
+ *
+ * Most callers want
+ * [`Engine.install`](/wasm/crypto/Engine/install) instead, which compiles every
+ * implementation this entrypoint provides and installs them in one call. This
+ * provider deliberately stays synchronous and leaves AES, asynchronous PBKDF2,
+ * and scrypt on Ox's default implementation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Keystore } from 'ox/wasm'
+ *
+ * await Engine.install({ Keystore: Keystore.engine() })
+ *
+ * Keystore.pbkdf2({ password: 'testpassword' })
+ * ```
+ *
+ * @returns The WASM implementation of synchronous PBKDF2-HMAC-SHA256.
+ */
+export declare function engine(): Promise<engine.ReturnType>;
+export declare namespace engine {
+    /** The WASM `Keystore` primitives this module implements. */
+    type ReturnType = {
+        pbkdf2Sha256: NonNullable<Engine.Keystore['pbkdf2Sha256']>;
+    };
+    type ErrorType = internal.MemoryError | Errors.GlobalErrorType;
+}
+//# sourceMappingURL=Keystore.d.ts.map

package/dist/wasm/Keystore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Keystore.d.ts","sourceRoot":"","sources":["../../src/wasm/Keystore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAEhD,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAA;AAGrD,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAMzD;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,6DAA6D;IAC7D,KAAK,UAAU,GAAG;QAChB,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAA;KAC3D,CAAA;IAED,KAAK,SAAS,GAAG,QAAQ,CAAC,WAAW,GAAG,MAAM,CAAC,eAAe,CAAA;CAC/D"}

package/dist/wasm/Keystore.js

@@ -0,0 +1,34 @@
+import * as hashes from './internal/hashes.js';
+import * as pbkdf2 from './internal/pbkdf2.js';
+export * from '../core/Keystore.js';
+export { MemoryError } from './internal/instantiate.js';
+/**
+ * Compiles the WASM implementation of the [`Keystore`](/api/Keystore) PBKDF2
+ * primitive, without installing it.
+ *
+ * Most callers want
+ * [`Engine.install`](/wasm/crypto/Engine/install) instead, which compiles every
+ * implementation this entrypoint provides and installs them in one call. This
+ * provider deliberately stays synchronous and leaves AES, asynchronous PBKDF2,
+ * and scrypt on Ox's default implementation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Keystore } from 'ox/wasm'
+ *
+ * await Engine.install({ Keystore: Keystore.engine() })
+ *
+ * Keystore.pbkdf2({ password: 'testpassword' })
+ * ```
+ *
+ * @returns The WASM implementation of synchronous PBKDF2-HMAC-SHA256.
+ */
+export async function engine() {
+    const module = await hashes.load();
+    return {
+        pbkdf2Sha256: (password, salt, options) => pbkdf2.pbkdf2Sha256(module, password, salt, options),
+    };
+}
+//# sourceMappingURL=Keystore.js.map

package/dist/wasm/Keystore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Keystore.js","sourceRoot":"","sources":["../../src/wasm/Keystore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAE9C,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAE9C,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM;IAC1B,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAA;IAClC,OAAO;QACL,YAAY,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CACxC,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC;KACvD,CAAA;AACH,CAAC"}

package/dist/wasm/Mnemonic.d.ts

@@ -0,0 +1,33 @@
+import type * as Engine from '../core/Engine.js';
+import type * as Errors from '../core/Errors.js';
+import * as internal from './internal/instantiate.js';
+export * from '../core/Mnemonic.js';
+export { MemoryError } from './internal/instantiate.js';
+/**
+ * Compiles the WASM implementation of [`Mnemonic.toSeed`](/api/Mnemonic/toSeed),
+ * without installing it.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Mnemonic } from 'ox/wasm'
+ *
+ * await Engine.install({ Mnemonic: Mnemonic.engine() })
+ *
+ * Mnemonic.toSeed(
+ *   'test test test test test test test test test test test junk'
+ * )
+ * ```
+ *
+ * @returns The WASM implementation of the `Mnemonic` slot.
+ */
+export declare function engine(): Promise<engine.ReturnType>;
+export declare namespace engine {
+    /** Every `Mnemonic` primitive this module implements. */
+    type ReturnType = {
+        toSeed: NonNullable<Engine.Mnemonic['toSeed']>;
+    };
+    type ErrorType = internal.MemoryError | Errors.GlobalErrorType;
+}
+//# sourceMappingURL=Mnemonic.d.ts.map

package/dist/wasm/Mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mnemonic.d.ts","sourceRoot":"","sources":["../../src/wasm/Mnemonic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAEhD,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAA;AAGrD,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAMzD;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,yDAAyD;IACzD,KAAK,UAAU,GAAG;QAChB,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAA;KAC/C,CAAA;IAED,KAAK,SAAS,GAAG,QAAQ,CAAC,WAAW,GAAG,MAAM,CAAC,eAAe,CAAA;CAC/D"}

package/dist/wasm/Mnemonic.js

@@ -0,0 +1,30 @@
+import * as crypto25519 from './internal/crypto25519.js';
+import * as mnemonic from './internal/mnemonic.js';
+export * from '../core/Mnemonic.js';
+export { MemoryError } from './internal/instantiate.js';
+/**
+ * Compiles the WASM implementation of [`Mnemonic.toSeed`](/api/Mnemonic/toSeed),
+ * without installing it.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Mnemonic } from 'ox/wasm'
+ *
+ * await Engine.install({ Mnemonic: Mnemonic.engine() })
+ *
+ * Mnemonic.toSeed(
+ *   'test test test test test test test test test test test junk'
+ * )
+ * ```
+ *
+ * @returns The WASM implementation of the `Mnemonic` slot.
+ */
+export async function engine() {
+    const module = await crypto25519.load();
+    return {
+        toSeed: (value, passphrase) => mnemonic.toSeed(module, value, passphrase),
+    };
+}
+//# sourceMappingURL=Mnemonic.js.map

package/dist/wasm/Mnemonic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mnemonic.js","sourceRoot":"","sources":["../../src/wasm/Mnemonic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,2BAA2B,CAAA;AAExD,OAAO,KAAK,QAAQ,MAAM,wBAAwB,CAAA;AAElD,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM;IAC1B,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,IAAI,EAAE,CAAA;IAEvC,OAAO;QACL,MAAM,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC;KAC1E,CAAA;AACH,CAAC"}

package/dist/wasm/X25519.d.ts

@@ -0,0 +1,33 @@
+import type * as Engine from '../core/Engine.js';
+import type * as Errors from '../core/Errors.js';
+import * as internal from './internal/instantiate.js';
+export * from '../core/X25519.js';
+export { MemoryError } from './internal/instantiate.js';
+/**
+ * Compiles WASM implementations of selected [`X25519`](/api/X25519)
+ * primitives, without installing them.
+ *
+ * Random key generation remains on Ox's default implementation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { X25519 } from 'ox/wasm'
+ *
+ * await Engine.install({ X25519: X25519.engine() })
+ *
+ * X25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @returns The WASM implementation of part of the `X25519` slot.
+ */
+export declare function engine(): Promise<engine.ReturnType>;
+export declare namespace engine {
+    /** Every `X25519` primitive this module implements. */
+    type ReturnType = {
+        [key in 'getPublicKey' | 'getSharedSecret']-?: NonNullable<Engine.Ecdh[key]>;
+    };
+    type ErrorType = internal.MemoryError | Errors.GlobalErrorType;
+}
+//# sourceMappingURL=X25519.d.ts.map

package/dist/wasm/X25519.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"X25519.d.ts","sourceRoot":"","sources":["../../src/wasm/X25519.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAEhD,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAA;AAGrD,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAIvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAuBzD;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,uDAAuD;IACvD,KAAK,UAAU,GAAG;SACf,GAAG,IAAI,cAAc,GAAG,iBAAiB,CAAC,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;KAC7E,CAAA;IAED,KAAK,SAAS,GAAG,QAAQ,CAAC,WAAW,GAAG,MAAM,CAAC,eAAe,CAAA;CAC/D"}

package/dist/wasm/X25519.js

@@ -0,0 +1,53 @@
+import * as crypto25519 from './internal/crypto25519.js';
+import * as x25519 from './internal/x25519.js';
+export * from '../core/X25519.js';
+export { MemoryError } from './internal/instantiate.js';
+const keySize = 32;
+/**
+ * Compiles WASM implementations of selected [`X25519`](/api/X25519)
+ * primitives, without installing them.
+ *
+ * Random key generation remains on Ox's default implementation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { X25519 } from 'ox/wasm'
+ *
+ * await Engine.install({ X25519: X25519.engine() })
+ *
+ * X25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @returns The WASM implementation of part of the `X25519` slot.
+ */
+export async function engine() {
+    const module = await crypto25519.load();
+    return {
+        getPublicKey(privateKey) {
+            assertLength(privateKey, 'private');
+            module.reserve(keySize * 2);
+            const privateKeyPtr = module.heapBase;
+            const publicKeyPtr = privateKeyPtr + keySize;
+            try {
+                module.view().set(privateKey, privateKeyPtr);
+                module.exports.x25519_get_public_key(privateKeyPtr, publicKeyPtr);
+                return module.view().slice(publicKeyPtr, publicKeyPtr + keySize);
+            }
+            finally {
+                module.exports.zero(privateKeyPtr, keySize * 2);
+            }
+        },
+        getSharedSecret(privateKey, publicKey) {
+            assertLength(privateKey, 'private');
+            assertLength(publicKey, 'public');
+            return x25519.getSharedSecret(module, privateKey, publicKey);
+        },
+    };
+}
+function assertLength(key, type) {
+    if (key.length !== keySize)
+        throw new RangeError(`X25519 ${type} key must be ${keySize} bytes, got ${key.length}`);
+}
+//# sourceMappingURL=X25519.js.map

package/dist/wasm/X25519.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"X25519.js","sourceRoot":"","sources":["../../src/wasm/X25519.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,2BAA2B,CAAA;AAExD,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAE9C,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD,MAAM,OAAO,GAAG,EAAE,CAAA;AAElB;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM;IAC1B,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,IAAI,EAAE,CAAA;IAEvC,OAAO;QACL,YAAY,CAAC,UAAU;YACrB,YAAY,CAAC,UAAU,EAAE,SAAS,CAAC,CAAA;YACnC,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,CAAC,CAAC,CAAA;YAC3B,MAAM,aAAa,GAAG,MAAM,CAAC,QAAQ,CAAA;YACrC,MAAM,YAAY,GAAG,aAAa,GAAG,OAAO,CAAA;YAC5C,IAAI,CAAC;gBACH,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,UAAU,EAAE,aAAa,CAAC,CAAA;gBAC5C,MAAM,CAAC,OAAO,CAAC,qBAAqB,CAAC,aAAa,EAAE,YAAY,CAAC,CAAA;gBACjE,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,CAAA;YAClE,CAAC;oBAAS,CAAC;gBACT,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,GAAG,CAAC,CAAC,CAAA;YACjD,CAAC;QACH,CAAC;QACD,eAAe,CAAC,UAAU,EAAE,SAAS;YACnC,YAAY,CAAC,UAAU,EAAE,SAAS,CAAC,CAAA;YACnC,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;YACjC,OAAO,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC,CAAA;QAC9D,CAAC;KACF,CAAA;AACH,CAAC;AAWD,SAAS,YAAY,CAAC,GAAe,EAAE,IAA0B;IAC/D,IAAI,GAAG,CAAC,MAAM,KAAK,OAAO;QACxB,MAAM,IAAI,UAAU,CAClB,UAAU,IAAI,gBAAgB,OAAO,eAAe,GAAG,CAAC,MAAM,EAAE,CACjE,CAAA;AACL,CAAC"}

package/dist/wasm/index.d.ts

@@ -0,0 +1,115 @@
+/** @entrypointCategory WASM */
+/**
+ * WASM implementations of Ox's supported cryptographic primitives, compiled
+ * from C.
+ *
+ * Install it during startup. WASM must be compiled asynchronously, so the
+ * `await` lives there. Every cryptographic call afterwards is synchronous.
+ *
+ * :::note
+ * Performance varies by primitive, input size, runtime, and processor. Run
+ * `pnpm bench:engines` to compare the available implementations on your target
+ * machine.
+ * :::
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine, Hash } from 'ox/wasm'
+ *
+ * await Engine.install()
+ *
+ * Hash.sha256('0xdeadbeef')
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Engine from './Engine.js';
+/**
+ * WASM implementations of Ox's supported Ed25519 primitives.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Ed25519 } from 'ox/wasm'
+ *
+ * await Engine.install({ Ed25519: Ed25519.engine() })
+ *
+ * Ed25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Ed25519 from './Ed25519.js';
+/**
+ * WASM implementations of Ox's supported hash primitives.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Hash } from 'ox/wasm'
+ *
+ * await Engine.install({ Hash: Hash.engine() })
+ *
+ * Hash.sha256('0xdeadbeef')
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Hash from './Hash.js';
+/**
+ * WASM implementation of Ox's synchronous PBKDF2-HMAC-SHA256 primitive.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Keystore } from 'ox/wasm'
+ *
+ * await Engine.install({ Keystore: Keystore.engine() })
+ *
+ * Keystore.pbkdf2({ password: 'testpassword' })
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Keystore from './Keystore.js';
+/**
+ * WASM implementation of Ox's BIP-39 seed derivation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Mnemonic } from 'ox/wasm'
+ *
+ * await Engine.install({ Mnemonic: Mnemonic.engine() })
+ *
+ * Mnemonic.toSeed(
+ *   'test test test test test test test test test test test junk'
+ * )
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Mnemonic from './Mnemonic.js';
+/**
+ * WASM implementations of Ox's supported X25519 primitives.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { X25519 } from 'ox/wasm'
+ *
+ * await Engine.install({ X25519: X25519.engine() })
+ *
+ * X25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @category Crypto
+ */
+export * as X25519 from './X25519.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/wasm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wasm/index.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA"}