pshenmic-dpp 2.0.0-dev.8 → 2.0.0

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

@@ -0,0 +1,27 @@
+import type { OrchardAddressNAPI } from '../../../../binaries/bindingsTypes.js';
+import { NetworkLike, ScopeLike } from '../../types.js';
+import { FullViewingKeyWASM } from './FullViewingKey.js';
+import { IncomingViewingKeyWASM } from './IncomingViewingKey.js';
+export declare class OrchardAddressWASM {
+    /** @private **/
+    _rawOrchardAddress: OrchardAddressNAPI;
+    toBech32m(network: NetworkLike): string;
+    bytes(): Uint8Array;
+    static fromBech32m(bech32m: string): OrchardAddressWASM;
+    static fromBytes(bytes: Uint8Array): OrchardAddressWASM;
+    /** Derives the address from a BIP-39 seed via ZIP-32 (m/32'/coinType'/account'). */
+    static fromSeed(seed: Uint8Array, coinType: number, account: number, diversifierIndex?: number, scope?: ScopeLike): OrchardAddressWASM;
+    /**
+     * Derives the address at `diversifierIndex` (default 0) from a full viewing
+     * key, for `scope` (default External).
+     */
+    static fromFullViewingKey(fullViewingKey: FullViewingKeyWASM, diversifierIndex?: number, scope?: ScopeLike): OrchardAddressWASM;
+    /**
+     * Derives the address at `diversifierIndex` (default 0) from an incoming
+     * viewing key. The scope is fixed by the key itself.
+     */
+    static fromIncomingViewingKey(incomingViewingKey: IncomingViewingKeyWASM, diversifierIndex?: number): OrchardAddressWASM;
+    static createFromRawInstance(rawInstance: OrchardAddressNAPI): OrchardAddressWASM;
+}
+/** Derives the sender's Orchard outgoing viewing key (32 bytes) from a BIP-39 seed. */
+export declare function orchardOvkFromSeed(seed: Uint8Array, coinType: number, account: number): Uint8Array;

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

@@ -0,0 +1,45 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export class OrchardAddressWASM {
+    /** @private **/
+    _rawOrchardAddress;
+    toBech32m(network) {
+        return this._rawOrchardAddress.toBech32m(valueToDynamicValue(network));
+    }
+    bytes() {
+        return this._rawOrchardAddress.bytes();
+    }
+    static fromBech32m(bech32m) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromBech32m(bech32m));
+    }
+    static fromBytes(bytes) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromBytes(bytes));
+    }
+    /** Derives the address from a BIP-39 seed via ZIP-32 (m/32'/coinType'/account'). */
+    static fromSeed(seed, coinType, account, diversifierIndex, scope) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromSeed(seed, coinType, account, diversifierIndex, scope == null ? undefined : valueToDynamicValue(scope)));
+    }
+    /**
+     * Derives the address at `diversifierIndex` (default 0) from a full viewing
+     * key, for `scope` (default External).
+     */
+    static fromFullViewingKey(fullViewingKey, diversifierIndex, scope) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromFullViewingKey(fullViewingKey._rawFullViewingKey, diversifierIndex, scope == null ? undefined : valueToDynamicValue(scope)));
+    }
+    /**
+     * Derives the address at `diversifierIndex` (default 0) from an incoming
+     * viewing key. The scope is fixed by the key itself.
+     */
+    static fromIncomingViewingKey(incomingViewingKey, diversifierIndex) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromIncomingViewingKey(incomingViewingKey._rawIncomingViewingKey, diversifierIndex));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(OrchardAddressWASM.prototype);
+        instance._rawOrchardAddress = rawInstance;
+        return instance;
+    }
+}
+/** Derives the sender's Orchard outgoing viewing key (32 bytes) from a BIP-39 seed. */
+export function orchardOvkFromSeed(seed, coinType, account) {
+    return dppProvider.dpp.orchardOvkFromSeed(seed, coinType, account);
+}

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

@@ -0,0 +1,19 @@
+import type { OrchardProverNAPI } from '../../../../binaries/bindingsTypes.js';
+/**
+ * Reusable Orchard prover holding the Halo 2 proving key. Building it is
+ * expensive (~seconds); construct once and reuse. (The `ShieldedBuilderWASM`
+ * already builds its own prover internally — this is exposed for standalone use.)
+ */
+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

