pshenmic-dpp 2.0.0-dev.2 → 2.0.0-dev.21

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

@@ -26,7 +26,7 @@ export class GroupStateTransitionInfoWASM {
         this._rawGroupStateTransitionInfo.actionIsProposer = actionIsProposer;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(GroupStateTransitionInfoWASM.prototype);
         instance._rawGroupStateTransitionInfo = rawInstance;
         return instance;
     }

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

@@ -40,7 +40,7 @@ export class IdentifierWASM {
         return this.createFromRawInstance(dppProvider.dpp.IdentifierNAPI.fromBytes(id));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentifierWASM.prototype);
         instance._rawIdentifier = rawInstance;
         return instance;
     }

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

@@ -63,7 +63,7 @@ export class IdentityWASM {
         return this._rawIdentity.base64();
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityWASM.prototype);
         instance._rawIdentity = rawInstance;
         return instance;
     }

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

@@ -29,6 +29,7 @@ export declare class IdentityPublicKeyWASM {
     set disabledAt(disabledAt: bigint | number);
     get contractBounds(): ContractBoundsWASM | undefined;
     set contractBounds(contractBounds: ContractBoundsWASM | undefined | null);
+    getContractBounds(): ContractBoundsWASM | undefined;
     removeDisabledAt(): void;
     getPublicKeyHash(): string;
     isMaster(): boolean;

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

@@ -84,6 +84,11 @@ export class IdentityPublicKeyWASM {
     set contractBounds(contractBounds) {
         this._rawIdentityPublicKey.contractBounds = contractBounds?._rawContractBounds;
     }
+    getContractBounds() {
+        if (this._rawIdentityPublicKey.contractBounds != null) {
+            return ContractBoundsWASM.createFromRawInstance(this._rawIdentityPublicKey.contractBounds);
+        }
+    }
     removeDisabledAt() {
         this._rawIdentityPublicKey.removeDisabledAt();
     }
@@ -119,7 +124,7 @@ export class IdentityPublicKeyWASM {
         return this.createFromRawInstance(rawInstance);
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityPublicKeyWASM.prototype);
         instance._rawIdentityPublicKey = rawInstance;
         return instance;
     }

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

@@ -10,6 +10,7 @@ export declare class IdentityPublicKeyInCreationWASM {
     toIdentityPublicKey(): IdentityPublicKeyWASM;
     validatePrivateKey(privateKey: string | Uint8Array | PrivateKeyWASM, network: NetworkLike): boolean;
     getHash(): Uint8Array;
+    getContractBounds(): ContractBoundsWASM | undefined;
     get contractBounds(): ContractBoundsWASM | undefined;
     set contractBounds(value: ContractBoundsWASM);
     get keyId(): number;

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

@@ -19,6 +19,11 @@ export class IdentityPublicKeyInCreationWASM {
     getHash() {
         return this._rawKeyInCreation.getHash();
     }
+    getContractBounds() {
+        if (this._rawKeyInCreation.contractBounds != null) {
+            return ContractBoundsWASM.createFromRawInstance(this._rawKeyInCreation.contractBounds);
+        }
+    }
     get contractBounds() {
         if (this._rawKeyInCreation.contractBounds != null) {
             return ContractBoundsWASM.createFromRawInstance(this._rawKeyInCreation.contractBounds);
@@ -70,7 +75,7 @@ export class IdentityPublicKeyInCreationWASM {
         this._rawKeyInCreation.signature = value;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityPublicKeyInCreationWASM.prototype);
         instance._rawKeyInCreation = rawInstance;
         return instance;
     }

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

@@ -62,7 +62,7 @@ export class IdentityCreateTransitionWASM {
         return IdentityCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreateTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityCreateTransitionWASM.prototype);
         instance._rawIdentityCreateTransition = rawInstance;
         return instance;
     }

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

@@ -78,7 +78,7 @@ export class IdentityCreditTransferWASM {
         return IdentityCreditTransferWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditTransferNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityCreditTransferWASM.prototype);
         instance._rawIdentityCreditTransfer = rawInstance;
         return instance;
     }

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

@@ -107,7 +107,7 @@ export class IdentityCreditWithdrawalTransitionWASM {
         return IdentityCreditWithdrawalTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditWithdrawalTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityCreditWithdrawalTransitionWASM.prototype);
         instance._rawIdentityCreditWithdrawalTransition = rawInstance;
         return instance;
     }

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

@@ -68,7 +68,7 @@ export class IdentityTopUpTransitionWASM {
         return IdentityTopUpTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityTopUpTransitionWASM.prototype);
         instance._rawIdentityTopUpTransition = rawInstance;
         return instance;
     }

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

