ox 1.1.2 → 1.2.0

package/dist/trusted-setups/internal/setups/mainnet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mainnet.js","sourceRoot":"","sources":["../../../../src/trusted-setups/internal/setups/mainnet.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,EAAE;AACF,+DAA+D;AAC/D,+EAA+E;AAE/E,iDAAiD;AACjD,MAAM,CAAC,MAAM,UAAU,GACrB,kggQAAkggQ,CAAA;AAEpggQ,iDAAiD;AACjD,MAAM,CAAC,MAAM,UAAU,GACrB,kggQAAkggQ,CAAA;AAEpggQ,iDAAiD;AACjD,MAAM,CAAC,MAAM,UAAU,GACrB,koQAAkoQ,CAAA"}

package/dist/wasm/Engine.d.ts

@@ -2,7 +2,6 @@ import * as CoreEngine from '../core/Engine.js';
 import type * as Errors from '../core/Errors.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';
 import type * as internal from './internal/instantiate.js';
@@ -62,7 +61,9 @@ export declare namespace engine {
     type ReturnType = {
         Ed25519: Ed25519.engine.ReturnType;
         Hash: Hash.engine.ReturnType;
-        Keystore: Keystore.engine.ReturnType;
+        Keystore: {
+            pbkdf2Sha256: NonNullable<CoreEngine.Keystore['pbkdf2Sha256']>;
+        };
         Mnemonic: Mnemonic.engine.ReturnType;
         X25519: X25519.engine.ReturnType;
     };

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

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../src/wasm/Engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAChD,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;AACrC,OAAO,KAAK,KAAK,QAAQ,MAAM,2BAA2B,CAAA;AAE1D,OAAO,EACL,eAAe,EACf,GAAG,EACH,qBAAqB,EACrB,KAAK,EACL,GAAG,EACH,qBAAqB,EACrB,gBAAgB,EAChB,IAAI,GACL,MAAM,mBAAmB,CAAA;AAC1B,YAAY,EACV,GAAG,EACH,IAAI,EACJ,KAAK,EACL,KAAK,EACL,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,QAAQ,GACT,MAAM,mBAAmB,CAAA;AAE1B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAQ3D;AAED,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC;IAC/B,KAAK,UAAU,GAAG,MAAM,CAAC,UAAU,CAAA;IAEnC,KAAK,SAAS,GACV,MAAM,CAAC,SAAS,GAChB,UAAU,CAAC,OAAO,CAAC,SAAS,GAC5B,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAezD;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,6EAA6E;IAC7E,KAAK,UAAU,GAAG;QAChB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,CAAA;QAClC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,CAAA;QAC5B,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAA;QACpC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAA;QACpC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAA;KACjC,CAAA;IAED,KAAK,SAAS,GAAG,QAAQ,CAAC,WAAW,GAAG,MAAM,CAAC,eAAe,CAAA;CAC/D"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../src/wasm/Engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,KAAK,QAAQ,MAAM,2BAA2B,CAAA;AAE1D,OAAO,EACL,eAAe,EACf,GAAG,EACH,qBAAqB,EACrB,KAAK,EACL,GAAG,EACH,qBAAqB,EACrB,gBAAgB,EAChB,IAAI,GACL,MAAM,mBAAmB,CAAA;AAC1B,YAAY,EACV,GAAG,EACH,IAAI,EACJ,KAAK,EACL,KAAK,EACL,MAAM,EACN,IAAI,EACJ,QAAQ,EACR,QAAQ,GACT,MAAM,mBAAmB,CAAA;AAE1B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAQ3D;AAED,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC;IAC/B,KAAK,UAAU,GAAG,MAAM,CAAC,UAAU,CAAA;IAEnC,KAAK,SAAS,GACV,MAAM,CAAC,SAAS,GAChB,UAAU,CAAC,OAAO,CAAC,SAAS,GAC5B,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAezD;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,6EAA6E;IAC7E,KAAK,UAAU,GAAG;QAChB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,CAAA;QAClC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,CAAA;QAC5B,QAAQ,EAAE;YACR,YAAY,EAAE,WAAW,CAAC,UAAU,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAA;SAC/D,CAAA;QACD,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAA;QACpC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAA;KACjC,CAAA;IAED,KAAK,SAAS,GAAG,QAAQ,CAAC,WAAW,GAAG,MAAM,CAAC,eAAe,CAAA;CAC/D"}