@@ -0,0 +1,34 @@
+import { dppProvider } from '../../provider.js';
+/**
+ * Reusable Orchard prover holding the Halo 2 proving key. Building it is
+ * expensive (~seconds); construct once and reuse. (The `ShieldedBuilderWASM`
+ * already builds its own prover internally — this is exposed for standalone use.)
+ */
+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() {
+        // 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);
+        instance._rawOrchardProver = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { RecoveredNoteNAPI } from '../../../../binaries/bindingsTypes.js';
+import { NoteWASM } from './Note.js';
+import { SerializedActionWASM } from '../ShieldedTransitions/SerializedAction.js';
+/** A note recovered from a shielded action by trial-decryption. */
+export declare class RecoveredNoteWASM {
+    /** @private **/
+    _rawRecoveredNote: RecoveredNoteNAPI;
+    /** The action's global leaf position in the commitment tree. */
+    get index(): number;
+    get note(): NoteWASM;
+    get nullifier(): Uint8Array;
+    static createFromRawInstance(rawInstance: RecoveredNoteNAPI): RecoveredNoteWASM;
+}
+/**
+ * Recovers your own notes from a set of shielded actions by trial-decrypting
+ * each with the viewing key derived from `seed` (ZIP-32 m/32'/coinType'/account').
+ * Only actions addressed to you are returned; `index` is the global leaf position.
+ */
+export declare function recoverNotes(actions: SerializedActionWASM[], seed: Uint8Array, coinType: number, account: number): RecoveredNoteWASM[];

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

@@ -0,0 +1,32 @@
+import { dppProvider } from '../../provider.js';
+import { NoteWASM } from './Note.js';
+/** A note recovered from a shielded action by trial-decryption. */
+export class RecoveredNoteWASM {
+    /** @private **/
+    _rawRecoveredNote;
+    /** The action's global leaf position in the commitment tree. */
+    get index() {
+        return this._rawRecoveredNote.index;
+    }
+    get note() {
+        return NoteWASM.createFromRawInstance(this._rawRecoveredNote.note);
+    }
+    get nullifier() {
+        return this._rawRecoveredNote.nullifier;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(RecoveredNoteWASM.prototype);
+        instance._rawRecoveredNote = rawInstance;
+        return instance;
+    }
+}
+/**
+ * Recovers your own notes from a set of shielded actions by trial-decrypting
+ * each with the viewing key derived from `seed` (ZIP-32 m/32'/coinType'/account').
+ * Only actions addressed to you are returned; `index` is the global leaf position.
+ */
+export function recoverNotes(actions, seed, coinType, account) {
+    return dppProvider.dpp
+        .recoverNotes(actions.map(a => a._rawSerializedAction), seed, coinType, account)
+        .map(RecoveredNoteWASM.createFromRawInstance);
+}

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

@@ -0,0 +1,64 @@
+import type { PlatformVersionNAPI, ShieldedBuilderNAPI } from '../../../../binaries/bindingsTypes.js';
+import { PlatformAddressLike, PoolingLike } from '../../types.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+import { ShieldedMemoWASM } from './ShieldedMemo.js';
+import { SpendableNoteWASM } from './SpendableNote.js';
+import { ShieldedWithdrawalResultWASM } from './ShieldedWithdrawalResult.js';
+import { ShieldedOutputWASM } from './ShieldedOutput.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { PrivateKeyWASM } from '../PrivateKey.js';
+import { CoreScriptWASM } from '../CoreScript.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+import { InputAddressWASM } from '../AddressTransitions/entities/InputAddress.js';
+import { AddressFundsFeeStrategyStepWASM } from '../AddressTransitions/entities/AddressFundsFeeStrategyStep.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { IdentityCreateFromShieldedPoolResultWASM } from './IdentityCreateFromShieldedPoolResult.js';
+/**
+ * Builds and proves shielded (Orchard) state transitions. Construction builds
+ * the Halo 2 proving key (~seconds), so create one instance and reuse it.
+ *
+ * Deposits (`shield`, `shieldFromAssetLock`) don't need pool notes. Spends
+ * (`shieldedWithdrawal`, `unshield`, `shieldedTransfer`) need a `SpendableNote`
+ * witnessed against an on-chain anchor — rebuild the tree from the full pool
+ * note set (getShieldedEncryptedNotes) with `CommitmentTreeWASM`.
+ */
+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): 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): 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): 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): 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): Promise<ShieldedWithdrawalResultWASM>;
+    /**
+     * Pool -> pool, paying several Orchard addresses in one proof.
+     *
+     * The spend side matches `shieldedTransfer` — every note must belong to the
+     * `seed`/`coinType`/`account` this call derives its spend authority from, and
+     * all must be witnessed against the same `anchor`. The output side is a list,
+     * each entry carrying its own amount and memo, and the leftover always goes
+     * to `changeAddress` (a zero-value change note is still written, which keeps
+     * the fee predictable before the change amount is known).
+     *
+     * Consensus prices the fee off the bundle's action count, which Orchard sets
+     * to `max(spends, outputs + 1, 2)` and caps at 16 — so a fan-out of 15
+     * recipients is the ceiling, and each extra action adds proving time. Passing
+     * more throws before proving rather than after.
+     */
+    shieldedTransferMulti(spends: SpendableNoteWASM[], outputs: ShieldedOutputWASM[], changeAddress: OrchardAddressWASM, seed: Uint8Array, coinType: number, account: number, anchor: Uint8Array, 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): Promise<IdentityCreateFromShieldedPoolResultWASM>;
+}

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