@@ -101,7 +101,7 @@ export class IdentityUpdateTransitionWASM {
         return IdentityUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityUpdateTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityUpdateTransitionWASM.prototype);
         instance._rawIdentityUpdateTransition = rawInstance;
         return instance;
     }

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

@@ -36,7 +36,7 @@ export class InstantLockWASM {
         this._rawInstantLock.blsSignature = sig;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(InstantLockWASM.prototype);
         instance._rawInstantLock = rawInstance;
         return instance;
     }

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

@@ -20,8 +20,6 @@ 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;

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) {
@@ -89,7 +83,7 @@ export class MasternodeVoteTransitionWASM {
         return MasternodeVoteTransitionWASM.createFromRawInstance(dppProvider.dpp.MasternodeVoteTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(MasternodeVoteTransitionWASM.prototype);
         instance._rawMasternodeVoteTransition = rawInstance;
         return instance;
     }

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

@@ -20,7 +20,7 @@ export class VoteWASM {
         this._rawVote.resourceVoteChoice = resourceVoteChoice._rawResourceVoteChoice;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(VoteWASM.prototype);
         instance._rawVote = rawInstance;
         return instance;
     }

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

@@ -11,7 +11,7 @@ export declare class VotePollWASM {
     set documentTypeName(value: string);
     get indexName(): string;
     set indexName(value: string);
-    get indexValues(): any;
+    get indexValues(): string[];
     set indexValues(values: string[]);
     toString(): string;
     static createFromRawInstance(rawInstance: VotePollNAPI): VotePollWASM;

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

@@ -1,5 +1,5 @@
 import { dppProvider } from '../../provider.js';
-import { prepareIdentifierValue, valueFromDynamicValue, valueToDynamicValue } from '../../utils.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
 import { IdentifierWASM } from '../Identifier.js';
 export class VotePollWASM {
     /** @private **/
@@ -26,7 +26,7 @@ export class VotePollWASM {
         this._rawVotePollWASM.indexName = value;
     }
     get indexValues() {
-        return valueFromDynamicValue(new dppProvider.dpp.DynamicValue(this._rawVotePollWASM.indexValues));
+        return this._rawVotePollWASM.indexValues;
     }
     set indexValues(values) {
         this._rawVotePollWASM.indexValues = valueToDynamicValue(values);
@@ -35,7 +35,7 @@ export class VotePollWASM {
         return this._rawVotePollWASM.toString();
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(VotePollWASM.prototype);
         instance._rawVotePollWASM = rawInstance;
         return instance;
     }

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/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/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;
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { OrchardAddressNAPI } from '../../../../binaries/bindingsTypes.js';
+import { NetworkLike } from '../../types.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): 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,31 @@
+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) {
+        return OrchardAddressWASM.createFromRawInstance(dppProvider.dpp.OrchardAddressNAPI.fromSeed(seed, coinType, account, 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,12 @@
+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;
+    constructor();
+    static createFromRawInstance(rawInstance: OrchardProverNAPI): OrchardProverWASM;
+}

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

@@ -0,0 +1,18 @@
+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;
+    constructor() {
+        this._rawOrchardProver = new dppProvider.dpp.OrchardProverNAPI();
+    }
+    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,18 @@
+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;
+    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,29 @@
+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);
+    }
+    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,40 @@
+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 { 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;
+    constructor();
+    /** Asset lock -> pool (deposit). */
+    shieldFromAssetLock(recipient: OrchardAddressWASM, shieldAmount: bigint, assetLockProof: AssetLockProofWASM, privateKey: PrivateKeyWASM, memo: ShieldedMemoWASM, dummyOutputs: number, senderOvk?: Uint8Array, surplusOutput?: PlatformAddressLike, platformVersion?: PlatformVersionNAPI): 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;
+    /** 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;
+    /** 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;
+    /** 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;
+    /** 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;
+}