pshenmic-dpp 2.0.0-dev.23 → 2.0.0-dev.25

package/dist/binaries/wasmCreation.cjs

@@ -1,46 +1,127 @@
 "use strict";
 const { WASI } = require('@tybys/wasm-util');
 const { getDefaultContext } = require('@emnapi/runtime');
-const { instantiateNapiModuleSync } = require('@emnapi/core');
-const { bytes } = require('./wasm/wasmBytes.cjs');
-const { decode } = require('../utils/base122.cjs');
-const { decompressSync } = require('fflate');
-const wasmBytes = new Uint8Array(decode(bytes));
-const wasi = new WASI({
-    version: 'preview1',
-    print: function () {
-        console.log.apply(console, arguments);
-    },
-    printErr: function () {
-        console.error.apply(console, arguments);
-    }
-});
+const { instantiateNapiModuleSync, MessageHandler } = require('@emnapi/core');
 const emnapiContext = getDefaultContext();
 emnapiContext.feature.supportNewFunction = false;
 emnapiContext.feature.supportBigInt = false;
-const __sharedMemory = new WebAssembly.Memory({
-    initial: 1000,
-    maximum: 2000,
-    shared: true
-});
-const wasm = instantiateNapiModuleSync(decompressSync(wasmBytes), {
-    context: emnapiContext,
-    wasi,
-    overwriteImports(importObject) {
-        importObject.env = {
-            ...importObject.env,
-            ...importObject.napi,
-            ...importObject.emnapi,
-            memory: __sharedMemory
-        };
-    },
-    beforeInit({ instance }) {
-        for (const name of Object.keys(instance.exports)) {
-            if (name.startsWith('__napi_register__')) {
-                instance.exports[name]();
-            }
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+const nodeWorkerThreads = isNode ? require('worker_threads') : null;
+const isWorker = isNode
+    ? !nodeWorkerThreads.isMainThread
+    : (typeof self !== 'undefined' && !self.document);
+if (isWorker) {
+    // wasi pthread worker: the main thread posts the compiled module + shared
+    // memory here and this instantiates a child-thread copy over them. Async
+    // `#[napi]` fns (the Halo 2 proving stack) run on these threads.
+    const postMsg = isNode
+        ? (d) => nodeWorkerThreads.parentPort.postMessage(d)
+        : (d) => self.postMessage(d);
+    if (isNode) {
+        // emnapi's threadsafe-function dispatch calls the bare global
+        // `postMessage` from pthread contexts (a Web Worker global); Node
+        // worker_threads doesn't have it, so polyfill with parentPort.
+        globalThis.self = globalThis;
+        globalThis.postMessage = postMsg;
+    }
+    const handler = new MessageHandler({
+        postMessage: postMsg,
+        onLoad({ wasmModule, wasmMemory }) {
+            const wasi = new WASI({ version: 'preview1' });
+            return instantiateNapiModuleSync(wasmModule, {
+                childThread: true,
+                wasi,
+                context: emnapiContext,
+                postMessage: postMsg,
+                overwriteImports(importObject) {
+                    importObject.env = {
+                        ...importObject.env,
+                        ...importObject.napi,
+                        ...importObject.emnapi,
+                        memory: wasmMemory
+                    };
+                }
+            });
         }
+    });
+    if (isNode) {
+        nodeWorkerThreads.parentPort.on('message', (data) => handler.handle({ data }));
     }
-});
-module.exports = wasm.napiModule.exports;
-module.exports.default = wasm.napiModule.exports;
+    else {
+        self.onmessage = (e) => handler.handle({ data: e.data });
+    }
+    module.exports = null;
+}
+else {
+    // Main thread only. This block must NEVER run in a worker: it decodes,
+    // decompresses and sync-compiles the whole 7.5MB module and allocates a
+    // fresh 64MB shared memory — workers receive the already-compiled module
+    // and the real memory via the 'load' message instead. Running it per
+    // worker multiplies init time by the core count (rayon spawns one thread
+    // per core while building the proving key).
+    const { bytes } = require('./wasm/wasmBytes.cjs');
+    const { decode } = require('../utils/base122.cjs');
+    const { decompressSync } = require('fflate');
+    const { default: sharedMemory } = require('./memory.cjs');
+    const wasmBytes = new Uint8Array(decode(bytes));
+    const wasi = new WASI({
+        version: 'preview1',
+        print: function () {
+            console.log.apply(console, arguments);
+        },
+        printErr: function () {
+            console.error.apply(console, arguments);
+        }
+    });
+    let workerBlobUrl;
+    const wasm = instantiateNapiModuleSync(decompressSync(wasmBytes), {
+        context: emnapiContext,
+        wasi,
+        // Threads are spawned lazily (first async `#[napi]` call), so
+        // instantiation stays synchronous: emnapi only forbids sync loading
+        // with a PREloaded worker pool (`reuseWorker.size > 0`). `true` keeps
+        // size 0 but returns finished workers to a pool instead of
+        // terminating them, so repeated proving calls reuse them.
+        reuseWorker: true,
+        onCreateWorker() {
+            if (isNode) {
+                return new nodeWorkerThreads.Worker(__filename);
+            }
+            // Escape hatch for hosts that want to control worker creation
+            // (e.g. strict CSP environments where blob: workers are forbidden).
+            if (typeof globalThis.__PSHENMIC_DPP_CREATE_WORKER__ === 'function') {
+                return globalThis.__PSHENMIC_DPP_CREATE_WORKER__();
+            }
+            if (typeof Worker === 'undefined') {
+                throw new Error('Cannot create a wasm thread worker: no Worker constructor in this environment. ' +
+                    'Provide globalThis.__PSHENMIC_DPP_CREATE_WORKER__ returning a Worker running workerBundle.cjs `source`.');
+            }
+            // Self-contained worker (all emnapi deps inlined) spawned from a Blob
+            // URL, so it survives being bundled into a single file: the worker
+            // receives the compiled module + shared memory via postMessage and
+            // needs no access to this script's URL or the wasm bytes.
+            if (workerBlobUrl === undefined) {
+                const { source } = require('./wasm/workerBundle.cjs');
+                workerBlobUrl = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
+            }
+            return new Worker(workerBlobUrl, { name: 'pshenmic-dpp-wasm-thread' });
+        },
+        overwriteImports(importObject) {
+            importObject.env = {
+                ...importObject.env,
+                ...importObject.napi,
+                ...importObject.emnapi,
+                memory: sharedMemory
+            };
+        },
+        beforeInit({ instance }) {
+            for (const name of Object.keys(instance.exports)) {
+                if (name.startsWith('__napi_register__')) {
+                    instance.exports[name]();
+                }
+            }
+        }
+    });
+    module.exports = wasm.napiModule.exports;
+    module.exports.default = wasm.napiModule.exports;
+}

package/dist/binaries/wasmCreation.d.cts

@@ -1,2 +1,4 @@
 declare const _exports: any;
 export = _exports;
+declare const _exports: any;
+export = _exports;

package/dist/src/dpp/structs/Orchard/OrchardProver.d.ts

@@ -7,6 +7,13 @@ import type { OrchardProverNAPI } from '../../../../binaries/bindingsTypes.js';
 export declare class OrchardProverWASM {
     /** @private **/
     _rawOrchardProver: OrchardProverNAPI;
+    /**
+     * The proving key is deterministic and expensive (~10s), so it's built
+     * once per process and shared by every prover instance. Cleared on
+     * failure so a failed init can be retried.
+     */
+    private static _initPromise;
     constructor();
+    init(): Promise<void>;
     static createFromRawInstance(rawInstance: OrchardProverNAPI): OrchardProverWASM;
 }

package/dist/src/dpp/structs/Orchard/OrchardProver.js

@@ -7,8 +7,24 @@ import { dppProvider } from '../../provider.js';
 export class OrchardProverWASM {
     /** @private **/
     _rawOrchardProver;
+    /**
+     * The proving key is deterministic and expensive (~10s), so it's built
+     * once per process and shared by every prover instance. Cleared on
+     * failure so a failed init can be retried.
+     */
+    static _initPromise = null;
     constructor() {
-        this._rawOrchardProver = new dppProvider.dpp.OrchardProverNAPI();
+        // empty
+    }
+    async init() {
+        if (OrchardProverWASM._initPromise == null) {
+            OrchardProverWASM._initPromise = dppProvider.dpp.OrchardProverNAPI.init()
+                .catch((e) => {
+                OrchardProverWASM._initPromise = null;
+                throw e;
+            });
+        }
+        this._rawOrchardProver = await OrchardProverWASM._initPromise;
     }
     static createFromRawInstance(rawInstance) {
         const instance = Object.create(OrchardProverWASM.prototype);

package/dist/src/dpp/structs/Orchard/ShieldedBuilder.d.ts

@@ -24,17 +24,24 @@ import { IdentityCreateFromShieldedPoolResultWASM } from './IdentityCreateFromSh
 export declare class ShieldedBuilderWASM {
     /** @private **/
     _rawShieldedBuilder: ShieldedBuilderNAPI;
+    /**
+     * Building the Halo 2 proving key takes ~10s, and the key is deterministic,
+     * so it's built once per process: every builder instance shares the same
+     * raw builder. Cleared on failure so a failed init can be retried.
+     */
+    private static _initPromise;
     constructor();
+    init(): Promise<void>;
     /** Asset lock -> pool (deposit). */
-    shieldFromAssetLock(recipient: OrchardAddressWASM, shieldAmount: bigint, assetLockProof: AssetLockProofWASM, privateKey: PrivateKeyWASM, memo: ShieldedMemoWASM, dummyOutputs: number, senderOvk?: Uint8Array, surplusOutput?: PlatformAddressLike, platformVersion?: PlatformVersionNAPI): StateTransitionWASM;
+    shieldFromAssetLock(recipient: OrchardAddressWASM, shieldAmount: bigint, assetLockProof: AssetLockProofWASM, privateKey: PrivateKeyWASM, memo: ShieldedMemoWASM, dummyOutputs: number, senderOvk?: Uint8Array, surplusOutput?: PlatformAddressLike, platformVersion?: PlatformVersionNAPI): Promise<StateTransitionWASM>;
     /** Transparent platform addresses -> pool (deposit). One private key per input. */
-    shield(recipient: OrchardAddressWASM, shieldAmount: bigint, inputs: InputAddressWASM[], privateKeys: PrivateKeyWASM[], feeStrategy: AddressFundsFeeStrategyStepWASM[], userFeeIncrease: number, memo: ShieldedMemoWASM, senderOvk?: Uint8Array, platformVersion?: PlatformVersionNAPI): StateTransitionWASM;
+    shield(recipient: OrchardAddressWASM, shieldAmount: bigint, inputs: InputAddressWASM[], privateKeys: PrivateKeyWASM[], feeStrategy: AddressFundsFeeStrategyStepWASM[], userFeeIncrease: number, memo: ShieldedMemoWASM, senderOvk?: Uint8Array, platformVersion?: PlatformVersionNAPI): Promise<StateTransitionWASM>;
     /** Pool -> core L1 (spend). */
-    shieldedWithdrawal(spends: SpendableNoteWASM[], withdrawalAmount: bigint, outputScript: CoreScriptWASM, coreFeePerByte: number, pooling: PoolingLike, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): ShieldedWithdrawalResultWASM;
+    shieldedWithdrawal(spends: SpendableNoteWASM[], withdrawalAmount: bigint, outputScript: CoreScriptWASM, coreFeePerByte: number, pooling: PoolingLike, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): Promise<ShieldedWithdrawalResultWASM>;
     /** Pool -> platform identity balance (spend). */
-    unshield(spends: SpendableNoteWASM[], outputAddress: PlatformAddressLike, unshieldAmount: bigint, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): ShieldedWithdrawalResultWASM;
+    unshield(spends: SpendableNoteWASM[], outputAddress: PlatformAddressLike, unshieldAmount: bigint, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): Promise<ShieldedWithdrawalResultWASM>;
     /** Pool -> pool (spend). */
-    shieldedTransfer(spends: SpendableNoteWASM[], recipient: OrchardAddressWASM, transferAmount: bigint, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): ShieldedWithdrawalResultWASM;
+    shieldedTransfer(spends: SpendableNoteWASM[], recipient: OrchardAddressWASM, transferAmount: bigint, changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): Promise<ShieldedWithdrawalResultWASM>;
     /** Pool -> new identity (spend). One private key per public key, same order. */
-    identityCreateFromShieldedPool(publicKeys: IdentityPublicKeyInCreationWASM[], privateKeys: PrivateKeyWASM[], denomination: bigint, sendToAddressOnCreationFailure: PlatformAddressLike, spends: SpendableNoteWASM[], changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): IdentityCreateFromShieldedPoolResultWASM;
+    identityCreateFromShieldedPool(publicKeys: IdentityPublicKeyInCreationWASM[], privateKeys: PrivateKeyWASM[], denomination: bigint, sendToAddressOnCreationFailure: PlatformAddressLike, spends: SpendableNoteWASM[], changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, memo: ShieldedMemoWASM, platformVersion?: PlatformVersionNAPI): Promise<IdentityCreateFromShieldedPoolResultWASM>;
 }

package/dist/src/dpp/structs/Orchard/ShieldedBuilder.js

@@ -15,31 +15,47 @@ import { IdentityCreateFromShieldedPoolResultWASM } from './IdentityCreateFromSh
 export class ShieldedBuilderWASM {
     /** @private **/
     _rawShieldedBuilder;
+    /**
+     * Building the Halo 2 proving key takes ~10s, and the key is deterministic,
+     * so it's built once per process: every builder instance shares the same
+     * raw builder. Cleared on failure so a failed init can be retried.
+     */
+    static _initPromise = null;
     constructor() {
-        this._rawShieldedBuilder = new dppProvider.dpp.ShieldedBuilderNAPI();
+        // empty
+    }
+    async init() {
+        if (ShieldedBuilderWASM._initPromise == null) {
+            ShieldedBuilderWASM._initPromise = dppProvider.dpp.ShieldedBuilderNAPI.init()
+                .catch((e) => {
+                ShieldedBuilderWASM._initPromise = null;
+                throw e;
+            });
+        }
+        this._rawShieldedBuilder = await ShieldedBuilderWASM._initPromise;
     }
     /** Asset lock -> pool (deposit). */
-    shieldFromAssetLock(recipient, shieldAmount, assetLockProof, privateKey, memo, dummyOutputs, senderOvk, surplusOutput, platformVersion) {
-        return StateTransitionWASM.createFromRawInstance(this._rawShieldedBuilder.shieldFromAssetLock(recipient._rawOrchardAddress, shieldAmount.toString(), assetLockProof._rawAssetLockProof, privateKey._rawPrivateKey, memo._rawShieldedMemo, dummyOutputs, senderOvk, surplusOutput != null ? preparePlatformAddressValue(surplusOutput) : undefined, platformVersion));
+    async shieldFromAssetLock(recipient, shieldAmount, assetLockProof, privateKey, memo, dummyOutputs, senderOvk, surplusOutput, platformVersion) {
+        return StateTransitionWASM.createFromRawInstance(await this._rawShieldedBuilder.shieldFromAssetLock(recipient._rawOrchardAddress, shieldAmount.toString(), assetLockProof._rawAssetLockProof, privateKey._rawPrivateKey, memo._rawShieldedMemo, dummyOutputs, senderOvk, surplusOutput != null ? preparePlatformAddressValue(surplusOutput) : undefined, platformVersion));
     }
     /** Transparent platform addresses -> pool (deposit). One private key per input. */
-    shield(recipient, shieldAmount, inputs, privateKeys, feeStrategy, userFeeIncrease, memo, senderOvk, platformVersion) {
-        return StateTransitionWASM.createFromRawInstance(this._rawShieldedBuilder.shield(recipient._rawOrchardAddress, shieldAmount.toString(), inputs.map(i => i._rawInputAddress), privateKeys.map(k => k._rawPrivateKey), feeStrategy.map(s => s._rawAddressFundsFeeStrategyStep), userFeeIncrease, memo._rawShieldedMemo, senderOvk, platformVersion));
+    async shield(recipient, shieldAmount, inputs, privateKeys, feeStrategy, userFeeIncrease, memo, senderOvk, platformVersion) {
+        return StateTransitionWASM.createFromRawInstance(await this._rawShieldedBuilder.shield(recipient._rawOrchardAddress, shieldAmount.toString(), inputs.map(i => i._rawInputAddress), privateKeys.map(k => k._rawPrivateKey), feeStrategy.map(s => s._rawAddressFundsFeeStrategyStep), userFeeIncrease, memo._rawShieldedMemo, senderOvk, platformVersion));
     }
     /** Pool -> core L1 (spend). */
-    shieldedWithdrawal(spends, withdrawalAmount, outputScript, coreFeePerByte, pooling, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
-        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.shieldedWithdrawal(spends.map(s => s._rawSpendableNote), withdrawalAmount.toString(), outputScript._rawCoreScript, coreFeePerByte, valueToDynamicValue(pooling), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    async shieldedWithdrawal(spends, withdrawalAmount, outputScript, coreFeePerByte, pooling, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(await this._rawShieldedBuilder.shieldedWithdrawal(spends.map(s => s._rawSpendableNote), withdrawalAmount.toString(), outputScript._rawCoreScript, coreFeePerByte, valueToDynamicValue(pooling), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
     }
     /** Pool -> platform identity balance (spend). */
-    unshield(spends, outputAddress, unshieldAmount, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
-        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.unshield(spends.map(s => s._rawSpendableNote), preparePlatformAddressValue(outputAddress), unshieldAmount.toString(), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    async unshield(spends, outputAddress, unshieldAmount, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(await this._rawShieldedBuilder.unshield(spends.map(s => s._rawSpendableNote), preparePlatformAddressValue(outputAddress), unshieldAmount.toString(), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
     }
     /** Pool -> pool (spend). */
-    shieldedTransfer(spends, recipient, transferAmount, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
-        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.shieldedTransfer(spends.map(s => s._rawSpendableNote), recipient._rawOrchardAddress, transferAmount.toString(), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    async shieldedTransfer(spends, recipient, transferAmount, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(await this._rawShieldedBuilder.shieldedTransfer(spends.map(s => s._rawSpendableNote), recipient._rawOrchardAddress, transferAmount.toString(), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
     }
     /** Pool -> new identity (spend). One private key per public key, same order. */
-    identityCreateFromShieldedPool(publicKeys, privateKeys, denomination, sendToAddressOnCreationFailure, spends, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
-        return IdentityCreateFromShieldedPoolResultWASM.createFromRawInstance(this._rawShieldedBuilder.identityCreateFromShieldedPool(publicKeys.map(k => k._rawKeyInCreation), privateKeys.map(k => k._rawPrivateKey), denomination.toString(), preparePlatformAddressValue(sendToAddressOnCreationFailure), spends.map(s => s._rawSpendableNote), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    async identityCreateFromShieldedPool(publicKeys, privateKeys, denomination, sendToAddressOnCreationFailure, spends, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return IdentityCreateFromShieldedPoolResultWASM.createFromRawInstance(await this._rawShieldedBuilder.identityCreateFromShieldedPool(publicKeys.map(k => k._rawKeyInCreation), privateKeys.map(k => k._rawPrivateKey), denomination.toString(), preparePlatformAddressValue(sendToAddressOnCreationFailure), spends.map(s => s._rawSpendableNote), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pshenmic-dpp",
-  "version": "2.0.0-dev.23",
+  "version": "2.0.0-dev.25",
   "main": "dist/src/wasm.js",
   "types": "dist/src/wasm.d.ts",
   "react-native": "./dist/src/react-native.js",

package/tests/unit/Shielded.spec.ts

@@ -288,21 +288,23 @@ describe('SpendableNote', function () {
 })
 
 describe('OrchardProver', function () {
-  // Constructing the prover builds the Halo 2 proving key (~seconds).
-  test('should construct a prover', function () {
+  // Initializing the prover builds the Halo 2 proving key (~seconds).
+  test('should construct a prover', async function () {
     const prover = new OrchardProverWASM()
+    await prover.init()
 
     expect(prover).toBeInstanceOf(OrchardProverWASM)
   }, 30000)
 })
 
 describe('ShieldedBuilder', function () {
-  // The builder builds its own Halo 2 proving key on construction (~seconds),
+  // The builder builds its own Halo 2 proving key on init (~seconds),
   // so build it once and reuse it across the deposit test.
   let builder: ShieldedBuilderWASM
 
-  beforeAll(function () {
+  beforeAll(async function () {
     builder = new ShieldedBuilderWASM()
+    await builder.init()
   }, 30000)
 
   describe('constructor', function () {
@@ -312,7 +314,7 @@ describe('ShieldedBuilder', function () {
   })
 
   describe('shield (transparent -> pool deposit)', function () {
-    test('should build and prove a shield transition', function () {
+    test('should build and prove a shield transition', async function () {
       const recipient = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
       const senderOvk = orchardOvkFromSeed(SEED, COIN_TYPE, ACCOUNT)
 
@@ -321,7 +323,7 @@ describe('ShieldedBuilder', function () {
       // address, nonce, balance — balance must cover amount + fee.
       const input = new InputAddressWASM(inputAddress, 0, DASH / 2n)
 
-      const st = builder.shield(
+      const st = await builder.shield(
         recipient,
         (DASH * 4n) / 10n, // 0.4 DASH into the pool
         [input],

package/tests/unit/WebAssembly.spec.ts

@@ -1,5 +1,5 @@
 import * as dpp from "pshenmic-dpp/wasm";
-import {IdentifierWASM} from "pshenmic-dpp/wasm";
+import {IdentifierWASM, ShieldedBuilderWASM} from "pshenmic-dpp/wasm";
 
 let identifierBytes: Uint8Array;
 
@@ -46,4 +46,43 @@ describe("dpp", function () {
       expect(identifier.bytes()).toEqual(identifierBytes);
     });
   })
+
+  describe('shielded init', function () {
+    test('should allow to use old instances after shielded init', async function () {
+      const identifier = IdentifierWASM.fromBytes(identifierBytes);
+
+      const builder = new ShieldedBuilderWASM()
+
+      await builder.init();
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    })
+
+    test('should build a real Halo 2 proof with instances created before init', async function () {
+      const seed = new Uint8Array(64).fill(7);
+
+      // created BEFORE init — must stay usable by the proving call
+      const recipient = dpp.OrchardAddressWASM.fromSeed(seed, 1, 0);
+      const senderOvk = dpp.orchardOvkFromSeed(seed, 1, 0);
+      const privateKey = dpp.PrivateKeyWASM.fromWIF('cUy4wbim4y9NDwC24omx8oWY5WqfmjSU2gdcZtTXza2xDCAkQXRP');
+      const outPoint = new dpp.OutPointWASM('79af4b339ddfee8c9b6d08d74155373c6ef547cda5e65473a254b9b0f8533f0c', 0);
+      const assetLockProof = dpp.AssetLockProofWASM.createChainAssetLockProof(1499737, outPoint);
+      const memo = dpp.ShieldedMemoWASM.empty();
+
+      const builder = new ShieldedBuilderWASM();
+      await builder.init();
+
+      const st = await builder.shieldFromAssetLock(
+        recipient,
+        40_000_000_000n,
+        assetLockProof,
+        privateKey,
+        memo,
+        0,
+        senderOvk
+      );
+
+      expect(st.hex().length).toBeGreaterThan(0);
+    }, 120000)
+  })
 });