package/dist/wasm/Engine.js

@@ -1,7 +1,7 @@
 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 keystore from './internal/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';
@@ -31,7 +31,7 @@ export async function install() {
     return CoreEngine.install({
         Ed25519: Ed25519.engine(),
         Hash: Hash.engine(),
-        Keystore: Keystore.engine(),
+        Keystore: keystore.engine(),
         Mnemonic: Mnemonic.engine(),
         X25519: X25519.engine(),
     });
@@ -58,17 +58,17 @@ export async function install() {
  * @returns An engine, ready to install.
  */
 export async function engine() {
-    const [ed25519, hash, keystore, mnemonic, x25519] = await Promise.all([
+    const [ed25519, hash, keystoreEngine, mnemonic, x25519] = await Promise.all([
         Ed25519.engine(),
         Hash.engine(),
-        Keystore.engine(),
+        keystore.engine(),
         Mnemonic.engine(),
         X25519.engine(),
     ]);
     return {
         Ed25519: ed25519,
         Hash: hash,
-        Keystore: keystore,
+        Keystore: keystoreEngine,
         Mnemonic: mnemonic,
         X25519: x25519,
     };

package/dist/wasm/Engine.js.map

@@ -1 +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"}
+{"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,wBAAwB,CAAA;AAClD,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,cAAc,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC1E,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,cAAc;QACxB,QAAQ,EAAE,QAAQ;QAClB,MAAM,EAAE,MAAM;KACf,CAAA;AACH,CAAC"}

package/dist/wasm/Keystore.d.ts

@@ -4,14 +4,26 @@ 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.
+ * Compiles the WASM implementations of the [`Keystore`](/api/Keystore)
+ * synchronous key-derivation primitives, without installing them.
  *
- * 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.
+ * Most callers can use [`Engine.install`](/wasm/crypto/Engine/install).
+ * Install this factory explicitly when an application has benchmarked and
+ * selected WASM scrypt.
+ *
+ * This provider stays synchronous and leaves AES and asynchronous key
+ * derivation on Ox's default implementation.
+ *
+ * Scrypt uses a standalone artifact and grows memory only when called.
+ * WebAssembly cannot shrink that capacity. The provider clears its contents
+ * and enforces Noble's 1 GiB temporary-workspace limit.
+ *
+ * The aggregate [`Engine.install`](/wasm/crypto/Engine/install) installs only
+ * PBKDF2 from this provider. Install this factory explicitly to opt into
+ * scrypt, whose relative performance depends on its parameters and runtime.
+ *
+ * Copied inputs, derived output, and the complete workspace are cleared after
+ * every return or trap.
  *
  * @example
  * ```ts twoslash
@@ -21,16 +33,18 @@ export { MemoryError } from './internal/instantiate.js';
  *
  * await Engine.install({ Keystore: Keystore.engine() })
  *
- * Keystore.pbkdf2({ password: 'testpassword' })
+ * Keystore.scrypt({ password: 'testpassword' })
  * ```
  *
- * @returns The WASM implementation of synchronous PBKDF2-HMAC-SHA256.
+ * @returns The WASM implementations of synchronous PBKDF2-HMAC-SHA256 and
+ * scrypt.
  */
 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']>;
+        scrypt: NonNullable<Engine.Keystore['scrypt']>;
     };
     type ErrorType = internal.MemoryError | Errors.GlobalErrorType;
 }

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

@@ -1 +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"}
+{"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;AAChD,OAAO,KAAK,QAAQ,MAAM,2BAA2B,CAAA;AAIrD,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAUzD;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;QAC1D,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/Keystore.js

@@ -1,16 +1,28 @@
-import * as hashes from './internal/hashes.js';
-import * as pbkdf2 from './internal/pbkdf2.js';
+import * as keystore from './internal/keystore.js';
+import * as scrypt from './internal/scrypt.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.
+ * Compiles the WASM implementations of the [`Keystore`](/api/Keystore)
+ * synchronous key-derivation primitives, without installing them.
  *
- * 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.
+ * Most callers can use [`Engine.install`](/wasm/crypto/Engine/install).
+ * Install this factory explicitly when an application has benchmarked and
+ * selected WASM scrypt.
+ *
+ * This provider stays synchronous and leaves AES and asynchronous key
+ * derivation on Ox's default implementation.
+ *
+ * Scrypt uses a standalone artifact and grows memory only when called.
+ * WebAssembly cannot shrink that capacity. The provider clears its contents
+ * and enforces Noble's 1 GiB temporary-workspace limit.
+ *
+ * The aggregate [`Engine.install`](/wasm/crypto/Engine/install) installs only
+ * PBKDF2 from this provider. Install this factory explicitly to opt into
+ * scrypt, whose relative performance depends on its parameters and runtime.
+ *
+ * Copied inputs, derived output, and the complete workspace are cleared after
+ * every return or trap.
  *
  * @example
  * ```ts twoslash
@@ -20,15 +32,20 @@ export { MemoryError } from './internal/instantiate.js';
  *
  * await Engine.install({ Keystore: Keystore.engine() })
  *
- * Keystore.pbkdf2({ password: 'testpassword' })
+ * Keystore.scrypt({ password: 'testpassword' })
  * ```
  *
- * @returns The WASM implementation of synchronous PBKDF2-HMAC-SHA256.
+ * @returns The WASM implementations of synchronous PBKDF2-HMAC-SHA256 and
+ * scrypt.
  */
 export async function engine() {
-    const module = await hashes.load();
+    const [keystoreEngine, scryptModule] = await Promise.all([
+        keystore.engine(),
+        scrypt.load(),
+    ]);
     return {
-        pbkdf2Sha256: (password, salt, options) => pbkdf2.pbkdf2Sha256(module, password, salt, options),
+        ...keystoreEngine,
+        scrypt: (password, salt, options) => scrypt.derive(scryptModule, password, salt, options),
     };
 }
 //# sourceMappingURL=Keystore.js.map

package/dist/wasm/Keystore.js.map

@@ -1 +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"}
+{"version":3,"file":"Keystore.js","sourceRoot":"","sources":["../../src/wasm/Keystore.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,QAAQ,MAAM,wBAAwB,CAAA;AAClD,OAAO,KAAK,MAAM,MAAM,sBAAsB,CAAA;AAE9C,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM;IAC1B,MAAM,CAAC,cAAc,EAAE,YAAY,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QACvD,QAAQ,CAAC,MAAM,EAAE;QACjB,MAAM,CAAC,IAAI,EAAE;KACd,CAAC,CAAA;IACF,OAAO;QACL,GAAG,cAAc;QACjB,MAAM,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAClC,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC;KACvD,CAAA;AACH,CAAC"}

package/dist/wasm/Kzg.d.ts

@@ -0,0 +1,112 @@
+import * as Bytes from '../core/Bytes.js';
+import * as Errors from '../core/Errors.js';
+import type * as CoreKzg from '../core/Kzg.js';
+export * from '../core/Kzg.js';
+/**
+ * Trusted setup points accepted by `create`.
+ *
+ * Point arrays use the established Ethereum trusted-setup field names. Each
+ * field may also be supplied as one packed byte array.
+ */
+export type TrustedSetup = {
+    /** 4,096 G1 points in Lagrange form. */
+    readonly g1_lagrange: Bytes.Bytes | readonly string[];
+    /** 4,096 G1 points in monomial form. */
+    readonly g1_monomial: Bytes.Bytes | readonly string[];
+    /** 65 G2 points in monomial form. */
+    readonly g2_monomial: Bytes.Bytes | readonly string[];
+};
+/**
+ * Creates an independently owned WASM implementation of [`Kzg.Kzg`](/api/Kzg).
+ *
+ * The factory compiles the c-kzg artifact once per JavaScript realm. Every call
+ * instantiates separate WASM memory and trusted-setup state. Call `dispose` when
+ * the instance is no longer needed.
+ *
+ * Operations on an instance are synchronous and run to completion. JavaScript
+ * workers do not share an instance, so create one in each worker that needs KZG.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Setups } from 'ox/trusted-setups'
+ * import { Kzg } from 'ox/wasm'
+ *
+ * const kzg = await Kzg.create({
+ *   trustedSetup: Setups.mainnet
+ * })
+ * // Pass `kzg` anywhere that accepts `Kzg.Kzg`.
+ *
+ * kzg.dispose()
+ * ```
+ *
+ * @param options - Trusted setup and precomputation options.
+ * @returns An initialized KZG implementation with explicit disposal.
+ */
+export declare function create(options: create.Options): Promise<create.ReturnType>;
+export declare namespace create {
+    /** Options for `create`. */
+    type Options = {
+        /**
+         * Fixed-base MSM window from 0 through 8.
+         *
+         * `0` performs no fixed-base precomputation and uses the least memory.
+         * Larger values improve proof generation at an exponential memory cost.
+         *
+         * @default 0
+         */
+        precompute?: number | undefined;
+        /** Ethereum trusted-setup points. */
+        trustedSetup: TrustedSetup;
+    };
+    /** An initialized KZG implementation with explicit lifecycle ownership. */
+    type ReturnType = CoreKzg.Kzg & {
+        /**
+         * Releases the trusted setup and makes every operation throw.
+         *
+         * Disposal is idempotent.
+         */
+        dispose(): void;
+    };
+    type ErrorType = DisposedError | InvalidInputError | InvalidPrecomputeError | InvalidTrustedSetupError | MemoryError | WasmError | Errors.GlobalErrorType;
+}
+/** Thrown when an operation is called after its KZG instance was disposed. */
+export declare class DisposedError extends Errors.BaseError {
+    readonly name = "Kzg.DisposedError";
+    constructor();
+}
+/** Thrown when a KZG operation receives malformed input. */
+export declare class InvalidInputError extends Errors.BaseError {
+    readonly name = "Kzg.InvalidInputError";
+    constructor({ message }: {
+        message: string;
+    });
+}
+/** Thrown when `precompute` is outside the supported memory bound. */
+export declare class InvalidPrecomputeError extends Errors.BaseError {
+    readonly name = "Kzg.InvalidPrecomputeError";
+    constructor({ precompute }: {
+        precompute: number;
+    });
+}
+/** Thrown when c-kzg rejects the trusted setup. */
+export declare class InvalidTrustedSetupError extends Errors.BaseError {
+    readonly name = "Kzg.InvalidTrustedSetupError";
+    constructor(options?: {
+        message?: string | undefined;
+    });
+}
+/** Thrown when the KZG artifact reaches its 128 MiB memory limit. */
+export declare class MemoryError extends Errors.BaseError {
+    readonly name = "Kzg.MemoryError";
+    constructor();
+}
+/** Thrown when the KZG artifact traps or reports an internal error. */
+export declare class WasmError extends Errors.BaseError<Error | undefined> {
+    readonly name = "Kzg.WasmError";
+    constructor(options?: {
+        cause?: Error | undefined;
+        operation?: string | undefined;
+    });
+}
+//# sourceMappingURL=Kzg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Kzg.d.ts","sourceRoot":"","sources":["../../src/wasm/Kzg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAE3C,OAAO,KAAK,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAG9C,cAAc,gBAAgB,CAAA;AAU9B;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,KAAK,GAAG,SAAS,MAAM,EAAE,CAAA;IACrD,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,KAAK,GAAG,SAAS,MAAM,EAAE,CAAA;IACrD,qCAAqC;IACrC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,KAAK,GAAG,SAAS,MAAM,EAAE,CAAA;CACtD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,MAAM,CAC1B,OAAO,EAAE,MAAM,CAAC,OAAO,GACtB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAiN5B;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,4BAA4B;IAC5B,KAAK,OAAO,GAAG;QACb;;;;;;;WAOG;QACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC/B,qCAAqC;QACrC,YAAY,EAAE,YAAY,CAAA;KAC3B,CAAA;IAED,2EAA2E;IAC3E,KAAK,UAAU,GAAG,OAAO,CAAC,GAAG,GAAG;QAC9B;;;;WAIG;QACH,OAAO,IAAI,IAAI,CAAA;KAChB,CAAA;IAED,KAAK,SAAS,GACV,aAAa,GACb,iBAAiB,GACjB,sBAAsB,GACtB,wBAAwB,GACxB,WAAW,GACX,SAAS,GACT,MAAM,CAAC,eAAe,CAAA;CAC3B;AAkJD,8EAA8E;AAC9E,qBAAa,aAAc,SAAQ,MAAM,CAAC,SAAS;IACjD,SAAkB,IAAI,uBAAsB;;CAK7C;AAED,4DAA4D;AAC5D,qBAAa,iBAAkB,SAAQ,MAAM,CAAC,SAAS;IACrD,SAAkB,IAAI,2BAA0B;gBAEpC,EAAE,OAAO,EAAE,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;CAG7C;AAED,sEAAsE;AACtE,qBAAa,sBAAuB,SAAQ,MAAM,CAAC,SAAS;IAC1D,SAAkB,IAAI,gCAA+B;gBAEzC,EAAE,UAAU,EAAE,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE;CAKnD;AAED,mDAAmD;AACnD,qBAAa,wBAAyB,SAAQ,MAAM,CAAC,SAAS;IAC5D,SAAkB,IAAI,kCAAiC;gBAE3C,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAO;CAG3D;AAED,qEAAqE;AACrE,qBAAa,WAAY,SAAQ,MAAM,CAAC,SAAS;IAC/C,SAAkB,IAAI,qBAAoB;;CAU3C;AAED,uEAAuE;AACvE,qBAAa,SAAU,SAAQ,MAAM,CAAC,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC;IAChE,SAAkB,IAAI,mBAAkB;gBAGtC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAO;CAS9E"}

package/dist/wasm/Kzg.js

@@ -0,0 +1,333 @@
+import * as Errors from '../core/Errors.js';
+import * as Hex from '../core/Hex.js';
+export * from '../core/Kzg.js';
+const blobSize = 131_072;
+const cellSize = 2_048;
+const cellsPerBlob = 128;
+const commitmentSize = 48;
+const g1Points = 4_096;
+const g2Points = 65;
+const proofSize = 48;
+/**
+ * Creates an independently owned WASM implementation of [`Kzg.Kzg`](/api/Kzg).
+ *
+ * The factory compiles the c-kzg artifact once per JavaScript realm. Every call
+ * instantiates separate WASM memory and trusted-setup state. Call `dispose` when
+ * the instance is no longer needed.
+ *
+ * Operations on an instance are synchronous and run to completion. JavaScript
+ * workers do not share an instance, so create one in each worker that needs KZG.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Setups } from 'ox/trusted-setups'
+ * import { Kzg } from 'ox/wasm'
+ *
+ * const kzg = await Kzg.create({
+ *   trustedSetup: Setups.mainnet
+ * })
+ * // Pass `kzg` anywhere that accepts `Kzg.Kzg`.
+ *
+ * kzg.dispose()
+ * ```
+ *
+ * @param options - Trusted setup and precomputation options.
+ * @returns An initialized KZG implementation with explicit disposal.
+ */
+export async function create(options) {
+    const { trustedSetup } = options;
+    const precompute = options.precompute ?? 0;
+    if (!Number.isInteger(precompute) || precompute < 0 || precompute > 8)
+        throw new InvalidPrecomputeError({ precompute });
+    const setup = {
+        g1Lagrange: normalizePoints(trustedSetup.g1_lagrange, g1Points, commitmentSize, 'g1_lagrange'),
+        g1Monomial: normalizePoints(trustedSetup.g1_monomial, g1Points, commitmentSize, 'g1_monomial'),
+        g2Monomial: normalizePoints(trustedSetup.g2_monomial, g2Points, 96, 'g2_monomial'),
+    };
+    const { instantiate } = await import('./internal/kzg.js');
+    let module = await instantiate();
+    const getModule = () => {
+        if (!module)
+            throw new DisposedError();
+        return module;
+    };
+    try {
+        const initialized = getModule();
+        withBuffers(initialized, [setup.g1Monomial, setup.g1Lagrange, setup.g2Monomial], [], ([g1Monomial, g1Lagrange, g2Monomial]) => {
+            assertReturn(initialized.exports.kzg_initialize(g1Monomial, g1Lagrange, g2Monomial, precompute), 'initialize');
+        });
+    }
+    catch (error) {
+        module?.exports.kzg_dispose();
+        module = undefined;
+        throw error;
+    }
+    const instance = {
+        blobToKzgCommitment(blob) {
+            assertBytes(blob, blobSize, 'blob');
+            return withBuffers(getModule(), [blob], [commitmentSize], ([blob], [out]) => {
+                const module = getModule();
+                assertReturn(module.exports.kzg_blob_to_kzg_commitment(out, blob), 'blobToKzgCommitment');
+            })[0];
+        },
+        computeCells(blob) {
+            assertBytes(blob, blobSize, 'blob');
+            const bytes = withBuffers(getModule(), [blob], [cellsPerBlob * cellSize], ([blob], [cells]) => {
+                const module = getModule();
+                assertReturn(module.exports.kzg_compute_cells(cells, blob), 'computeCells');
+            })[0];
+            return split(bytes, cellSize);
+        },
+        computeCellsAndKzgProofs(blob) {
+            assertBytes(blob, blobSize, 'blob');
+            const [cells, proofs] = withBuffers(getModule(), [blob], [cellsPerBlob * cellSize, cellsPerBlob * proofSize], ([blob], [cells, proofs]) => {
+                const module = getModule();
+                assertReturn(module.exports.kzg_compute_cells_and_kzg_proofs(cells, proofs, blob), 'computeCellsAndKzgProofs');
+            });
+            return {
+                cells: split(cells, cellSize),
+                proofs: split(proofs, proofSize),
+            };
+        },
+        dispose() {
+            if (!module)
+                return;
+            const initialized = module;
+            module = undefined;
+            initialized.exports.kzg_dispose();
+        },
+        recoverCellsAndKzgProofs(cellIndices, cells) {
+            if (cellIndices.length !== cells.length)
+                throw new InvalidInputError({
+                    message: '`cellIndices` and `cells` must have the same length.',
+                });
+            if (cells.length < 64 || cells.length > cellsPerBlob)
+                throw new InvalidInputError({
+                    message: '`cells` must contain between 64 and 128 cells.',
+                });
+            assertCellIndices(cellIndices, true);
+            for (const cell of cells)
+                assertBytes(cell, cellSize, 'cell');
+            const values = cellIndices
+                .map((index, i) => ({ cell: cells[i], index }))
+                .sort((a, b) => a.index - b.index);
+            const indices = values.map(({ index }) => index);
+            const sortedCells = values.map(({ cell }) => cell);
+            const [recoveredCells, proofs] = withBuffers(getModule(), [encodeIndices(indices), concat(sortedCells)], [cellsPerBlob * cellSize, cellsPerBlob * proofSize], ([indices, cells], [recoveredCells, proofs]) => {
+                const module = getModule();
+                assertReturn(module.exports.kzg_recover_cells_and_kzg_proofs(recoveredCells, proofs, indices, cells, values.length), 'recoverCellsAndKzgProofs');
+            });
+            return {
+                cells: split(recoveredCells, cellSize),
+                proofs: split(proofs, proofSize),
+            };
+        },
+        verifyCellKzgProofBatch(commitments, cellIndices, cells, proofs) {
+            const count = commitments.length;
+            if (count === 0 ||
+                cellIndices.length !== count ||
+                cells.length !== count ||
+                proofs.length !== count)
+                throw new InvalidInputError({
+                    message: '`commitments`, `cellIndices`, `cells`, and `proofs` must have the same non-zero length.',
+                });
+            assertCellIndices(cellIndices, false);
+            for (const commitment of commitments)
+                assertBytes(commitment, commitmentSize, 'commitment');
+            for (const cell of cells)
+                assertBytes(cell, cellSize, 'cell');
+            for (const proof of proofs)
+                assertBytes(proof, proofSize, 'proof');
+            return (withBuffers(getModule(), [
+                concat(commitments),
+                encodeIndices(cellIndices),
+                concat(cells),
+                concat(proofs),
+            ], [4], ([commitments, indices, cells, proofs], [verified]) => {
+                const module = getModule();
+                assertReturn(module.exports.kzg_verify_cell_kzg_proof_batch(verified, commitments, indices, cells, proofs, count), 'verifyCellKzgProofBatch');
+            })[0][0] === 1);
+        },
+    };
+    return instance;
+}
+function assertBytes(value, size, name) {
+    if (!(value instanceof Uint8Array) || value.length !== size)
+        throw new InvalidInputError({
+            message: `\`${name}\` must contain exactly ${size} bytes.`,
+        });
+}
+function assertCellIndices(indices, unique) {
+    const seen = new Set();
+    for (const index of indices) {
+        if (!Number.isInteger(index) || index < 0 || index >= cellsPerBlob)
+            throw new InvalidInputError({
+                message: '`cellIndices` must contain integers from 0 through 127.',
+            });
+        if (unique && seen.has(index))
+            throw new InvalidInputError({
+                message: '`cellIndices` must not contain duplicate indices.',
+            });
+        seen.add(index);
+    }
+}
+function assertReturn(value, operation) {
+    if (value === 0)
+        return;
+    if (value === 1)
+        throw operation === 'initialize'
+            ? new InvalidTrustedSetupError()
+            : new InvalidInputError({ message: `c-kzg rejected \`${operation}\`.` });
+    if (value === 3)
+        throw new MemoryError();
+    throw new WasmError({ operation });
+}
+function concat(values) {
+    const size = values.reduce((size, value) => size + value.length, 0);
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const value of values) {
+        result.set(value, offset);
+        offset += value.length;
+    }
+    return result;
+}
+function encodeIndices(indices) {
+    const bytes = new Uint8Array(indices.length * 8);
+    const view = new DataView(bytes.buffer);
+    for (let i = 0; i < indices.length; i++)
+        view.setBigUint64(i * 8, BigInt(indices[i]), true);
+    return bytes;
+}
+function normalizePoints(value, count, size, name) {
+    const expected = count * size;
+    if (value instanceof Uint8Array) {
+        if (value.length !== expected)
+            throw new InvalidTrustedSetupError({
+                message: `\`${name}\` must contain exactly ${expected} bytes.`,
+            });
+        return Uint8Array.from(value);
+    }
+    if (!Array.isArray(value) || value.length !== count)
+        throw new InvalidTrustedSetupError({
+            message: `\`${name}\` must contain exactly ${count} points.`,
+        });
+    const result = new Uint8Array(expected);
+    for (let i = 0; i < value.length; i++) {
+        const point = value[i];
+        try {
+            const bytes = Hex.toBytes(point);
+            if (bytes.length !== size)
+                throw new Error();
+            result.set(bytes, i * size);
+        }
+        catch {
+            throw new InvalidTrustedSetupError({
+                message: `\`${name}[${i}]\` must be a ${size}-byte hex value.`,
+            });
+        }
+    }
+    return result;
+}
+function split(value, size) {
+    const result = [];
+    for (let offset = 0; offset < value.length; offset += size)
+        result.push(value.slice(offset, offset + size));
+    return result;
+}
+function withBuffers(module, inputs, outputs, call) {
+    const inputPointers = [];
+    const outputPointers = [];
+    try {
+        for (const input of inputs)
+            inputPointers.push(allocate(module, input.length));
+        for (const size of outputs)
+            outputPointers.push(allocate(module, size));
+        const view = module.view();
+        for (let i = 0; i < inputs.length; i++)
+            view.set(inputs[i], inputPointers[i]);
+        call(inputPointers, outputPointers);
+        return outputs.map((size, i) => module.view().slice(outputPointers[i], outputPointers[i] + size));
+    }
+    catch (cause) {
+        if (cause instanceof Errors.BaseError)
+            throw cause;
+        throw new WasmError({ cause: cause });
+    }
+    finally {
+        for (let i = 0; i < inputs.length; i++) {
+            const pointer = inputPointers[i];
+            if (!pointer)
+                continue;
+            module.exports.zero(pointer, inputs[i].length);
+            module.exports.dealloc(pointer);
+        }
+        for (let i = 0; i < outputs.length; i++) {
+            const pointer = outputPointers[i];
+            if (!pointer)
+                continue;
+            module.exports.zero(pointer, outputs[i]);
+            module.exports.dealloc(pointer);
+        }
+    }
+}
+function allocate(module, size) {
+    const pointer = module.exports.alloc(size);
+    if (!pointer)
+        throw new MemoryError();
+    return pointer;
+}
+/** Thrown when an operation is called after its KZG instance was disposed. */
+export class DisposedError extends Errors.BaseError {
+    name = 'Kzg.DisposedError';
+    constructor() {
+        super('KZG instance has been disposed.');
+    }
+}
+/** Thrown when a KZG operation receives malformed input. */
+export class InvalidInputError extends Errors.BaseError {
+    name = 'Kzg.InvalidInputError';
+    constructor({ message }) {
+        super(message);
+    }
+}
+/** Thrown when `precompute` is outside the supported memory bound. */
+export class InvalidPrecomputeError extends Errors.BaseError {
+    name = 'Kzg.InvalidPrecomputeError';
+    constructor({ precompute }) {
+        super(`\`precompute\` must be an integer from 0 through 8. Got ${precompute}.`);
+    }
+}
+/** Thrown when c-kzg rejects the trusted setup. */
+export class InvalidTrustedSetupError extends Errors.BaseError {
+    name = 'Kzg.InvalidTrustedSetupError';
+    constructor(options = {}) {
+        super(options.message ?? 'c-kzg rejected the trusted setup.');
+    }
+}
+/** Thrown when the KZG artifact reaches its 128 MiB memory limit. */
+export class MemoryError extends Errors.BaseError {
+    name = 'Kzg.MemoryError';
+    constructor() {
+        super('KZG WASM memory limit was exceeded.', {
+            metaMessages: [
+                'The artifact grows memory on demand up to 128 MiB.',
+                'Use a smaller `precompute` value or batch fewer proofs.',
+            ],
+        });
+    }
+}
+/** Thrown when the KZG artifact traps or reports an internal error. */
+export class WasmError extends Errors.BaseError {
+    name = 'Kzg.WasmError';
+    constructor(options = {}) {
+        super('KZG WASM operation failed.', {
+            cause: options.cause,
+            metaMessages: options.operation
+                ? [`Operation: ${options.operation}`]
+                : undefined,
+        });
+    }
+}
+//# sourceMappingURL=Kzg.js.map