@@ -0,0 +1,79 @@
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
+import { ShieldedWithdrawalResultWASM } from './ShieldedWithdrawalResult.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+import { IdentityCreateFromShieldedPoolResultWASM } from './IdentityCreateFromShieldedPoolResult.js';
+/**
+ * Builds and proves shielded (Orchard) state transitions. Construction builds
+ * the Halo 2 proving key (~seconds), so create one instance and reuse it.
+ *
+ * Deposits (`shield`, `shieldFromAssetLock`) don't need pool notes. Spends
+ * (`shieldedWithdrawal`, `unshield`, `shieldedTransfer`) need a `SpendableNote`
+ * witnessed against an on-chain anchor — rebuild the tree from the full pool
+ * note set (getShieldedEncryptedNotes) with `CommitmentTreeWASM`.
+ */
+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() {
+        // 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). */
+    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. */
+    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). */
+    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). */
+    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). */
+    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 -> pool, paying several Orchard addresses in one proof.
+     *
+     * The spend side matches `shieldedTransfer` — every note must belong to the
+     * `seed`/`coinType`/`account` this call derives its spend authority from, and
+     * all must be witnessed against the same `anchor`. The output side is a list,
+     * each entry carrying its own amount and memo, and the leftover always goes
+     * to `changeAddress` (a zero-value change note is still written, which keeps
+     * the fee predictable before the change amount is known).
+     *
+     * Consensus prices the fee off the bundle's action count, which Orchard sets
+     * to `max(spends, outputs + 1, 2)` and caps at 16 — so a fan-out of 15
+     * recipients is the ceiling, and each extra action adds proving time. Passing
+     * more throws before proving rather than after.
+     */
+    async shieldedTransferMulti(spends, outputs, changeAddress, seed, coinType, account, anchor, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(await this._rawShieldedBuilder.shieldedTransferMulti(spends.map(s => s._rawSpendableNote), outputs.map(o => o._rawShieldedOutput), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, platformVersion));
+    }
+    /** Pool -> new identity (spend). One private key per public key, same order. */
+    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/dist/src/dpp/structs/Orchard/ShieldedMemo.d.ts

@@ -0,0 +1,11 @@
+import type { ShieldedMemoNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class ShieldedMemoWASM {
+    /** @private **/
+    _rawShieldedMemo: ShieldedMemoNAPI;
+    toString(): string;
+    toBytes(): Uint8Array;
+    static empty(): ShieldedMemoWASM;
+    static fromString(value: string): ShieldedMemoWASM;
+    static other(kind: number, payload: Uint8Array): ShieldedMemoWASM;
+    static createFromRawInstance(rawInstance: ShieldedMemoNAPI): ShieldedMemoWASM;
+}

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

@@ -0,0 +1,25 @@
+import { dppProvider } from '../../provider.js';
+export class ShieldedMemoWASM {
+    /** @private **/
+    _rawShieldedMemo;
+    toString() {
+        return this._rawShieldedMemo.toString();
+    }
+    toBytes() {
+        return this._rawShieldedMemo.toBytes();
+    }
+    static empty() {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.empty());
+    }
+    static fromString(value) {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.fromString(value));
+    }
+    static other(kind, payload) {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.other(kind, payload));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedMemoWASM.prototype);
+        instance._rawShieldedMemo = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { ShieldedOutputNAPI } from '../../../../binaries/bindingsTypes.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+import { ShieldedMemoWASM } from './ShieldedMemo.js';
+/**
+ * One output of a multi-output shielded transfer (`shieldedTransferMulti`):
+ * who receives the note, how much, and the memo carried inside it.
+ *
+ * Each output holds its own memo — the single-recipient builders share one memo
+ * across the bundle, which has nothing sensible to say when there are several
+ * unrelated recipients.
+ */
+export declare class ShieldedOutputWASM {
+    /** @private **/
+    _rawShieldedOutput: ShieldedOutputNAPI;
+    constructor(address: OrchardAddressWASM, amount: bigint, memo: ShieldedMemoWASM);
+    get address(): OrchardAddressWASM;
+    set address(value: OrchardAddressWASM);
+    get amount(): bigint;
+    set amount(value: bigint);
+    get memo(): ShieldedMemoWASM;
+    set memo(value: ShieldedMemoWASM);
+    static createFromRawInstance(rawInstance: ShieldedOutputNAPI): ShieldedOutputWASM;
+}

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

