pshenmic-dpp 2.0.0-dev.9 → 2.0.0

package/dist/binaries/bindingsTypes.d.ts

@@ -13,6 +13,16 @@ export declare class ActionTakerNAPI {
     get value(): IdentifierNAPI | Array<IdentifierNAPI>;
     set value(value: IdentifierLikeNAPI | Array<IdentifierLikeNAPI>);
 }
+/** How one address's balance changed in a block. */
+export declare class AddressBalanceChangeNAPI {
+    get address(): PlatformAddressNAPI;
+    /**
+     * Either "setCredits", where `credits` is the new balance, or
+     * "addToCredits", where `credits` is the amount added to it.
+     */
+    get operation(): string;
+    get credits(): BigIntString;
+}
 export declare class AddressCreditWithdrawalTransitionNAPI {
     constructor(jsInputs: Array<InputAddressNAPI>, jsFeeStrategy: Array<AddressFundsFeeStrategyStepNAPI>, coreFeePerByte: number, jsPooling: DynamicValue, jsOutputScript: CoreScriptNAPI, userFeeIncrease: number, jsInputWitnesses: Array<AddressWitnessNAPI>, jsOutput?: OutputAddressNAPI | undefined | null);
     get coreFeePerByte(): number;
@@ -31,6 +41,8 @@ export declare class AddressCreditWithdrawalTransitionNAPI {
     set feeStrategy(jsFeeStrategy: Array<AddressFundsFeeStrategyStepNAPI>);
     set userFeeIncrease(userFeeIncrease: number);
     set inputWitness(jsInputWitnesses: Array<AddressWitnessNAPI>);
+    static estimateMinFee(jsInputCount: number, jsHasChangeOutput: boolean, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -56,6 +68,7 @@ export declare class AddressFundingFromAssetLockTransitionNAPI {
     set feeStrategy(jsFeeStrategy: Array<AddressFundsFeeStrategyStepNAPI>);
     set userFeeIncrease(userFeeIncrease: number);
     set inputWitness(jsInputWitnesses: Array<AddressWitnessNAPI>);
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -84,6 +97,8 @@ export declare class AddressFundsTransferTransitionNAPI {
     set feeStrategy(jsFeeStrategy: Array<AddressFundsFeeStrategyStepNAPI>);
     set userFeeIncrease(userFeeIncrease: number);
     set inputWitness(jsInputWitnesses: Array<AddressWitnessNAPI>);
+    static estimateMinFee(jsInputCount: number, jsOutputCount: number, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -111,6 +126,12 @@ export declare class AssetLockProofNAPI {
     hex(): string;
     static fromHex(assetLockProof: string): AssetLockProofNAPI;
 }
+export declare class AssetLockValueNAPI {
+    get initialCreditValue(): BigIntString;
+    get txOutScript(): Uint8Array;
+    get remainingCreditValue(): BigIntString;
+    get usedTags(): Array<Uint8Array>;
+}
 export declare class AuthorizedActionTakersNAPI {
     static NoOne(): AuthorizedActionTakersNAPI;
     static ContractOwner(): AuthorizedActionTakersNAPI;
@@ -142,6 +163,7 @@ export declare class BatchTransitionNAPI {
     setIdentityContractNonce(nonce: BigIntString): void;
     toStateTransition(): StateTransitionNAPI;
     static fromStateTransition(stateTransition: StateTransitionNAPI): BatchTransitionNAPI;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -149,11 +171,24 @@ export declare class BatchTransitionNAPI {
     static fromBase64(base64: string): BatchTransitionNAPI;
     static fromHex(hex: string): BatchTransitionNAPI;
 }
+/** The address balance changes that happened in a single block. */
+export declare class BlockAddressBalanceChangesNAPI {
+    get blockHeight(): BigIntString;
+    get changes(): Array<AddressBalanceChangeNAPI>;
+}
 export declare class BlockBasedDistributionNAPI {
     interval: BigIntString;
     get function(): DistributionFunctionNAPI;
     set function(distributionFunction: DistributionFunctionNAPI);
 }
+/**
+ * One add-to-credits operation, kept tagged with the block it happened in so a
+ * partially-synced client can tell which additions it has already applied.
+ */
+export declare class BlockHeightCreditNAPI {
+    get blockHeight(): BigIntString;
+    get credits(): BigIntString;
+}
 export declare class BlockInfoNAPI {
     constructor(timestamp: BigIntString, height: BigIntString, coreBlockHeight: number, jsEpochIndex?: number | undefined | null);
     get timeMs(): BigIntString;
@@ -190,6 +225,82 @@ export declare class ChangeControlRulesNAPI {
     set selfChangingAdminActionTakersAllowed(selfChangingAdminActionTakersAllowed: boolean);
     canChangeAdminActionTakers(adminActionTakers: AuthorizedActionTakersNAPI, jsContractOwnerId: IdentifierLikeNAPI, mainGroup: number | undefined | null, jsGroups: Array<[number, GroupNAPI]>, actionTaker: ActionTakerNAPI, jsGoal: DynamicValue): boolean;
 }
+/**
+ * Client-side Orchard note commitment tree.
+ *
+ * Rebuild the tree by appending every note commitment (`cmx`) in tree order,
+ * then produce a spend witness (`MerklePath`) for any leaf you marked. The
+ * witness + [`anchor`](Self::anchor) are what a shielded spend (withdrawal,
+ * unshield, transfer) needs to prove a note is in the tree.
+ *
+ * Typical flow:
+ * 1. `append(cmx, marked)` for each commitment (mark the ones you'll spend),
+ * 2. `checkpoint(id)` once all commitments up to your anchor are in,
+ * 3. `witness(position)` for the marked leaf and `anchor()` for the root —
+ *    both taken from the same state so `merklePath.root(cmx) == anchor`.
+ */
+export declare class CommitmentTreeNAPI {
+    /**
+     * Creates an empty tree. `max_checkpoints` bounds how many historical
+     * checkpoints are retained for witnessing (default 100).
+     */
+    constructor(maxCheckpoints?: number | undefined | null);
+    /**
+     * Appends a 32-byte note commitment (`cmx`). Set `marked` to `true` for
+     * commitments you intend to spend (only marked leaves can be witnessed).
+     */
+    append(jsCmx: Uint8Array, marked: boolean): void;
+    /**
+     * Records a checkpoint at the current state. Witnesses are produced
+     * relative to checkpoints, so checkpoint after appending the commitments
+     * up to the anchor you want to spend against.
+     */
+    checkpoint(checkpointId: number): boolean;
+    /**
+     * Position (leaf index) of the most recently appended commitment, or
+     * `null` if the tree is empty.
+     */
+    maxLeafPosition(): number | null;
+    /**
+     * Produces the Merkle witness for the marked leaf at `position`.
+     * `checkpoint_depth` is 0 for the current state, 1 for the previous
+     * checkpoint, etc. Returns `null` if no witness is available.
+     */
+    witness(position: number, checkpointDepth?: number | undefined | null): MerklePathNAPI | null;
+    /**
+     * The current tree root as a 32-byte Orchard `Anchor` (the empty-tree
+     * anchor if nothing has been appended).
+     */
+    anchor(): Uint8Array;
+}
+/** How one address's balance changed across a compacted range of blocks. */
+export declare class CompactedAddressBalanceChangeNAPI {
+    get address(): PlatformAddressNAPI;
+    /**
+     * Either "setCredits" or "addToCreditsOperations", naming which of the two
+     * fields below is populated.
+     */
+    get operation(): string;
+    /**
+     * The final balance, when a set overwrote everything before it in the
+     * range.
+     */
+    get setCredits(): BigIntString | null;
+    /**
+     * The individual additions, kept per block rather than summed so a client
+     * can apply only the ones past its sync height.
+     */
+    get addToCreditsOperations(): Array<BlockHeightCreditNAPI>;
+}
+/**
+ * The compacted changes covering blocks `startBlockHeight` through
+ * `endBlockHeight` inclusive.
+ */
+export declare class CompactedBlockAddressBalanceChangesNAPI {
+    get startBlockHeight(): BigIntString;
+    get endBlockHeight(): BigIntString;
+    get changes(): Array<CompactedAddressBalanceChangeNAPI>;
+}
 export declare class ConsensusErrorNAPI {
     static deserialize(error: Uint8Array): ConsensusErrorNAPI;
     get message(): string;
@@ -231,6 +342,7 @@ export declare class DataContractCreateTransitionNAPI {
     static fromBytes(bytes: Uint8Array): DataContractCreateTransitionNAPI;
     static fromHex(hex: string): DataContractCreateTransitionNAPI;
     static fromBase64(base64: string): DataContractCreateTransitionNAPI;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -280,6 +392,7 @@ export declare class DataContractUpdateTransitionNAPI {
     static fromBytes(bytes: Uint8Array): DataContractUpdateTransitionNAPI;
     static fromHex(hex: string): DataContractUpdateTransitionNAPI;
     static fromBase64(base64: string): DataContractUpdateTransitionNAPI;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -466,6 +579,60 @@ export declare class ExtendedEpochInfoNAPI {
     feeMultiplierPermille: BigIntString;
     protocolVersion: number;
 }
+export declare class FinalizedEpochInfoNAPI {
+    get firstBlockTime(): BigIntString;
+    get firstBlockHeight(): BigIntString;
+    get totalBlocksInEpoch(): BigIntString;
+    get firstCoreBlockHeight(): number;
+    get nextEpochStartCoreBlockHeight(): number;
+    get totalProcessingFees(): BigIntString;
+    get totalDistributedStorageFees(): BigIntString;
+    get totalCreatedStorageFees(): BigIntString;
+    get coreBlockRewards(): BigIntString;
+    get blockProposers(): Array<[IdentifierNAPI, BigIntString]>;
+    get feeMultiplierPermille(): BigIntString;
+    get protocolVersion(): number;
+}
+/**
+ * An Orchard full viewing key: it can detect both incoming and outgoing notes
+ * and compute their nullifiers (so it sees the full balance), but cannot spend.
+ */
+export declare class FullViewingKeyNAPI {
+    /**
+     * Derives the full viewing key from a BIP-39 seed via ZIP-32
+     * (`m/32'/coin_type'/account'`). `coin_type` is SLIP-44 (Dash = 5,
+     * testnets = 1).
+     */
+    static fromSeed(seed: Uint8Array, coinType: number, account: number): FullViewingKeyNAPI;
+    /**
+     * Parses a full viewing key from its 96-byte raw encoding
+     * (`ak || nk || rivk`).
+     */
+    static fromBytes(bytes: Uint8Array): FullViewingKeyNAPI;
+    /** The 96-byte raw encoding of this key. */
+    bytes(): Uint8Array;
+    /**
+     * Derives the incoming viewing key for the given scope (default
+     * `External`) — the key that trial-decrypts notes sent to you.
+     */
+    toIvk(jsScope?: DynamicValue | undefined | null): IncomingViewingKeyNAPI;
+    /**
+     * Derives the outgoing viewing key (32 bytes) for the given scope (default
+     * `External`) — the value to pass as `sender_ovk` when building a shield so
+     * the sender can later recover its own send.
+     */
+    toOvk(jsScope?: DynamicValue | undefined | null): Uint8Array;
+    /**
+     * The payment address at `diversifier_index` (default 0) for the given
+     * scope (default `External`).
+     */
+    address(diversifierIndex?: number | undefined | null, jsScope?: DynamicValue | undefined | null): OrchardAddressNAPI;
+    /**
+     * The scope this address was derived under, or `null` if it does not
+     * belong to this key.
+     */
+    scopeForAddress(jsAddress: OrchardAddressNAPI): string | null;
+}
 export declare class GroupNAPI {
     constructor(jsMembers: Array<[IdentifierLikeNAPI, number]>, requiredPower: number);
     get members(): Array<[IdentifierNAPI, number]>;
@@ -483,6 +650,70 @@ export declare class GroupStateTransitionInfoNAPI {
     get actionId(): IdentifierNAPI;
     get actionIsProposer(): boolean;
 }
+/**
+ * An ancestor of a leaf whose subtree is large enough to hide which leaf was
+ * actually wanted.
+ */
+export declare class GroveAncestorNAPI {
+    levelsUp: number;
+    get count(): BigIntString;
+    get key(): Uint8Array;
+    get hash(): Uint8Array;
+}
+/** A proven element together with the key it is stored under. */
+export declare class GroveElementEntryNAPI {
+    get key(): Uint8Array;
+    get element(): GroveElementNAPI;
+}
+/**
+ * A GroveDB element flattened into a JS-friendly shape.
+ *
+ * `Element` is a wide enum whose variants carry different combinations of a
+ * value, a sum and a count. Rather than model that union in JS, every variant
+ * is projected onto the fields it actually populates and identified by `type`,
+ * so callers switch on `type` and read the fields it implies.
+ *
+ * The projection is deliberately lossy: element flags, reference paths, and
+ * the structural parameters of the append-only tree variants (chunk power,
+ * height) are dropped. The address funds tree stores none of those, so what
+ * survives is everything that tree can actually hold.
+ */
+export declare class GroveElementNAPI {
+    /** The `Element` variant, e.g. "Item", "SumTree" or "ProvableCountSumTree". */
+    get type(): string;
+    /**
+     * Set when the element was wrapped to opt out of contributing to its
+     * parent's aggregates: "NonCounted", "NotSummed" or "NotCountedOrSummed".
+     * `type` then describes the wrapped element itself.
+     */
+    get wrapper(): string | null;
+    /**
+     * An item's payload, or a subtree's root key. Absent for an empty subtree,
+     * and for variants that carry neither (`Reference`, `SumItem`).
+     */
+    get value(): Uint8Array | null;
+    /** The sum, for the sum-bearing variants only. */
+    get sum(): BigIntString | null;
+    /** The element count, for the count-bearing variants only. */
+    get count(): BigIntString | null;
+}
+/**
+ * A truncated subtree: the proof stops here, and `hash` is what a follow-up
+ * branch proof for this key must reproduce.
+ */
+export declare class GroveLeafInfoNAPI {
+    get key(): Uint8Array;
+    /**
+     * Pass this as `expectedRootHash` when verifying the branch proof for this
+     * key.
+     */
+    get hash(): Uint8Array;
+    /**
+     * How many elements the truncated subtree holds. Only the counted tree
+     * types carry this.
+     */
+    get count(): BigIntString | null;
+}
 export declare class IdentifierNAPI {
     constructor(jsId: DynamicValue);
     base58(): string;
@@ -508,6 +739,7 @@ export declare class IdentityCreateFromAddressesTransitionNAPI {
     set feeStrategy(jsFeeStrategy: Array<AddressFundsFeeStrategyStepNAPI>);
     set userFeeIncrease(userFeeIncrease: number);
     set inputWitness(jsInputWitnesses: Array<AddressWitnessNAPI>);
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -517,11 +749,48 @@ export declare class IdentityCreateFromAddressesTransitionNAPI {
     static fromStateTransition(st: StateTransitionNAPI): IdentityCreateFromAddressesTransitionNAPI;
     toStateTransition(): StateTransitionNAPI;
 }
+/**
+ * Result of [`ShieldedBuilderNAPI::identity_create_from_shielded_pool`]: 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 IdentityCreateFromShieldedPoolResultNAPI {
+    get publicKeys(): Array<IdentityPublicKeyInCreationNAPI>;
+    get identityId(): IdentifierNAPI;
+    get predictedFee(): BigIntString;
+    get actions(): Array<SerializedActionNAPI>;
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+}
+export declare class IdentityCreateFromShieldedPoolTransitionNAPI {
+    constructor(jsPublicKeys: Array<IdentityPublicKeyInCreationNAPI>, jsDenomination: BigIntString, jsActions: Array<SerializedActionNAPI>, jsAnchor: Uint8Array, jsProof: Uint8Array, jsBindingsSignature: Uint8Array, jsSendToAddressOnCreationFailure: PlatformAddressLikeNAPI, jsIdentityId: IdentifierLikeNAPI);
+    get publicKeys(): Array<IdentityPublicKeyInCreationNAPI>;
+    get denomination(): BigIntString;
+    get actions(): Array<SerializedActionNAPI>;
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+    get sendToAddressOnCreationFailure(): PlatformAddressNAPI;
+    get identityId(): IdentifierNAPI;
+    set publicKeys(jsPublicKeys: Array<IdentityPublicKeyInCreationNAPI>);
+    set denomination(denomination: BigIntString);
+    set actions(actions: Array<SerializedActionNAPI>);
+    set anchor(jsAnchor: Uint8Array);
+    set proof(proof: Uint8Array);
+    set bindingsSignature(jsBindingsSignature: Uint8Array);
+    set sendToAddressOnCreationFailure(jsAddress: PlatformAddressLikeNAPI);
+    set identityId(jsId: IdentifierLikeNAPI);
+    static computeMinimumFee(jsNumActions: number, jsNumKeys: number, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
+    toStateTransition(): StateTransitionNAPI;
+    static fromStateTransition(st: StateTransitionNAPI): IdentityCreateFromShieldedPoolTransitionNAPI;
+}
 export declare class IdentityCreateTransitionNAPI {
     constructor(jsPublicKeys: Array<IdentityPublicKeyInCreationNAPI>, assetLock: AssetLockProofNAPI, signature?: Uint8Array | undefined | null, userFeeIncrease?: number | undefined | null);
     static default(jsPlatformVersion: DynamicValue): IdentityCreateTransitionNAPI;
     static fromHex(hex: string): IdentityCreateTransitionNAPI;
     static fromBase64(base64: string): IdentityCreateTransitionNAPI;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     static fromBytes(bytes: Uint8Array): IdentityCreateTransitionNAPI;
     get publicKeys(): Array<IdentityPublicKeyInCreationNAPI>;
@@ -539,6 +808,7 @@ export declare class IdentityCreateTransitionNAPI {
 }
 export declare class IdentityCreditTransferNAPI {
     constructor(jsSender: IdentifierLikeNAPI, amount: BigIntString, jsRecipient: IdentifierLikeNAPI, nonce: BigIntString, userFeeIncrease?: number | undefined | null);
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -577,6 +847,7 @@ export declare class IdentityCreditTransferToAddressesTransitionNAPI {
     set userFeeIncrease(userFeeIncrease: number);
     set signaturePublicKeyId(keyId: number);
     set signature(signature: Uint8Array);
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -612,6 +883,7 @@ export declare class IdentityCreditWithdrawalTransitionNAPI {
     set signaturePublicKeyId(signaturePublicKeyId: number);
     static fromHex(hex: string): IdentityCreditWithdrawalTransitionNAPI;
     static fromBase64(base64: string): IdentityCreditWithdrawalTransitionNAPI;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -719,6 +991,7 @@ export declare class IdentityTopUpFromAddressesTransitionNAPI {
     set feeStrategy(jsFeeStrategy: Array<AddressFundsFeeStrategyStepNAPI>);
     set userFeeIncrease(userFeeIncrease: number);
     set inputWitness(jsInputWitnesses: Array<AddressWitnessNAPI>);
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -741,6 +1014,7 @@ export declare class IdentityTopUpTransitionNAPI {
     get signature(): Uint8Array;
     getSignableBytes(): Uint8Array;
     set signature(signature: Uint8Array);
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -774,6 +1048,7 @@ export declare class IdentityUpdateTransitionNAPI {
     set signaturePublicKeyId(signaturePublicKeyId: number);
     static fromHex(hex: string): IdentityUpdateTransitionNAPI;
     static fromBase64(base64: string): IdentityUpdateTransitionNAPI;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
@@ -781,6 +1056,40 @@ export declare class IdentityUpdateTransitionNAPI {
     toStateTransition(): StateTransitionNAPI;
     static fromStateTransition(st: StateTransitionNAPI): IdentityUpdateTransitionNAPI;
 }
+/**
+ * An Orchard incoming viewing key: it detects and decrypts notes sent to you,
+ * but cannot see your outgoing notes, tell when a note is spent, or spend it.
+ * Safe to hand to a watch-only service such as a merchant terminal.
+ */
+export declare class IncomingViewingKeyNAPI {
+    /**
+     * Derives the incoming viewing key from a BIP-39 seed via ZIP-32
+     * (`m/32'/coin_type'/account'`) for the given scope (default `External`).
+     */
+    static fromSeed(seed: Uint8Array, coinType: number, account: number, jsScope?: DynamicValue | undefined | null): IncomingViewingKeyNAPI;
+    /**
+     * Derives the incoming viewing key from a full viewing key for the given
+     * scope (default `External`).
+     */
+    static fromFullViewingKey(jsFullViewingKey: FullViewingKeyNAPI, jsScope?: DynamicValue | undefined | null): IncomingViewingKeyNAPI;
+    /**
+     * Parses an incoming viewing key from its 64-byte raw encoding
+     * (`dk || ivk`).
+     */
+    static fromBytes(bytes: Uint8Array): IncomingViewingKeyNAPI;
+    /** The 64-byte raw encoding of this key. */
+    bytes(): Uint8Array;
+    /**
+     * The payment address at `diversifier_index` (default 0). The scope is
+     * fixed by the key itself.
+     */
+    address(diversifierIndex?: number | undefined | null): OrchardAddressNAPI;
+    /**
+     * The diversifier index `address` was derived at, or `null` if the address
+     * was not derived from this key.
+     */
+    diversifierIndex(jsAddress: OrchardAddressNAPI): number | null;
+}
 export declare class InputAddressNAPI {
     constructor(address: PlatformAddressLikeNAPI, nonce: number, credits: BigIntString);
     get address(): PlatformAddressNAPI;
@@ -832,18 +1141,75 @@ export declare class MasternodeVoteTransitionNAPI {
     set signature(signature: Uint8Array);
     static fromHex(hex: string): MasternodeVoteTransitionNAPI;
     static fromBase64(base64: string): MasternodeVoteTransitionNAPI;
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;
     static fromBytes(jsBytes: Uint8Array): MasternodeVoteTransitionNAPI;
-    get userFeeIncrease(): number;
     getSignableBytes(): Uint8Array;
     get assetLock(): AssetLockProofNAPI | null;
-    set userFeeIncrease(amount: number);
     get modifiedDataIds(): Array<IdentifierNAPI>;
     toStateTransition(): StateTransitionNAPI;
     static fromStateTransition(st: StateTransitionNAPI): MasternodeVoteTransitionNAPI;
 }
+/**
+ * The Merkle path from a note commitment leaf to the tree anchor: the leaf
+ * `position` plus the `NOTE_COMMITMENT_TREE_DEPTH` sibling hashes.
+ */
+export declare class MerklePathNAPI {
+    constructor(jsPosition: number, jsAuthPath: Array<Uint8Array>);
+    get position(): number;
+    get authPath(): Array<Uint8Array>;
+    set position(jsPosition: number);
+    set authPath(jsAuthPath: Array<Uint8Array>);
+}
+/**
+ * A shielded Orchard note: the funds received by an address, defined by its
+ * owner address, value, `rho`, and `rseed`.
+ */
+export declare class NoteNAPI {
+    constructor(jsAddress: OrchardAddressNAPI, jsValue: BigIntString, jsRho: Uint8Array, jsRseed: Uint8Array);
+    get address(): OrchardAddressNAPI;
+    get value(): BigIntString;
+    get rho(): Uint8Array;
+    get rseed(): Uint8Array;
+    /**
+     * The extracted note commitment (`cmx`, 32 bytes) — the leaf this note
+     * occupies in the note commitment tree. Append this to a
+     * `CommitmentTreeNAPI` to later produce the note's spend witness.
+     */
+    get cmx(): Uint8Array;
+    set address(jsAddress: OrchardAddressNAPI);
+    set value(jsValue: BigIntString);
+    set rho(jsRho: Uint8Array);
+    set rseed(jsRseed: Uint8Array);
+}
+export declare class OrchardAddressNAPI {
+    static fromBech32m(bech32M: string): OrchardAddressNAPI;
+    static fromBytes(bytes: Uint8Array): OrchardAddressNAPI;
+    toBech32m(jsNetwork: DynamicValue): string;
+    /**
+     * Derives the Orchard payment address from a BIP-39 seed via ZIP-32
+     * (`m/32'/coin_type'/account'`). `diversifier_index` selects the diversified
+     * address (default 0), `scope` the ZIP-32 scope (default `External`).
+     * `coin_type` is SLIP-44 (Dash = 5, testnets = 1).
+     */
+    static fromSeed(seed: Uint8Array, coinType: number, account: number, diversifierIndex?: number | undefined | null, jsScope?: DynamicValue | undefined | null): OrchardAddressNAPI;
+    /**
+     * Derives the payment address at `diversifier_index` (default 0) from a
+     * full viewing key, for the given `scope` (default `External`).
+     */
+    static fromFullViewingKey(jsFullViewingKey: FullViewingKeyNAPI, diversifierIndex?: number | undefined | null, jsScope?: DynamicValue | undefined | null): OrchardAddressNAPI;
+    /**
+     * Derives the payment address at `diversifier_index` (default 0) from an
+     * incoming viewing key. The scope is fixed by the key itself.
+     */
+    static fromIncomingViewingKey(jsIncomingViewingKey: IncomingViewingKeyNAPI, diversifierIndex?: number | undefined | null): OrchardAddressNAPI;
+    bytes(): Uint8Array;
+}
+export declare class OrchardProverNAPI {
+    static init(): Promise<OrchardProverNAPI>;
+}
 export declare class OutPointNAPI {
     constructor(txidHex: string, vout: number);
     getVOUT(): number;
@@ -890,6 +1256,17 @@ export declare class PlatformAddressInfoNAPI {
 export declare class PlatformAddressNAPI {
     constructor(address: PlatformAddressLikeNAPI);
     bytes(): Uint8Array;
+    /**
+     * Storage fee GroveDB charges for creating balance entries for addresses that are not in
+     * state yet.
+     *
+     * Minimum fees price a transition as if every one of its outputs pays a fresh address, but
+     * the fee actually charged is metered: paying an address that already exists writes no new
+     * bytes and costs (close to) nothing in storage, while every address created costs
+     * `PLATFORM_ADDRESS_STORAGE_BYTES` at the disk rate. Add this to a processing estimate when
+     * you know how many of your outputs are new.
+     */
+    static estimateStorageFeeForNewAddresses(jsAddressCount: number, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     toAddress(jsNetwork: DynamicValue): string;
     toBech32m(jsNetwork: DynamicValue): string;
     isP2PKH(): boolean;
@@ -937,6 +1314,20 @@ export declare class PublicKeyNAPI {
     bytes(): Uint8Array;
     static fromBytes(bytes: Uint8Array): PublicKeyNAPI;
 }
+/**
+ * A note recovered from a shielded action by trial-decryption, together with
+ * the index of the action it was found in (its on-wire / tree-leaf order
+ * within the transition's actions).
+ */
+export declare class RecoveredNoteNAPI {
+    get index(): number;
+    get note(): NoteNAPI;
+    /**
+     * The note's nullifier (32 bytes). Check it against `getShieldedNullifiers`
+     * to tell whether this note has already been spent.
+     */
+    get nullifier(): Uint8Array;
+}
 export declare class ResourceVoteChoiceNAPI {
     static TowardsIdentity(jsId: IdentifierLikeNAPI): ResourceVoteChoiceNAPI;
     static Abstain(): ResourceVoteChoiceNAPI;
@@ -950,6 +1341,21 @@ export declare class RewardDistributionTypeNAPI {
     static EpochBasedDistribution(interval: number, distributionFunction: DistributionFunctionNAPI): RewardDistributionTypeNAPI;
     getDistribution(): BlockBasedDistributionNAPI | TimeBasedDistributionNAPI | EpochBasedDistributionNAPI;
 }
+export declare class SerializedActionNAPI {
+    constructor(jsNullifier: Uint8Array, jsRk: Uint8Array, jsCmx: Uint8Array, jsEncryptedNote: Uint8Array, jsCvNet: Uint8Array, jsSpendAuthSig: Uint8Array);
+    get nullifier(): Uint8Array;
+    get rk(): Uint8Array;
+    get cmx(): Uint8Array;
+    get encrypted_note(): Uint8Array;
+    get cvNet(): Uint8Array;
+    get spendAuthSig(): Uint8Array;
+    set nullifier(jsNullifier: Uint8Array);
+    set rk(jsRk: Uint8Array);
+    set cmx(jsCmx: Uint8Array);
+    set encrypted_note(jsEncryptedNote: Uint8Array);
+    set cvNet(jsCvNet: Uint8Array);
+    set spendAuthSig(jsSpendAuthSig: Uint8Array);
+}
 export declare class SharedEncryptedNoteNAPI {
     constructor(senderKeyIndex: number, recipientKeyIndex: number, value: Uint8Array);
     get senderKeyIndex(): number;
@@ -959,6 +1365,259 @@ export declare class SharedEncryptedNoteNAPI {
     set recipientKeyIndex(index: number);
     set value(value: Uint8Array);
 }
+export declare class ShieldedBuilderNAPI {
+    static init(): Promise<ShieldedBuilderNAPI>;
+    shieldFromAssetLock(jsRecipient: OrchardAddressNAPI, jsShieldAmount: BigIntString, jsAssetLockProof: AssetLockProofNAPI, jsPrivateKey: DynamicValue | PrivateKeyNAPI, jsMemo: ShieldedMemoNAPI, jsDummyOutputs: number, jsSenderOvk?: Uint8Array | undefined | null, jsSurplusOutput?: PlatformAddressLikeNAPI | undefined | null, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): Promise<StateTransitionNAPI>;
+    /**
+     * Builds a `ShieldedWithdrawal` state transition (shielded pool -> core L1).
+     *
+     * - `spends` - notes to spend with their Merkle paths
+     * - `withdrawal_amount` - amount of credits to withdraw to the core chain
+     * - `output_script` - core chain script that receives the funds
+     * - `core_fee_per_byte` - core chain fee rate
+     * - `pooling` - withdrawal pooling strategy ("Never" / "IfAvailable" / "Standard")
+     * - `change_address` - Orchard address that receives the shielded change note
+     * - `seed` / `coin_type` / `account` - BIP-39 seed + ZIP-32 path used to derive the
+     *   spend authority (full viewing key + spend authorizing key) for the notes being spent
+     * - `anchor` - 32-byte Sinsemilla root the Merkle paths are witnessed against
+     * - `memo` - structured memo for the change note
+     * - `platform_version` - protocol version (defaults to the latest)
+     *
+     * Returns the proven state transition together with the fixed shielded fee (credits)
+     * consensus charges for it.
+     */
+    shieldedWithdrawal(jsSpends: Array<SpendableNoteNAPI>, jsWithdrawalAmount: BigIntString, jsOutputScript: CoreScriptNAPI, jsCoreFeePerByte: number, jsPooling: DynamicValue, jsChangeAddress: OrchardAddressNAPI, jsSeed: Uint8Array, jsCoinType: number, jsAccount: number, jsAnchor: Uint8Array, jsMemo: ShieldedMemoNAPI, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): Promise<ShieldedWithdrawalResultNAPI>;
+    /**
+     * Builds an `Unshield` state transition (shielded pool -> platform address).
+     *
+     * Like withdrawal, this spends notes — so it needs the same on-chain
+     * commitment-tree witness + anchor. The net (`unshield_amount`) is credited
+     * to `output_address` (a platform identity balance), and any remaining value
+     * returns to the shielded `change_address`.
+     *
+     * - `spends` - notes to spend with their Merkle paths
+     * - `output_address` - platform address that receives the unshielded credits
+     * - `unshield_amount` - amount of credits to unshield
+     * - `change_address` - Orchard address that receives the shielded change note
+     * - `seed` / `coin_type` / `account` - BIP-39 seed + ZIP-32 path for the spend authority
+     * - `anchor` - 32-byte Sinsemilla root the Merkle paths are witnessed against
+     * - `memo` - structured memo for the change note
+     * - `platform_version` - protocol version (defaults to the latest)
+     *
+     * Returns the proven state transition plus the fixed shielded fee (credits).
+     */
+    unshield(jsSpends: Array<SpendableNoteNAPI>, jsOutputAddress: PlatformAddressLikeNAPI, jsUnshieldAmount: BigIntString, jsChangeAddress: OrchardAddressNAPI, jsSeed: Uint8Array, jsCoinType: number, jsAccount: number, jsAnchor: Uint8Array, jsMemo: ShieldedMemoNAPI, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): Promise<ShieldedWithdrawalResultNAPI>;
+    /**
+     * Builds a `ShieldedTransfer` state transition (shielded pool -> shielded pool).
+     *
+     * Spends notes and sends value to another Orchard address, fully shielded.
+     * Needs the same on-chain commitment-tree witness + anchor as the other
+     * spends. Any remaining value returns to `change_address`.
+     *
+     * - `spends` - notes to spend with their Merkle paths
+     * - `recipient` - Orchard address that receives the transferred note
+     * - `transfer_amount` - amount of credits to transfer
+     * - `change_address` - Orchard address that receives the shielded change note
+     * - `seed` / `coin_type` / `account` - BIP-39 seed + ZIP-32 path for the spend authority
+     * - `anchor` - 32-byte Sinsemilla root the Merkle paths are witnessed against
+     * - `memo` - structured memo for the recipient/change note
+     * - `platform_version` - protocol version (defaults to the latest)
+     *
+     * Returns the proven state transition plus the fixed shielded fee (credits).
+     */
+    shieldedTransfer(jsSpends: Array<SpendableNoteNAPI>, jsRecipient: OrchardAddressNAPI, jsTransferAmount: BigIntString, jsChangeAddress: OrchardAddressNAPI, jsSeed: Uint8Array, jsCoinType: number, jsAccount: number, jsAnchor: Uint8Array, jsMemo: ShieldedMemoNAPI, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): Promise<ShieldedWithdrawalResultNAPI>;
+    /**
+     * Builds a `ShieldedTransfer` that pays many Orchard addresses at once
+     * (shielded pool -> shielded pool).
+     *
+     * Same spend side as [`Self::shielded_transfer`] — one account's notes, one
+     * anchor — but the output side is a list instead of a single recipient, so
+     * one proof and one fee cover the whole fan-out. Consensus never sees the
+     * output count (outputs are ciphertext inside the actions), so this needs no
+     * protocol change; what it does see is `actions.len()`, which Orchard sets to
+     * `max(spends, outputs + change, 2)` and prices the fee from.
+     *
+     * - `spends` - notes to spend with their Merkle paths
+     * - `outputs` - recipients, each with its own amount and memo (at least one)
+     * - `change_address` - Orchard address that receives the shielded change note;
+     *   it is always written, even at zero value, so the action count — and with
+     *   it the fee — is fixed before the change amount is known
+     * - `seed` / `coin_type` / `account` - BIP-39 seed + ZIP-32 path for the spend authority
+     * - `anchor` - 32-byte Sinsemilla root the Merkle paths are witnessed against
+     * - `platform_version` - protocol version (defaults to the latest)
+     *
+     * Returns the proven state transition plus the fixed shielded fee (credits).
+     * Errors before proving if the bundle would exceed the consensus action cap,
+     * rather than after a multi-second proof the node would reject.
+     */
+    shieldedTransferMulti(jsSpends: Array<SpendableNoteNAPI>, jsOutputs: Array<ShieldedOutputNAPI>, jsChangeAddress: OrchardAddressNAPI, jsSeed: Uint8Array, jsCoinType: number, jsAccount: number, jsAnchor: Uint8Array, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): Promise<ShieldedWithdrawalResultNAPI>;
+    /**
+     * Builds a `Shield` state transition (transparent platform addresses -> pool).
+     *
+     * A deposit: it does NOT spend pool notes (no witness/anchor needed), but it
+     * does sign the transparent input witnesses, so you pass the `PrivateKeyNAPI`
+     * for every input address. Fees are deducted from the inputs per `fee_strategy`.
+     *
+     * - `recipient` - Orchard address that receives the shielded note
+     * - `shield_amount` - amount of credits to shield
+     * - `inputs` - platform address inputs (address + nonce + balance)
+     * - `private_keys` - one private key per input address (used to sign witnesses)
+     * - `fee_strategy` - how fees are deducted from the inputs
+     * - `user_fee_increase` - user fee bump
+     * - `memo` - structured memo for the recipient note
+     * - `sender_ovk` - optional 32-byte sender OVK (recoverable send when set)
+     * - `platform_version` - protocol version (defaults to the latest)
+     */
+    shield(jsRecipient: OrchardAddressNAPI, jsShieldAmount: BigIntString, jsInputs: Array<InputAddressNAPI>, jsPrivateKeys: Array<PrivateKeyNAPI>, jsFeeStrategy: Array<AddressFundsFeeStrategyStepNAPI>, jsUserFeeIncrease: number, jsMemo: ShieldedMemoNAPI, jsSenderOvk?: Uint8Array | undefined | null, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): Promise<StateTransitionNAPI>;
+    /**
+     * Builds an `IdentityCreateFromShieldedPool` transition (pool -> new identity).
+     *
+     * A spend (needs the on-chain witness + anchor) that funds a brand-new identity
+     * from the shielded pool. Each `public_keys[i]` is paired with `private_keys[i]`,
+     * which signs that key's proof-of-possession (ECDSA keys only).
+     *
+     * - `public_keys` - the new identity's keys (in-creation form)
+     * - `private_keys` - one private key per public key (same order)
+     * - `denomination` - fixed pool denomination funding the identity
+     * - `send_to_address_on_creation_failure` - platform address refunded if creation fails
+     * - `spends` - notes to spend with their Merkle paths
+     * - `change_address` - Orchard address for the shielded change note
+     * - `seed` / `coin_type` / `account` - BIP-39 seed + ZIP-32 path for the spend authority
+     * - `anchor` - 32-byte Sinsemilla root the Merkle paths are witnessed against
+     * - `memo` - structured memo for the change note
+     * - `platform_version` - protocol version (defaults to the latest)
+     */
+    identityCreateFromShieldedPool(jsPublicKeys: Array<IdentityPublicKeyInCreationNAPI>, jsPrivateKeys: Array<PrivateKeyNAPI>, jsDenomination: BigIntString, jsSendToAddressOnCreationFailure: PlatformAddressLikeNAPI, jsSpends: Array<SpendableNoteNAPI>, jsChangeAddress: OrchardAddressNAPI, jsSeed: Uint8Array, jsCoinType: number, jsAccount: number, jsAnchor: Uint8Array, jsMemo: ShieldedMemoNAPI, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): Promise<IdentityCreateFromShieldedPoolResultNAPI>;
+}
+export declare class ShieldedMemoNAPI {
+    static fromString(value: string): ShieldedMemoNAPI;
+    static empty(): ShieldedMemoNAPI;
+    static other(kind: number, payload: Uint8Array): ShieldedMemoNAPI;
+    toString(): string;
+    toBytes(): Uint8Array;
+}
+/**
+ * One output of a multi-output shielded transfer: the Orchard address that
+ * receives the note, its value in credits, and the memo carried inside the
+ * note's encrypted ciphertext.
+ *
+ * The single-recipient builders take the recipient, amount and memo as three
+ * flat arguments; fanning out to N recipients needs them grouped, so each
+ * output carries its own memo rather than sharing one across the bundle.
+ */
+export declare class ShieldedOutputNAPI {
+    constructor(jsAddress: OrchardAddressNAPI, jsAmount: BigIntString, jsMemo: ShieldedMemoNAPI);
+    get address(): OrchardAddressNAPI;
+    set address(jsAddress: OrchardAddressNAPI);
+    get amount(): BigIntString;
+    set amount(jsAmount: BigIntString);
+    get memo(): ShieldedMemoNAPI;
+    set memo(jsMemo: ShieldedMemoNAPI);
+}
+export declare class ShieldedTransferTransitionNAPI {
+    constructor(jsActions: Array<SerializedActionNAPI>, jsValueBalance: BigIntString, jsAnchor: Uint8Array, jsProof: Uint8Array, jsBindingsSignature: Uint8Array);
+    get actions(): Array<SerializedActionNAPI>;
+    get valueBalance(): BigIntString;
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+    set actions(actions: Array<SerializedActionNAPI>);
+    set valueBalance(amount: BigIntString);
+    set anchor(jsAnchor: Uint8Array);
+    set proof(proof: Uint8Array);
+    set bindingsSignature(jsBindingsSignature: Uint8Array);
+    static computeMinimumFee(jsNumActions: number, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
+    toStateTransition(): StateTransitionNAPI;
+    static fromStateTransition(st: StateTransitionNAPI): ShieldedTransferTransitionNAPI;
+}
+/**
+ * Result of a proving shielded spend builder ([`ShieldedBuilderNAPI::shielded_withdrawal`],
+ * [`ShieldedBuilderNAPI::unshield`], [`ShieldedBuilderNAPI::shielded_transfer`]): the
+ * proven state transition plus the shielded fee (credits) consensus charges for it.
+ */
+export declare class ShieldedWithdrawalResultNAPI {
+    get stateTransition(): StateTransitionNAPI;
+    get fee(): BigIntString;
+}
+export declare class ShieldedWithdrawalTransitionNAPI {
+    constructor(jsActions: Array<SerializedActionNAPI>, jsUnshieldingAmount: BigIntString, jsAnchor: Uint8Array, jsProof: Uint8Array, jsBindingsSignature: Uint8Array, coreFeePerByte: number, jsPooling: DynamicValue, jsOutputScript: CoreScriptNAPI);
+    get actions(): Array<SerializedActionNAPI>;
+    get unshieldingAmount(): BigIntString;
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+    get coreFeePerByte(): number;
+    get pooling(): string;
+    get outputScript(): CoreScriptNAPI;
+    set actions(actions: Array<SerializedActionNAPI>);
+    set unshieldingAmount(amount: BigIntString);
+    set anchor(jsAnchor: Uint8Array);
+    set proof(proof: Uint8Array);
+    set bindingsSignature(jsBindingsSignature: Uint8Array);
+    set coreFeePerByte(coreFeePerByte: number);
+    set pooling(jsPooling: DynamicValue);
+    set outputScript(outputScript: CoreScriptNAPI);
+    static computeMinimumFee(jsNumActions: number, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
+    toStateTransition(): StateTransitionNAPI;
+    static fromStateTransition(st: StateTransitionNAPI): ShieldedWithdrawalTransitionNAPI;
+}
+export declare class ShieldFromAssetLockTransitionNAPI {
+    constructor(jsAssetLockProof: AssetLockProofNAPI, jsActions: Array<SerializedActionNAPI>, jsValueBalance: BigIntString, jsAnchor: Uint8Array, jsProof: Uint8Array, jsBindingsSignature: Uint8Array, jsSurplusOutput?: PlatformAddressLikeNAPI | undefined | null);
+    get assetLockProof(): AssetLockProofNAPI;
+    get actions(): Array<SerializedActionNAPI>;
+    get valueBalance(): BigIntString;
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+    get surplusOutput(): PlatformAddressNAPI | null;
+    get signature(): Uint8Array;
+    set assetLockProof(jsAssetLockProof: AssetLockProofNAPI);
+    set actions(actions: Array<SerializedActionNAPI>);
+    set valueBalance(amount: BigIntString);
+    set anchor(jsAnchor: Uint8Array);
+    set proof(proof: Uint8Array);
+    set bindingsSignature(jsBindingsSignature: Uint8Array);
+    set surplusOutput(jsSurplusOutput: PlatformAddressLikeNAPI | undefined | null);
+    set signature(signature: Uint8Array);
+    static computeMinimumFee(jsNumActions: number, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
+    toStateTransition(): StateTransitionNAPI;
+    static fromStateTransition(st: StateTransitionNAPI): ShieldFromAssetLockTransitionNAPI;
+}
+export declare class ShieldTransitionNAPI {
+    constructor(jsInputs: Array<InputAddressNAPI>, jsActions: Array<SerializedActionNAPI>, jsAmount: BigIntString, jsAnchor: Uint8Array, jsProof: Uint8Array, jsBindingsSignature: Uint8Array, jsFeeStrategy: Array<AddressFundsFeeStrategyStepNAPI>, userFeeIncrease: number, jsInputWitnesses: Array<AddressWitnessNAPI>);
+    get inputs(): Array<InputAddressNAPI>;
+    get actions(): Array<SerializedActionNAPI>;
+    get amount(): BigIntString;
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+    get feeStrategy(): Array<AddressFundsFeeStrategyStepNAPI>;
+    get userFeeIncrease(): number;
+    get inputWitnesses(): Array<AddressWitnessNAPI>;
+    set inputs(jsInputs: Array<InputAddressNAPI>);
+    set actions(actions: Array<SerializedActionNAPI>);
+    set amount(amount: BigIntString);
+    set anchor(jsAnchor: Uint8Array);
+    set proof(proof: Uint8Array);
+    set bindingsSignature(jsBindingsSignature: Uint8Array);
+    set feeStrategy(feeStrategy: Array<AddressFundsFeeStrategyStepNAPI>);
+    set userFeeIncrease(userFeeIncrease: number);
+    set inputWitnesses(jsInputWitnesses: Array<AddressWitnessNAPI>);
+    static computeMinimumFee(jsNumActions: number, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
+    toStateTransition(): StateTransitionNAPI;
+    static fromStateTransition(st: StateTransitionNAPI): ShieldTransitionNAPI;
+}
+/**
+ * An Orchard note to spend, paired with its Merkle inclusion path in the note
+ * commitment tree — the unit consumed by a shielded spend (withdrawal, etc.).
+ */
+export declare class SpendableNoteNAPI {
+    constructor(jsNote: NoteNAPI, jsMerklePath: MerklePathNAPI);
+    get note(): NoteNAPI;
+    get merklePath(): MerklePathNAPI;
+    set note(jsNote: NoteNAPI);
+    set merklePath(jsMerklePath: MerklePathNAPI);
+}
 export declare class StateTransitionNAPI {
     sign(jsPrivateKey: DynamicValue | PrivateKeyNAPI, publicKey: IdentityPublicKeyNAPI): Uint8Array;
     signByPrivateKey(jsPrivateKey: DynamicValue | PrivateKeyNAPI, keyId?: number | undefined | null, jsKeyType?: DynamicValue | undefined | null): Uint8Array;
@@ -971,6 +1630,15 @@ export declare class StateTransitionNAPI {
     static fromBase64(base64: string): StateTransitionNAPI;
     hash(skipSignature: boolean): string;
     getActionName(): string;
+    /**
+     * The minimum fee the network requires for this transition to be accepted.
+     *
+     * This is the same value the node checks the payer balance against before execution.
+     * The fee actually charged is metered during execution and depends on state (for
+     * example, paying an address that does not exist yet adds storage cost), so it can
+     * be higher than this minimum.
+     */
+    calculateMinRequiredFee(jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
     getActionType(): string;
     getActionTypeNumber(): number;
     getOwnerId(): IdentifierNAPI | null;
@@ -989,6 +1657,10 @@ export declare class StateTransitionNAPI {
     setIdentityContractNonce(nonce: BigIntString): void;
     setIdentityNonce(nonce: BigIntString): void;
 }
+export declare class StoredAssetLockInfoNAPI {
+    get type(): string;
+    get value(): AssetLockValueNAPI | null;
+}
 export declare class TimeBasedDistributionNAPI {
     interval: BigIntString;
     get function(): DistributionFunctionNAPI;
@@ -1354,6 +2026,98 @@ export declare class TxOutNAPI {
     set scriptPubKeyBytes(scriptPubkeyBytes: Uint8Array);
     getScriptPubKeyASM(): string;
 }
+export declare class UnshieldTransitionNAPI {
+    constructor(jsOutputAddress: PlatformAddressLikeNAPI, jsActions: Array<SerializedActionNAPI>, jsUnshieldingAmount: BigIntString, jsAnchor: Uint8Array, jsProof: Uint8Array, jsBindingsSignature: Uint8Array);
+    get outputAddress(): PlatformAddressNAPI;
+    get actions(): Array<SerializedActionNAPI>;
+    get unshieldingAmount(): BigIntString;
+    get anchor(): Uint8Array;
+    get proof(): Uint8Array;
+    get bindingsSignature(): Uint8Array;
+    set outputAddress(jsOutputAddress: PlatformAddressLikeNAPI);
+    set actions(actions: Array<SerializedActionNAPI>);
+    set unshieldingAmount(amount: BigIntString);
+    set anchor(jsAnchor: Uint8Array);
+    set proof(proof: Uint8Array);
+    set bindingsSignature(jsBindingsSignature: Uint8Array);
+    static computeMinimumFee(jsNumActions: number, jsPlatformVersion?: PlatformVersionNAPI | undefined | null): BigIntString;
+    toStateTransition(): StateTransitionNAPI;
+    static fromStateTransition(st: StateTransitionNAPI): UnshieldTransitionNAPI;
+}
+/**
+ * The verified subtree returned by a branch chunk proof.
+ *
+ * A branch proof is checked against the hash its parent trunk (or branch)
+ * proof published for this key, so it carries no root hash of its own: the
+ * chain back to the platform root is what the parent already established.
+ */
+export declare class VerifiedAddressesBranchStateNAPI {
+    /** The elements proven by this branch, keyed by their tree key. */
+    get elements(): Array<GroveElementEntryNAPI>;
+    /**
+     * Subtrees this branch in turn stops at, for going a level deeper. Empty
+     * when the branch returned its whole subtree.
+     */
+    get leafKeys(): Array<GroveLeafInfoNAPI>;
+    /**
+     * This subtree's root hash, matching the `expectedRootHash` it was
+     * verified against.
+     */
+    get branchRootHash(): Uint8Array;
+    /**
+     * Which truncated subtree below this branch would contain `key`.
+     *
+     * Returns `undefined` when the key is already among `elements`, or when no
+     * subtree could hold it.
+     */
+    traceKeyToLeaf(key: Uint8Array): GroveLeafInfoNAPI | null;
+    /**
+     * Walks up from `leafKey` to the nearest ancestor holding at least
+     * `minPrivacyTreeCount` elements. See the trunk equivalent for details.
+     */
+    getAncestor(leafKey: Uint8Array, minPrivacyTreeCount: BigIntString): GroveAncestorNAPI | null;
+}
+/**
+ * The verified trunk of the address funds tree.
+ *
+ * A trunk proof covers the top of the tree only; subtrees below it are
+ * truncated and listed in `leafKeys`. Use `traceKeyToLeaf` to find which
+ * truncated subtree holds a given address, then fetch that subtree with a
+ * branch query.
+ */
+export declare class VerifiedAddressesTrunkStateNAPI {
+    rootHash: Uint8Array;
+    /** The elements proven by the trunk, keyed by their tree key. */
+    get elements(): Array<GroveElementEntryNAPI>;
+    /**
+     * The subtrees the trunk stops at. Empty when the whole tree fit in the
+     * trunk.
+     */
+    get leafKeys(): Array<GroveLeafInfoNAPI>;
+    /**
+     * Depths to split subsequent branch queries into, e.g. `[7, 7, 6]` for a
+     * tree of depth 20.
+     */
+    get chunkDepths(): Array<number>;
+    /** The tree's total depth, derived from its element count. */
+    get maxTreeDepth(): number;
+    /**
+     * Which truncated subtree would contain `key`.
+     *
+     * Returns `undefined` when the key is already among `elements`, or when no
+     * subtree could hold it.
+     */
+    traceKeyToLeaf(key: Uint8Array): GroveLeafInfoNAPI | null;
+    /**
+     * Walks up from `leafKey` to the nearest ancestor holding at least
+     * `minPrivacyTreeCount` elements, so a branch query can request a subtree
+     * large enough not to reveal which leaf was wanted.
+     *
+     * Never returns the root, and returns `undefined` when the leaf has no
+     * ancestor above it.
+     */
+    getAncestor(leafKey: Uint8Array, minPrivacyTreeCount: BigIntString): GroveAncestorNAPI | null;
+}
 export declare class VerifiedBalanceTransferNAPI {
     get sender(): PartialIdentityNAPI;
     get recipient(): PartialIdentityNAPI;
@@ -1378,6 +2142,10 @@ export declare class VerifiedEpochsInfoNAPI {
     get epochsInfo(): Array<ExtendedEpochInfoNAPI>;
     set epochsInfo(info: Array<ExtendedEpochInfoNAPI>);
 }
+export declare class VerifiedFinlizedEpochInfosNAPI {
+    rootHash: Uint8Array;
+    get epochInfos(): Array<[number, FinalizedEpochInfoNAPI]>;
+}
 export declare class VerifiedIdentifierByNonUniquePublicKeyHashNAPI {
     rootHash: Uint8Array;
     get identifier(): IdentifierNAPI | null;
@@ -1422,6 +2190,10 @@ export declare class VerifiedIdentityWithAddressInfosNAPI {
     get identity(): PartialIdentityNAPI;
     get infos(): Array<PlatformAddressInfoNAPI>;
 }
+export declare class VerifiedMostRecentShieldedAnchorNAPI {
+    rootHash: Uint8Array;
+    anchor?: Uint8Array;
+}
 export declare class VerifiedPlatformAddressesInfosNAPI {
     rootHash: Uint8Array;
     get infos(): Array<PlatformAddressInfoNAPI>;
@@ -1432,9 +2204,56 @@ export declare class VerifiedPlatformAddressInfoNAPI {
     balance?: BigIntString;
     get address(): PlatformAddressNAPI | null;
 }
+export declare class VerifiedRecentAddressBalanceChangesNAPI {
+    rootHash: Uint8Array;
+    /** The proven blocks, in ascending block-height order. */
+    get blocks(): Array<BlockAddressBalanceChangesNAPI>;
+}
+export declare class VerifiedRecentCompactedAddressBalanceChangesNAPI {
+    rootHash: Uint8Array;
+    /** The proven compacted ranges, in ascending block-height order. */
+    get ranges(): Array<CompactedBlockAddressBalanceChangesNAPI>;
+}
+export declare class VerifiedShieldedAnchorsNAPI {
+    rootHash: Uint8Array;
+    get anchors(): Array<Uint8Array>;
+}
+export declare class VerifiedShieldedEncryptedNoteNAPI {
+    cmx: Uint8Array;
+    nullifier: Uint8Array;
+    cvNet: Uint8Array;
+    encryptedNote: Uint8Array;
+}
+export declare class VerifiedShieldedEncryptedNotesNAPI {
+    rootHash: Uint8Array;
+    totalCount: BigIntString;
+    get notes(): Array<VerifiedShieldedEncryptedNoteNAPI>;
+}
+export declare class VerifiedShieldedNotesCountNAPI {
+    rootHash: Uint8Array;
+    count?: BigIntString;
+}
+export declare class VerifiedShieldedNullifierNAPI {
+    nullifier: Uint8Array;
+    isSpent: boolean;
+}
+export declare class VerifiedShieldedNullifiersNAPI {
+    rootHash: Uint8Array;
+    get nullifiers(): Array<VerifiedShieldedNullifierNAPI>;
+}
+export declare class VerifiedShieldedPoolStateNAPI {
+    rootHash: Uint8Array;
+    totalBalance?: BigIntString;
+}
 export declare class VerifiedStateTransitionResultNAPI {
     rootHash: Uint8Array;
-    get result(): DataContractNAPI | IdentityNAPI | IdentifierNAPI | VerifiedIdentityBalanceNAPI | VerifiedIdentityTokenInfoNAPI | VerifiedTokenPricingScheduleNAPI | TokenStatusNAPI | Array<VerifiedIdentityBalanceNAPI> | PartialIdentityNAPI | VerifiedBalanceTransferNAPI | Array<VerifiedDocumentNAPI> | DocumentNAPI | VerifiedTokenGroupActionWithDocumentNAPI | VerifiedTokenGroupActionWithTokenBalanceNAPI | VerifiedTokenGroupActionWithTokenIdentityInfoNAPI | VerifiedTokenGroupActionWithTokenPricingScheduleNAPI | VoteNAPI | Array<PlatformAddressInfoNAPI> | VerifiedIdentityFullWithAddressInfosNAPI | VerifiedIdentityWithAddressInfosNAPI;
+    get result(): DataContractNAPI | IdentityNAPI | IdentifierNAPI | VerifiedIdentityBalanceNAPI | VerifiedIdentityTokenInfoNAPI | VerifiedTokenPricingScheduleNAPI | TokenStatusNAPI | Array<VerifiedIdentityBalanceNAPI> | PartialIdentityNAPI | VerifiedBalanceTransferNAPI | Array<VerifiedDocumentNAPI> | DocumentNAPI | VerifiedTokenGroupActionWithDocumentNAPI | VerifiedTokenGroupActionWithTokenBalanceNAPI | VerifiedTokenGroupActionWithTokenIdentityInfoNAPI | VerifiedTokenGroupActionWithTokenPricingScheduleNAPI | VoteNAPI | Array<PlatformAddressInfoNAPI> | VerifiedIdentityFullWithAddressInfosNAPI | VerifiedIdentityWithAddressInfosNAPI | StoredAssetLockInfoNAPI | Array<[Uint8Array, boolean]> | [Array<[Uint8Array, boolean]>, Array<PlatformAddressInfoNAPI>] | [Array<[Uint8Array, boolean]>, Array<VerifiedDocumentNAPI>] | [StoredAssetLockInfoNAPI, Array<PlatformAddressInfoNAPI>] | [IdentityNAPI, Array<[Uint8Array, boolean]>];
+    /**
+     * Whether the proof binds the execution of this specific state transition.
+     * When false the result is a height-pinned snapshot of the affected state,
+     * not evidence that the transition executed.
+     */
+    get isExecutionProved(): boolean;
 }
 export declare class VerifiedTokenBalancesForIdentitiesNAPI {
     rootHash: Uint8Array;
@@ -1515,7 +2334,7 @@ export declare class WitnessNAPI {
     clear(): void;
     push(newElement: Uint8Array): void;
 }
-export declare const enum ActionGoalNAPI {
+export declare enum ActionGoalNAPI {
     ActionCompletion = 0,
     ActionParticipation = 1
 }
@@ -1526,11 +2345,11 @@ export interface AddressWitnessP2shNAPI {
     signatures: Array<Array<number>>;
     redeemScript: Uint8Array;
 }
-export declare const enum AssetLockProofTypeNAPI {
+export declare enum AssetLockProofTypeNAPI {
     Instant = 0,
     Chain = 1
 }
-export declare const enum BatchTypeNAPI {
+export declare enum BatchTypeNAPI {
     Create = 0,
     Replace = 1,
     Delete = 2,
@@ -1618,12 +2437,12 @@ export interface DistributionStepwiseStepNAPI {
     step: BigIntString;
     amount: BigIntString;
 }
-export declare const enum GasFeesPaidByNAPI {
+export declare enum GasFeesPaidByNAPI {
     DocumentOwner = 0,
     ContractOwner = 1,
     PreferContractOwner = 2
 }
-export declare const enum GroupActionStatusNAPI {
+export declare enum GroupActionStatusNAPI {
     ActionActive = 0,
     ActionClosed = 1
 }
@@ -1633,21 +2452,27 @@ export interface InstantAssetLockProofRAW {
     transaction: Uint8Array;
     outputIndex: number;
 }
-export declare const enum KeyTypeNAPI {
+export declare enum KeyTypeNAPI {
     ECDSA_SECP256K1 = 0,
     BLS12_381 = 1,
     ECDSA_HASH160 = 2,
     BIP13_SCRIPT_HASH = 3,
     EDDSA_25519_HASH160 = 4
 }
-export declare const enum NetworkNAPI {
+export declare enum NetworkNAPI {
     Mainnet = 0,
     Testnet = 1,
     Devnet = 2,
     Regtest = 3
 }
+/**
+ * Derives the sender's Orchard outgoing viewing key (External scope, 32 bytes)
+ * from a BIP-39 seed via ZIP-32 — the value to pass as `sender_ovk` to
+ * `shieldFromAssetLock` so the sender can later recover its own send.
+ */
+export declare function orchardOvkFromSeed(seed: Uint8Array, coinType: number, account: number): Uint8Array;
 export type PlatformAddressLikeNAPI = PlatformAddressNAPI | DynamicValue;
-export declare const enum PlatformVersionNAPI {
+export declare enum PlatformVersionNAPI {
     PLATFORM_V1 = 1,
     PLATFORM_V2 = 2,
     PLATFORM_V3 = 3,
@@ -1658,14 +2483,16 @@ export declare const enum PlatformVersionNAPI {
     PLATFORM_V8 = 8,
     PLATFORM_V9 = 9,
     PLATFORM_V10 = 10,
-    PLATFORM_V11 = 11
+    PLATFORM_V11 = 11,
+    PLATFORM_V12 = 12,
+    PLATFORM_V13 = 13
 }
-export declare const enum PoolingNAPI {
+export declare enum PoolingNAPI {
     Never = 0,
     IfAvailable = 1,
     Standard = 2
 }
-export declare const enum PurposeNAPI {
+export declare enum PurposeNAPI {
     AUTHENTICATION = 0,
     ENCRYPTION = 1,
     DECRYPTION = 2,
@@ -1674,7 +2501,28 @@ export declare const enum PurposeNAPI {
     VOTING = 5,
     OWNER = 6
 }
-export declare const enum SecurityLevelNAPI {
+/**
+ * Recovers your own notes from a list of shielded actions by trial-decrypting
+ * each action's `encrypted_note` with the incoming viewing key derived from
+ * `seed` via ZIP-32 (`m/32'/coin_type'/account'`, External scope).
+ *
+ * Only actions addressed to you decrypt; the rest are skipped. Each returned
+ * entry carries the action `index` (use it as the leaf position when building
+ * the spend witness) and the recovered [`NoteNAPI`] (value, rho, rseed,
+ * address) — everything needed to spend it.
+ */
+export declare function recoverNotes(jsActions: Array<SerializedActionNAPI>, jsSeed: Uint8Array, jsCoinType: number, jsAccount: number): Array<RecoveredNoteNAPI>;
+/**
+ * The scope of an Orchard viewing key or address (ZIP-32).
+ *
+ * `External` addresses are the ones you hand out to receive funds; `Internal`
+ * is the wallet's own scope, used for change and note management.
+ */
+export declare enum ScopeNAPI {
+    External = 0,
+    Internal = 1
+}
+export declare enum SecurityLevelNAPI {
     MASTER = 0,
     CRITICAL = 1,
     HIGH = 2,
@@ -1685,19 +2533,31 @@ export interface TokenConfigurationLocalizationJsonNAPI {
     singularForm: string;
     pluralForm: string;
 }
-export declare const enum TokenDistributionTypeNAPI {
+export declare enum TokenDistributionTypeNAPI {
     PreProgrammed = 0,
     Perpetual = 1
 }
-export declare const enum TokenEmergencyActionNAPI {
+export declare enum TokenEmergencyActionNAPI {
     Pause = 0,
     Resume = 1
 }
+/**
+ * Verifies a branch chunk proof for the address funds tree.
+ *
+ * `expectedRootHash` must be the `hash` the parent trunk/branch proof reported
+ * for `key`; without it the branch is unanchored and proves nothing.
+ *
+ * `depth` is validated upstream against an allowed range, so take it from the
+ * parent trunk's `chunkDepths` rather than picking a value.
+ */
+export declare function verifyAddressesBranchState(proof: Uint8Array, key: Uint8Array, depth: number, expectedRootHash: Uint8Array, jsPlatformVersion: DynamicValue): VerifiedAddressesBranchStateNAPI;
 export declare function verifyAddressesInfos(proof: Uint8Array, jsPlatformAddresses: Array<PlatformAddressLikeNAPI>, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedPlatformAddressesInfosNAPI;
+export declare function verifyAddressesTrunkState(proof: Uint8Array, jsPlatformVersion: DynamicValue): VerifiedAddressesTrunkStateNAPI;
 export declare function verifyAddressInfo(proof: Uint8Array, jsPlatformAddress: PlatformAddressLikeNAPI, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedPlatformAddressInfoNAPI;
 export declare function verifyContractProof(proof: Uint8Array, contractKnownKeepsHistory: boolean | undefined | null, isProofSubset: boolean, inMultipleContractProofForm: boolean, jsContractId: IdentifierLikeNAPI, jsPlatformVersion: DynamicValue): VerifiedContractNAPI;
 export declare function verifyDocumentsProof(proof: Uint8Array, contract: DataContractNAPI, documentTypeName: string, jsWhereClauses: DynamicValue, jsOrderBy: Array<Array<string>>, limit: number | undefined | null, jsStartAt: IdentifierLikeNAPI | undefined | null, startAtIncluded: boolean, blockTimeMs: BigIntString | undefined | null, jsPlatformVersion: DynamicValue): VerifiedDocumentsNAPI;
 export declare function verifyEpochsInfoProof(proof: Uint8Array, currentEpoch: number, startEpoch: number | undefined | null, count: number, ascending: boolean, jsPlatformVersion: DynamicValue): VerifiedEpochsInfoNAPI;
+export declare function verifyFinalizedEpochInfosProof(proof: Uint8Array, startEpochIndex: number, startEpochIndexIncluded: boolean, endEpochIndex: number, endEpochIndexIncluded: boolean, jsPlatformVersion: DynamicValue): VerifiedFinlizedEpochInfosNAPI;
 export declare function verifyIdentifierByNonUniquePublicKeyHashProof(proof: Uint8Array, isProofSubset: boolean, jsPublicKeyHash: Uint8Array, jsAfter: IdentifierLikeNAPI | undefined | null, jsPlatformVersion: DynamicValue): VerifiedIdentifierByNonUniquePublicKeyHashNAPI;
 export declare function verifyIdentityBalanceProof(proof: Uint8Array, jsIdentityId: IdentifierLikeNAPI, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedIdentityBalanceRootHashNAPI;
 export declare function verifyIdentityByIdentifierProof(proof: Uint8Array, jsIdentityId: IdentifierLikeNAPI, isProofSubset: boolean, jsPlatformVersion: DynamicValue): VerifiedIdentityByIdentifierNAPI;
@@ -1705,6 +2565,31 @@ export declare function verifyIdentityByUniqueKeyHashProof(proof: Uint8Array, js
 export declare function verifyIdentityContractNonceProof(proof: Uint8Array, jsIdentityId: IdentifierLikeNAPI, jsContractId: IdentifierLikeNAPI, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedIdentityContractNonceNAPI;
 export declare function verifyIdentityKeysByIdentifierProof(proof: Uint8Array, jsIdentityId: IdentifierLikeNAPI, specificKeyIds: Array<number> | undefined | null, withRevision: boolean, withBalance: boolean, isProofSubset: boolean, limit: number | undefined | null, offset: number | undefined | null, jsPlatformVersion: DynamicValue): VerifiedIdentityKeysByIdentifierNAPI;
 export declare function verifyIdentityNonceProof(proof: Uint8Array, jsIdentityId: IdentifierLikeNAPI, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedIdentityNonceNAPI;
+export declare function verifyMostRecentShieldedAnchorProof(proof: Uint8Array, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedMostRecentShieldedAnchorNAPI;
+/**
+ * Verifies a proof of the address balance changes from a block height onwards.
+ *
+ * `startHeightExclusive` mirrors the request flag of the same name: when
+ * false the proof is a `RangeFrom` starting at `startBlockHeight`, when true a
+ * `RangeAfter` starting just past it. It must match what was asked for, since
+ * the two produce different queries and so different proofs.
+ */
+export declare function verifyRecentAddressBalanceChanges(proof: Uint8Array, startBlockHeight: BigIntString, startHeightExclusive: boolean, limit: number | undefined | null, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedRecentAddressBalanceChangesNAPI;
+/**
+ * Verifies a proof of the compacted address balance changes from a block
+ * height onwards.
+ *
+ * Unlike the uncompacted query there is no subset flag: the proof is a
+ * self-contained envelope whose predecessor half authenticates which range
+ * covers the requested height, so the forward half has nothing to be a subset
+ * of.
+ */
+export declare function verifyRecentCompactedAddressBalanceChanges(proof: Uint8Array, startBlockHeight: BigIntString, limit: number | undefined | null, jsPlatformVersion: DynamicValue): VerifiedRecentCompactedAddressBalanceChangesNAPI;
+export declare function verifyShieldedAnchorsProof(proof: Uint8Array, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedShieldedAnchorsNAPI;
+export declare function verifyShieldedEncryptedNotesProof(proof: Uint8Array, startIndex: BigIntString, count: number, maxElements: number, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedShieldedEncryptedNotesNAPI;
+export declare function verifyShieldedNotesCountProof(proof: Uint8Array, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedShieldedNotesCountNAPI;
+export declare function verifyShieldedNullifiersProof(proof: Uint8Array, nullifiers: Array<Uint8Array>, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedShieldedNullifiersNAPI;
+export declare function verifyShieldedPoolStateProof(proof: Uint8Array, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedShieldedPoolStateNAPI;
 export declare function verifySignatureDigest(signDigest: Uint8Array, signature: Uint8Array, pubkeyBytes: Uint8Array): boolean;
 export declare function verifyStateTransitionResult(proof: Uint8Array, stateTransition: StateTransitionNAPI, blockInfo: BlockInfoNAPI, jsKnownContractsArray: Array<DataContractNAPI>, jsPlatformVersion: DynamicValue): VerifiedStateTransitionResultNAPI;
 export declare function verifyTokenBalancesForIdentitiesProof(proof: Uint8Array, jsTokenId: IdentifierLikeNAPI, isProofSubset: boolean, jsIdentities: Array<IdentifierLikeNAPI>, jsPlatformVersion: DynamicValue): VerifiedTokenBalancesForIdentitiesNAPI;
@@ -1714,7 +2599,7 @@ export declare function verifyTokensBalancesForIdentityProof(proof: Uint8Array,
 export declare function verifyTokenTotalSupplyProof(proof: Uint8Array, jsTokenId: IdentifierLikeNAPI, verifySubsetOfProof: boolean, jsPlatformVersion: DynamicValue): VerifiedTokenTotalSupplyNAPI;
 export declare function verifyTotalCreditsProof(proof: Uint8Array, coreSubsidyHalvingInterval: number, activationCoreHeight: number, currentCoreHeight: number, jsPlatformVersion: DynamicValue): VerifiedTotalCreditsNAPI;
 export declare function verifyVotePollVoteStateProof(proof: Uint8Array, contract: DataContractNAPI, documentTypeName: string, indexName: string, jsIndexValues: Array<Uint8Array>, jsResultType: DynamicValue, allowIncludeLockedAndAbstainingVoteTally: boolean, count: number | undefined | null, jsStartAt: DynamicValue, jsPlatformVersion: DynamicValue): VerifiedVoteStateNAPI;
-export declare const enum VoteStateResultTypeNAPI {
+export declare enum VoteStateResultTypeNAPI {
     DOCUMENTS = 0,
     VOTE_TALLY = 1,
     DOCUMENTS_AND_VOTE_TALLY = 2