pshenmic-dpp 2.0.0-dev.9 → 2.0.0

package/dist/src/dpp/structs/AddressTransitions/IdentityTopUpFromAddressesTransition.js

@@ -44,6 +44,9 @@ export class IdentityTopUpFromAddressesTransitionWASM {
     set inputWitness(addressWitness) {
         this._rawIdentityTopUpFromAddressesTransition.inputWitness = addressWitness.map(w => w._rawWitness);
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawIdentityTopUpFromAddressesTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawIdentityTopUpFromAddressesTransition.bytes();
     }

package/dist/src/dpp/structs/Batch/BatchTransition.d.ts

@@ -1,4 +1,4 @@
-import type { BatchTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { BatchTransitionNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { IdentifierLike } from '../../types.js';
 import { BatchedTransitionWASM } from './BatchedTransition.js';
 import { DocumentTransitionWASM } from './DocumentTransition.js';
@@ -20,6 +20,7 @@ export declare class BatchTransitionWASM {
     get modifiedDataIds(): IdentifierWASM[];
     get allConflictingIndexCollateralVotingFunds(): bigint | undefined;
     setIdentityContractNonce(nonce: bigint): void;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/Batch/BatchTransition.js

@@ -57,6 +57,9 @@ export class BatchTransitionWASM {
     setIdentityContractNonce(nonce) {
         this._rawBatchTransition.setIdentityContractNonce(nonce.toString());
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawBatchTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawBatchTransition.bytes();
     }

package/dist/src/dpp/structs/DataContractTransitions/DataContractCreateTransition.d.ts

@@ -1,4 +1,4 @@
-import type { DataContractCreateTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { DataContractCreateTransitionNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { DataContractWASM } from '../DataContract.js';
 import { PlatformVersionLike } from '../../types.js';
 import { StateTransitionWASM } from '../StateTransition.js';
@@ -11,6 +11,7 @@ export declare class DataContractCreateTransitionWASM {
     verifyProtocolVersion(protocolVersion: number): boolean;
     setDataContract(dataContract: DataContractWASM, platformVersion?: PlatformVersionLike): void;
     getDataContract(platformVersion?: PlatformVersionLike, fullValidation?: boolean): DataContractWASM;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/DataContractTransitions/DataContractCreateTransition.js

@@ -23,6 +23,9 @@ export class DataContractCreateTransitionWASM {
     getDataContract(platformVersion, fullValidation) {
         return DataContractWASM.createFromRawInstance(this._rawDataContractCreateTransition.getDataContract(valueToDynamicValue(platformVersion), fullValidation));
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawDataContractCreateTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawDataContractCreateTransition.bytes();
     }

package/dist/src/dpp/structs/DataContractTransitions/DataContractUpdateTransition.d.ts

@@ -1,4 +1,4 @@
-import type { DataContractUpdateTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { DataContractUpdateTransitionNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { DataContractWASM } from '../DataContract.js';
 import { PlatformVersionLike } from '../../types.js';
 import { StateTransitionWASM } from '../StateTransition.js';
@@ -11,6 +11,7 @@ export declare class DataContractUpdateTransitionWASM {
     verifyProtocolVersion(protocolVersion: number): boolean;
     setDataContract(dataContract: DataContractWASM, platformVersion?: PlatformVersionLike): void;
     getDataContract(fullValidation?: boolean, platformVersion?: PlatformVersionLike): DataContractWASM;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/DataContractTransitions/DataContractUpdateTransition.js

@@ -23,6 +23,9 @@ export class DataContractUpdateTransitionWASM {
     getDataContract(fullValidation, platformVersion) {
         return DataContractWASM.createFromRawInstance(this._rawDataContractUpdateTransition.getDataContract(fullValidation, valueToDynamicValue(platformVersion)));
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawDataContractUpdateTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawDataContractUpdateTransition.bytes();
     }

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

@@ -11,6 +11,9 @@ export class IdentifierWASM {
             const id = new dpp.DynamicValue(rawId);
             this._rawIdentifier = new dpp.IdentifierNAPI(id);
         }
+        else if (rawId instanceof dpp.IdentifierNAPI) {
+            this._rawIdentifier = rawId;
+        }
         else {
             throw new Error('Invalid raw ID');
         }

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreateTransition.d.ts

@@ -1,4 +1,4 @@
-import type { IdentityCreateTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { IdentityCreateTransitionNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
 import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
 import { PlatformVersionLike } from '../../types.js';
@@ -18,6 +18,7 @@ export declare class IdentityCreateTransitionWASM {
     set assetLock(value: AssetLockProofWASM);
     getSignableBytes(): Uint8Array;
     getIdentifier(): IdentifierWASM;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     toStateTransition(): StateTransitionWASM;
     static default(platformVersion: PlatformVersionLike): IdentityCreateTransitionWASM;

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreateTransition.js

@@ -40,6 +40,9 @@ export class IdentityCreateTransitionWASM {
     getIdentifier() {
         return IdentifierWASM.createFromRawInstance(this._rawIdentityCreateTransition.getIdentifier());
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawIdentityCreateTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawIdentityCreateTransition.bytes();
     }

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreditTransfer.d.ts

@@ -1,4 +1,4 @@
-import type { IdentityCreditTransferNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { IdentityCreditTransferNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { IdentifierLike } from '../../types.js';
 import { IdentifierWASM } from '../Identifier.js';
 import { StateTransitionWASM } from '../StateTransition.js';
@@ -21,6 +21,7 @@ export declare class IdentityCreditTransferWASM {
     get userFeeIncrease(): number;
     set userFeeIncrease(value: number);
     getSignableBytes(): Uint8Array;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreditTransfer.js

@@ -53,6 +53,9 @@ export class IdentityCreditTransferWASM {
     getSignableBytes() {
         return this._rawIdentityCreditTransfer.getSignableBytes();
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawIdentityCreditTransfer.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawIdentityCreditTransfer.bytes();
     }

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreditWithdrawalTransition.d.ts

@@ -1,4 +1,4 @@
-import type { IdentityCreditWithdrawalTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { IdentityCreditWithdrawalTransitionNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { IdentifierLike, PoolingLike } from '../../types.js';
 import { CoreScriptWASM } from '../CoreScript.js';
 import { IdentifierWASM } from '../Identifier.js';
@@ -30,6 +30,7 @@ export declare class IdentityCreditWithdrawalTransitionWASM {
     getPurposeRequirement(): string[];
     getModifiedDataIds(): IdentifierWASM[];
     getOptionalAssetLockProof(): AssetLockProofWASM | undefined;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreditWithdrawalTransition.js

@@ -82,6 +82,9 @@ export class IdentityCreditWithdrawalTransitionWASM {
             return AssetLockProofWASM.createFromRawInstance(lock);
         }
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawIdentityCreditWithdrawalTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawIdentityCreditWithdrawalTransition.bytes();
     }

package/dist/src/dpp/structs/IdentityTransitions/IdentityTopUpTransition.d.ts

@@ -1,4 +1,4 @@
-import type { IdentityTopUpTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { IdentityTopUpTransitionNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
 import { IdentifierLike } from '../../types.js';
 import { IdentifierWASM } from '../Identifier.js';
@@ -18,6 +18,7 @@ export declare class IdentityTopUpTransitionWASM {
     getSignableBytes(): Uint8Array;
     getModifiedDataIds(): IdentifierWASM[];
     getOptionalAssetLockProof(): AssetLockProofWASM | undefined;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/IdentityTransitions/IdentityTopUpTransition.js

@@ -43,6 +43,9 @@ export class IdentityTopUpTransitionWASM {
         const lock = this._rawIdentityTopUpTransition.getOptionalAssetLockProof();
         return (lock != null) ? AssetLockProofWASM.createFromRawInstance(lock) : undefined;
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawIdentityTopUpTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawIdentityTopUpTransition.bytes();
     }

package/dist/src/dpp/structs/IdentityTransitions/IdentityUpdateTransition.d.ts

@@ -1,4 +1,4 @@
-import type { IdentityUpdateTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { IdentityUpdateTransitionNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { IdentifierLike } from '../../types.js';
 import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
 import { IdentifierWASM } from '../Identifier.js';
@@ -28,6 +28,7 @@ export declare class IdentityUpdateTransitionWASM {
     getPurposeRequirement(): string[];
     getModifiedDataIds(): IdentifierWASM[];
     getOptionalAssetLockProof(): AssetLockProofWASM | undefined;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/IdentityTransitions/IdentityUpdateTransition.js

@@ -76,6 +76,9 @@ export class IdentityUpdateTransitionWASM {
             return undefined;
         }
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawIdentityUpdateTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawIdentityUpdateTransition.bytes();
     }

package/dist/src/dpp/structs/MasternodeVote/MasternodeVoteTransition.d.ts

@@ -1,4 +1,4 @@
-import type { MasternodeVoteTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { MasternodeVoteTransitionNAPI, PlatformVersionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { IdentifierLike } from '../../types.js';
 import { VoteWASM } from './Vote.js';
 import { IdentifierWASM } from '../Identifier.js';
@@ -20,11 +20,10 @@ export declare class MasternodeVoteTransitionWASM {
     set signaturePublicKeyId(keyId: number);
     get signature(): Uint8Array;
     set signature(value: Uint8Array);
-    get userFeeIncrease(): number;
-    set userFeeIncrease(value: number);
     get assetLock(): AssetLockProofWASM | undefined;
     get modifiedDataIds(): IdentifierWASM[];
     getSignableBytes(): Uint8Array;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/MasternodeVote/MasternodeVoteTransition.js

@@ -46,12 +46,6 @@ export class MasternodeVoteTransitionWASM {
     set signature(value) {
         this._rawMasternodeVoteTransition.signature = value;
     }
-    get userFeeIncrease() {
-        return this._rawMasternodeVoteTransition.userFeeIncrease;
-    }
-    set userFeeIncrease(value) {
-        this._rawMasternodeVoteTransition.userFeeIncrease = value;
-    }
     get assetLock() {
         const lock = this._rawMasternodeVoteTransition.assetLock;
         if (lock != null) {
@@ -64,6 +58,9 @@ export class MasternodeVoteTransitionWASM {
     getSignableBytes() {
         return this._rawMasternodeVoteTransition.getSignableBytes();
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawMasternodeVoteTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawMasternodeVoteTransition.bytes();
     }

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

@@ -0,0 +1,14 @@
+import type { CommitmentTreeNAPI } from '../../../../binaries/bindingsTypes.js';
+import { MerklePathWASM } from './MerklePath.js';
+export declare class CommitmentTreeWASM {
+    /** @private **/
+    _rawCommitmentTree: CommitmentTreeNAPI;
+    constructor(maxCheckpoints?: number);
+    /** Appends a note commitment (cmx). `marked` = spendable (can be witnessed). */
+    append(cmx: Uint8Array, marked: boolean): void;
+    checkpoint(checkpointId: number): boolean;
+    maxLeafPosition(): number | null;
+    witness(position: number, checkpointDepth?: number): MerklePathWASM | null;
+    anchor(): Uint8Array;
+    static createFromRawInstance(rawInstance: CommitmentTreeNAPI): CommitmentTreeWASM;
+}

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

@@ -0,0 +1,31 @@
+import { dppProvider } from '../../provider.js';
+import { MerklePathWASM } from './MerklePath.js';
+export class CommitmentTreeWASM {
+    /** @private **/
+    _rawCommitmentTree;
+    constructor(maxCheckpoints) {
+        this._rawCommitmentTree = new dppProvider.dpp.CommitmentTreeNAPI(maxCheckpoints);
+    }
+    /** Appends a note commitment (cmx). `marked` = spendable (can be witnessed). */
+    append(cmx, marked) {
+        this._rawCommitmentTree.append(cmx, marked);
+    }
+    checkpoint(checkpointId) {
+        return this._rawCommitmentTree.checkpoint(checkpointId);
+    }
+    maxLeafPosition() {
+        return this._rawCommitmentTree.maxLeafPosition();
+    }
+    witness(position, checkpointDepth) {
+        const path = this._rawCommitmentTree.witness(position, checkpointDepth);
+        return path != null ? MerklePathWASM.createFromRawInstance(path) : null;
+    }
+    anchor() {
+        return this._rawCommitmentTree.anchor();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(CommitmentTreeWASM.prototype);
+        instance._rawCommitmentTree = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { FullViewingKeyNAPI } from '../../../../binaries/bindingsTypes.js';
+import { ScopeLike } from '../../types.js';
+import { IncomingViewingKeyWASM } from './IncomingViewingKey.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+/**
+ * An Orchard full viewing key: it detects both incoming and outgoing notes and
+ * computes their nullifiers (so it sees the full balance), but cannot spend.
+ */
+export declare class FullViewingKeyWASM {
+    /** @private **/
+    _rawFullViewingKey: FullViewingKeyNAPI;
+    /** The 96-byte raw encoding of this key (ak || nk || rivk). */
+    bytes(): Uint8Array;
+    /** Derives the incoming viewing key for the given scope (default External). */
+    toIvk(scope?: ScopeLike): IncomingViewingKeyWASM;
+    /** Derives the 32-byte outgoing viewing key for the given scope (default External). */
+    toOvk(scope?: ScopeLike): Uint8Array;
+    /** The payment address at `diversifierIndex` (default 0) for `scope` (default External). */
+    address(diversifierIndex?: number, scope?: ScopeLike): OrchardAddressWASM;
+    /** The scope `address` was derived under, or null if it does not belong to this key. */
+    scopeForAddress(address: OrchardAddressWASM): string | null;
+    /** Derives the full viewing key from a BIP-39 seed via ZIP-32 (m/32'/coinType'/account'). */
+    static fromSeed(seed: Uint8Array, coinType: number, account: number): FullViewingKeyWASM;
+    /** Parses a full viewing key from its 96-byte raw encoding. */
+    static fromBytes(bytes: Uint8Array): FullViewingKeyWASM;
+    static createFromRawInstance(rawInstance: FullViewingKeyNAPI): FullViewingKeyWASM;
+}

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

@@ -0,0 +1,45 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { IncomingViewingKeyWASM } from './IncomingViewingKey.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+/**
+ * An Orchard full viewing key: it detects both incoming and outgoing notes and
+ * computes their nullifiers (so it sees the full balance), but cannot spend.
+ */
+export class FullViewingKeyWASM {
+    /** @private **/
+    _rawFullViewingKey;
+    /** The 96-byte raw encoding of this key (ak || nk || rivk). */
+    bytes() {
+        return this._rawFullViewingKey.bytes();
+    }
+    /** Derives the incoming viewing key for the given scope (default External). */
+    toIvk(scope) {
+        return IncomingViewingKeyWASM.createFromRawInstance(this._rawFullViewingKey.toIvk(scope == null ? undefined : valueToDynamicValue(scope)));
+    }
+    /** Derives the 32-byte outgoing viewing key for the given scope (default External). */
+    toOvk(scope) {
+        return this._rawFullViewingKey.toOvk(scope == null ? undefined : valueToDynamicValue(scope));
+    }
+    /** The payment address at `diversifierIndex` (default 0) for `scope` (default External). */
+    address(diversifierIndex, scope) {
+        return OrchardAddressWASM.createFromRawInstance(this._rawFullViewingKey.address(diversifierIndex, scope == null ? undefined : valueToDynamicValue(scope)));
+    }
+    /** The scope `address` was derived under, or null if it does not belong to this key. */
+    scopeForAddress(address) {
+        return this._rawFullViewingKey.scopeForAddress(address._rawOrchardAddress);
+    }
+    /** Derives the full viewing key from a BIP-39 seed via ZIP-32 (m/32'/coinType'/account'). */
+    static fromSeed(seed, coinType, account) {
+        return FullViewingKeyWASM.createFromRawInstance(dppProvider.dpp.FullViewingKeyNAPI.fromSeed(seed, coinType, account));
+    }
+    /** Parses a full viewing key from its 96-byte raw encoding. */
+    static fromBytes(bytes) {
+        return FullViewingKeyWASM.createFromRawInstance(dppProvider.dpp.FullViewingKeyNAPI.fromBytes(bytes));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(FullViewingKeyWASM.prototype);
+        instance._rawFullViewingKey = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { IdentityCreateFromShieldedPoolResultNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { SerializedActionWASM } from '../ShieldedTransitions/SerializedAction.js';
+/**
+ * Result of `identityCreateFromShieldedPool`: the new identity's keys (with
+ * proof-of-possession signatures), the proven Orchard bundle fields, the derived
+ * identity id, and the client-predicted fee.
+ */
+export declare class IdentityCreateFromShieldedPoolResultWASM {
+    /** @private **/
+    _rawIdentityCreateFromShieldedPoolResult: IdentityCreateFromShieldedPoolResultNAPI;
+    get publicKeys(): IdentityPublicKeyInCreationWASM[];
+    get identityId(): IdentifierWASM;
+    get predictedFee(): bigint;
+    get actions(): SerializedActionWASM[];
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+    static createFromRawInstance(rawInstance: IdentityCreateFromShieldedPoolResultNAPI): IdentityCreateFromShieldedPoolResultWASM;
+}

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

@@ -0,0 +1,38 @@
+import { IdentifierWASM } from '../Identifier.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { SerializedActionWASM } from '../ShieldedTransitions/SerializedAction.js';
+/**
+ * Result of `identityCreateFromShieldedPool`: the new identity's keys (with
+ * proof-of-possession signatures), the proven Orchard bundle fields, the derived
+ * identity id, and the client-predicted fee.
+ */
+export class IdentityCreateFromShieldedPoolResultWASM {
+    /** @private **/
+    _rawIdentityCreateFromShieldedPoolResult;
+    get publicKeys() {
+        return this._rawIdentityCreateFromShieldedPoolResult.publicKeys.map(IdentityPublicKeyInCreationWASM.createFromRawInstance);
+    }
+    get identityId() {
+        return new IdentifierWASM(this._rawIdentityCreateFromShieldedPoolResult.identityId);
+    }
+    get predictedFee() {
+        return BigInt(this._rawIdentityCreateFromShieldedPoolResult.predictedFee);
+    }
+    get actions() {
+        return this._rawIdentityCreateFromShieldedPoolResult.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    get anchor() {
+        return this._rawIdentityCreateFromShieldedPoolResult.anchor;
+    }
+    get proof() {
+        return this._rawIdentityCreateFromShieldedPoolResult.proof;
+    }
+    get bindingsSignature() {
+        return this._rawIdentityCreateFromShieldedPoolResult.bindingsSignature;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityCreateFromShieldedPoolResultWASM.prototype);
+        instance._rawIdentityCreateFromShieldedPoolResult = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,29 @@
+import type { IncomingViewingKeyNAPI } from '../../../../binaries/bindingsTypes.js';
+import { ScopeLike } from '../../types.js';
+import { FullViewingKeyWASM } from './FullViewingKey.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+/**
+ * An Orchard incoming viewing key: it detects and decrypts notes sent to you,
+ * but cannot see outgoing notes, tell when a note is spent, or spend it — safe
+ * to hand to a watch-only service.
+ */
+export declare class IncomingViewingKeyWASM {
+    /** @private **/
+    _rawIncomingViewingKey: IncomingViewingKeyNAPI;
+    /** The 64-byte raw encoding of this key (dk || ivk). */
+    bytes(): Uint8Array;
+    /** The payment address at `diversifierIndex` (default 0); scope is fixed by the key. */
+    address(diversifierIndex?: number): OrchardAddressWASM;
+    /** The diversifier index `address` was derived at, or null if it is not from this key. */
+    diversifierIndex(address: OrchardAddressWASM): number | null;
+    /**
+     * Derives the incoming viewing key from a BIP-39 seed via ZIP-32
+     * (m/32'/coinType'/account') for the given scope (default External).
+     */
+    static fromSeed(seed: Uint8Array, coinType: number, account: number, scope?: ScopeLike): IncomingViewingKeyWASM;
+    /** Derives the incoming viewing key from a full viewing key (default External scope). */
+    static fromFullViewingKey(fullViewingKey: FullViewingKeyWASM, scope?: ScopeLike): IncomingViewingKeyWASM;
+    /** Parses an incoming viewing key from its 64-byte raw encoding. */
+    static fromBytes(bytes: Uint8Array): IncomingViewingKeyWASM;
+    static createFromRawInstance(rawInstance: IncomingViewingKeyNAPI): IncomingViewingKeyWASM;
+}

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

@@ -0,0 +1,44 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+/**
+ * An Orchard incoming viewing key: it detects and decrypts notes sent to you,
+ * but cannot see outgoing notes, tell when a note is spent, or spend it — safe
+ * to hand to a watch-only service.
+ */
+export class IncomingViewingKeyWASM {
+    /** @private **/
+    _rawIncomingViewingKey;
+    /** The 64-byte raw encoding of this key (dk || ivk). */
+    bytes() {
+        return this._rawIncomingViewingKey.bytes();
+    }
+    /** The payment address at `diversifierIndex` (default 0); scope is fixed by the key. */
+    address(diversifierIndex) {
+        return OrchardAddressWASM.createFromRawInstance(this._rawIncomingViewingKey.address(diversifierIndex));
+    }
+    /** The diversifier index `address` was derived at, or null if it is not from this key. */
+    diversifierIndex(address) {
+        return this._rawIncomingViewingKey.diversifierIndex(address._rawOrchardAddress);
+    }
+    /**
+     * Derives the incoming viewing key from a BIP-39 seed via ZIP-32
+     * (m/32'/coinType'/account') for the given scope (default External).
+     */
+    static fromSeed(seed, coinType, account, scope) {
+        return IncomingViewingKeyWASM.createFromRawInstance(dppProvider.dpp.IncomingViewingKeyNAPI.fromSeed(seed, coinType, account, scope == null ? undefined : valueToDynamicValue(scope)));
+    }
+    /** Derives the incoming viewing key from a full viewing key (default External scope). */
+    static fromFullViewingKey(fullViewingKey, scope) {
+        return IncomingViewingKeyWASM.createFromRawInstance(dppProvider.dpp.IncomingViewingKeyNAPI.fromFullViewingKey(fullViewingKey._rawFullViewingKey, scope == null ? undefined : valueToDynamicValue(scope)));
+    }
+    /** Parses an incoming viewing key from its 64-byte raw encoding. */
+    static fromBytes(bytes) {
+        return IncomingViewingKeyWASM.createFromRawInstance(dppProvider.dpp.IncomingViewingKeyNAPI.fromBytes(bytes));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IncomingViewingKeyWASM.prototype);
+        instance._rawIncomingViewingKey = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { MerklePathNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class MerklePathWASM {
+    /** @private **/
+    _rawMerklePath: MerklePathNAPI;
+    constructor(position: number, authPath: Uint8Array[]);
+    get position(): number;
+    set position(value: number);
+    get authPath(): Uint8Array[];
+    set authPath(value: Uint8Array[]);
+    static createFromRawInstance(rawInstance: MerklePathNAPI): MerklePathWASM;
+}

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

@@ -0,0 +1,25 @@
+import { dppProvider } from '../../provider.js';
+export class MerklePathWASM {
+    /** @private **/
+    _rawMerklePath;
+    constructor(position, authPath) {
+        this._rawMerklePath = new dppProvider.dpp.MerklePathNAPI(position, authPath);
+    }
+    get position() {
+        return this._rawMerklePath.position;
+    }
+    set position(value) {
+        this._rawMerklePath.position = value;
+    }
+    get authPath() {
+        return this._rawMerklePath.authPath;
+    }
+    set authPath(value) {
+        this._rawMerklePath.authPath = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(MerklePathWASM.prototype);
+        instance._rawMerklePath = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { NoteNAPI } from '../../../../binaries/bindingsTypes.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+export declare class NoteWASM {
+    /** @private **/
+    _rawNote: NoteNAPI;
+    constructor(address: OrchardAddressWASM, value: bigint, rho: Uint8Array, rseed: Uint8Array);
+    get address(): OrchardAddressWASM;
+    set address(value: OrchardAddressWASM);
+    get value(): bigint;
+    set value(value: bigint);
+    get rho(): Uint8Array;
+    set rho(value: Uint8Array);
+    get rseed(): Uint8Array;
+    set rseed(value: Uint8Array);
+    /** The note commitment (cmx, 32 bytes) — its leaf in the commitment tree. */
+    get cmx(): Uint8Array;
+    static createFromRawInstance(rawInstance: NoteNAPI): NoteWASM;
+}

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

@@ -0,0 +1,42 @@
+import { dppProvider } from '../../provider.js';
+import { OrchardAddressWASM } from './OrchardAddress.js';
+export class NoteWASM {
+    /** @private **/
+    _rawNote;
+    constructor(address, value, rho, rseed) {
+        this._rawNote = new dppProvider.dpp.NoteNAPI(address._rawOrchardAddress, value.toString(), rho, rseed);
+    }
+    get address() {
+        return OrchardAddressWASM.createFromRawInstance(this._rawNote.address);
+    }
+    set address(value) {
+        this._rawNote.address = value._rawOrchardAddress;
+    }
+    get value() {
+        return BigInt(this._rawNote.value);
+    }
+    set value(value) {
+        this._rawNote.value = value.toString();
+    }
+    get rho() {
+        return this._rawNote.rho;
+    }
+    set rho(value) {
+        this._rawNote.rho = value;
+    }
+    get rseed() {
+        return this._rawNote.rseed;
+    }
+    set rseed(value) {
+        this._rawNote.rseed = value;
+    }
+    /** The note commitment (cmx, 32 bytes) — its leaf in the commitment tree. */
+    get cmx() {
+        return this._rawNote.cmx;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(NoteWASM.prototype);
+        instance._rawNote = rawInstance;
+        return instance;
+    }
+}