@@ -0,0 +1,41 @@
+import { dppProvider } from '../../provider.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+import { ShieldedMemoWASM } from './ShieldedMemo.js';
+/**
+ * One output of a multi-output shielded transfer (`shieldedTransferMulti`):
+ * who receives the note, how much, and the memo carried inside it.
+ *
+ * Each output holds its own memo — the single-recipient builders share one memo
+ * across the bundle, which has nothing sensible to say when there are several
+ * unrelated recipients.
+ */
+export class ShieldedOutputWASM {
+    /** @private **/
+    _rawShieldedOutput;
+    constructor(address, amount, memo) {
+        this._rawShieldedOutput = new dppProvider.dpp.ShieldedOutputNAPI(address._rawOrchardAddress, amount.toString(), memo._rawShieldedMemo);
+    }
+    get address() {
+        return OrchardAddressWASM.createFromRawInstance(this._rawShieldedOutput.address);
+    }
+    set address(value) {
+        this._rawShieldedOutput.address = value._rawOrchardAddress;
+    }
+    get amount() {
+        return BigInt(this._rawShieldedOutput.amount);
+    }
+    set amount(value) {
+        this._rawShieldedOutput.amount = value.toString();
+    }
+    get memo() {
+        return ShieldedMemoWASM.createFromRawInstance(this._rawShieldedOutput.memo);
+    }
+    set memo(value) {
+        this._rawShieldedOutput.memo = value._rawShieldedMemo;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedOutputWASM.prototype);
+        instance._rawShieldedOutput = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { ShieldedWithdrawalResultNAPI } from '../../../../binaries/bindingsTypes.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+/** Result of a proving shielded spend (withdrawal / unshield / transfer). */
+export declare class ShieldedWithdrawalResultWASM {
+    /** @private **/
+    _rawShieldedWithdrawalResult: ShieldedWithdrawalResultNAPI;
+    get stateTransition(): StateTransitionWASM;
+    /** The fixed shielded fee (credits) consensus charges for the spend. */
+    get fee(): bigint;
+    static createFromRawInstance(rawInstance: ShieldedWithdrawalResultNAPI): ShieldedWithdrawalResultWASM;
+}

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

@@ -0,0 +1,18 @@
+import { StateTransitionWASM } from '../StateTransition.js';
+/** Result of a proving shielded spend (withdrawal / unshield / transfer). */
+export class ShieldedWithdrawalResultWASM {
+    /** @private **/
+    _rawShieldedWithdrawalResult;
+    get stateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedWithdrawalResult.stateTransition);
+    }
+    /** The fixed shielded fee (credits) consensus charges for the spend. */
+    get fee() {
+        return BigInt(this._rawShieldedWithdrawalResult.fee);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedWithdrawalResultWASM.prototype);
+        instance._rawShieldedWithdrawalResult = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { SpendableNoteNAPI } from '../../../../binaries/bindingsTypes.js';
+import { NoteWASM } from './Note.js';
+import { MerklePathWASM } from './MerklePath.js';
+export declare class SpendableNoteWASM {
+    /** @private **/
+    _rawSpendableNote: SpendableNoteNAPI;
+    constructor(note: NoteWASM, merklePath: MerklePathWASM);
+    get note(): NoteWASM;
+    set note(value: NoteWASM);
+    get merklePath(): MerklePathWASM;
+    set merklePath(value: MerklePathWASM);
+    static createFromRawInstance(rawInstance: SpendableNoteNAPI): SpendableNoteWASM;
+}

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

@@ -0,0 +1,27 @@
+import { dppProvider } from '../../provider.js';
+import { NoteWASM } from './Note.js';
+import { MerklePathWASM } from './MerklePath.js';
+export class SpendableNoteWASM {
+    /** @private **/
+    _rawSpendableNote;
+    constructor(note, merklePath) {
+        this._rawSpendableNote = new dppProvider.dpp.SpendableNoteNAPI(note._rawNote, merklePath._rawMerklePath);
+    }
+    get note() {
+        return NoteWASM.createFromRawInstance(this._rawSpendableNote.note);
+    }
+    set note(value) {
+        this._rawSpendableNote.note = value._rawNote;
+    }
+    get merklePath() {
+        return MerklePathWASM.createFromRawInstance(this._rawSpendableNote.merklePath);
+    }
+    set merklePath(value) {
+        this._rawSpendableNote.merklePath = value._rawMerklePath;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(SpendableNoteWASM.prototype);
+        instance._rawSpendableNote = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/PlatformAddress/PlatformAddress.d.ts

@@ -1,4 +1,4 @@
-import type { PlatformAddressNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { PlatformAddressNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { NetworkLike, PlatformAddressLike } from '../../types.js';
 export declare class PlatformAddressWASM {
     /** @private **/
@@ -10,6 +10,14 @@ export declare class PlatformAddressWASM {
     isP2PKH(): boolean;
     isP2SH(): boolean;
     hash(): Uint8Array;
+    /**
+     * Storage fee charged for creating balance entries for addresses that are not in state yet.
+     *
+     * A minimum fee prices every output as a fresh address, but the fee actually charged is
+     * metered: paying an address that already exists adds no bytes, while each address created
+     * costs this much storage on top of processing.
+     */
+    static estimateStorageFeeForNewAddresses(addressCount: number, platformVersion?: PlatformVersionNAPI): bigint;
     static fromBech32m(bech32m: string): PlatformAddressWASM;
     static fromBytes(bytes: Uint8Array): PlatformAddressWASM;
     static createFromRawInstance(rawInstance: PlatformAddressNAPI): PlatformAddressWASM;

package/dist/src/dpp/structs/PlatformAddress/PlatformAddress.js

@@ -24,6 +24,16 @@ export class PlatformAddressWASM {
     hash() {
         return this._rawPlatformAddress.hash();
     }
+    /**
+     * Storage fee charged for creating balance entries for addresses that are not in state yet.
+     *
+     * A minimum fee prices every output as a fresh address, but the fee actually charged is
+     * metered: paying an address that already exists adds no bytes, while each address created
+     * costs this much storage on top of processing.
+     */
+    static estimateStorageFeeForNewAddresses(addressCount, platformVersion) {
+        return BigInt(dppProvider.dpp.PlatformAddressNAPI.estimateStorageFeeForNewAddresses(addressCount, platformVersion));
+    }
     static fromBech32m(bech32m) {
         return PlatformAddressWASM.createFromRawInstance(dppProvider.dpp.PlatformAddressNAPI.fromBech32m(bech32m));
     }

package/dist/src/dpp/structs/ShieldedTransitions/IdentityCreateFromShieldedPoolTransition.d.ts

@@ -0,0 +1,32 @@
+import type { PlatformVersionNAPI, IdentityCreateFromShieldedPoolTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { IdentifierLike, PlatformAddressLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class IdentityCreateFromShieldedPoolTransitionWASM {
+    /** @private **/
+    _rawIdentityCreateFromShieldedPoolTransition: IdentityCreateFromShieldedPoolTransitionNAPI;
+    constructor(publicKeys: IdentityPublicKeyInCreationWASM[], denomination: bigint, actions: SerializedActionWASM[], anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array, sendToAddressOnCreationFailure: PlatformAddressLike, identityId: IdentifierLike);
+    get publicKeys(): IdentityPublicKeyInCreationWASM[];
+    set publicKeys(value: IdentityPublicKeyInCreationWASM[]);
+    get denomination(): bigint;
+    set denomination(value: bigint);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    get sendToAddressOnCreationFailure(): PlatformAddressWASM;
+    set sendToAddressOnCreationFailure(value: PlatformAddressLike);
+    get identityId(): IdentifierWASM;
+    set identityId(value: IdentifierLike);
+    static computeMinimumFee(numActions: number, numKeys: number, platformVersion?: PlatformVersionNAPI): bigint;
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): IdentityCreateFromShieldedPoolTransitionWASM;
+    static createFromRawInstance(rawInstance: IdentityCreateFromShieldedPoolTransitionNAPI): IdentityCreateFromShieldedPoolTransitionWASM;
+}