pshenmic-dpp 2.0.0-dev.9 → 2.0.0

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

@@ -79,6 +79,9 @@ export class StateTransitionWASM {
     getSignableBytes() {
         return this._rawStateTransition.getSignableBytes();
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawStateTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawStateTransition.bytes();
     }

package/dist/src/dpp/types.d.ts

@@ -1,5 +1,5 @@
 import type * as protocol from '../../binaries/bindingsTypes.js';
-import { ActionGoal, AssetLockProofType, GasFeesPaidByWASM, KeyType, NetworkWASM, PlatformVersionWASM, PoolingWASM, Purpose, SecurityLevel, TokenDistributionType, TokenEmergencyActionWASM, VoteStateResultType } from './enums.js';
+import { ActionGoal, AssetLockProofType, GasFeesPaidByWASM, KeyType, NetworkWASM, PlatformVersionWASM, PoolingWASM, Purpose, ScopeWASM, SecurityLevel, TokenDistributionType, TokenEmergencyActionWASM, VoteStateResultType } from './enums.js';
 import { IdentifierWASM } from './structs/Identifier.js';
 import { languageCodes } from './constants.js';
 import { DistributionFunctionWASM } from './structs/TokenConfiguration/DistributionFunction.js';
@@ -44,6 +44,7 @@ export type TokenEmergencyActionLike = TokenEmergencyActionWASM | keyof typeof T
 export type AssetLockProofTypeLike = AssetLockProofType | keyof typeof AssetLockProofType | Lowercase<keyof typeof AssetLockProofType>;
 export type PoolingLike = PoolingWASM | keyof typeof PoolingWASM | Lowercase<keyof typeof PoolingWASM>;
 export type VoteStateResultTypeLike = VoteStateResultType | keyof typeof VoteStateResultType | Lowercase<keyof typeof VoteStateResultType>;
+export type ScopeLike = ScopeWASM | keyof typeof ScopeWASM | Lowercase<keyof typeof ScopeWASM>;
 export type AddressWitnessP2PKH = protocol.AddressWitnessP2pkhNAPI;
 export type AddressWitnessP2SH = protocol.AddressWitnessP2shNAPI;
 export type TokenConfigurationLocalizationJson = protocol.TokenConfigurationLocalizationJsonNAPI;
@@ -84,10 +85,32 @@ export interface ExtendedEpochInfo {
     feeMultiplierPermille: bigint;
     protocolVersion: number;
 }
+export interface FinalizedEpochInfo {
+    epochIndex: number;
+    firstBlockTime: Date;
+    firstBlockHeight: bigint;
+    totalBlocksInEpoch: bigint;
+    firstCoreBlockHeight: number;
+    nextEpochStartCoreBlockHeight: number;
+    totalProcessingFees: bigint;
+    totalDistributedStorageFees: bigint;
+    totalCreatedStorageFees: bigint;
+    coreBlockRewards: bigint;
+    blockProposers: {
+        proposer: IdentifierWASM;
+        count: bigint;
+    }[];
+    feeMultiplierPermille: bigint;
+    protocolVersion: number;
+}
 export interface VerifiedEpochsInfo {
     rootHash: Uint8Array;
     epochsInfo: ExtendedEpochInfo[];
 }
+export interface VerifiedFinalizedEpochsInfo {
+    rootHash: Uint8Array;
+    epochInfos: FinalizedEpochInfo[];
+}
 export interface VerifiedTotalCredits {
     rootHash: Uint8Array;
     totalCredits: bigint;
@@ -195,11 +218,45 @@ export interface VerifiedIdentityWithAddressInfos {
     identity: PartialIdentityWASM;
     infos: VerifiedPlatformAddressInfo[];
 }
-export type VerifiedStateTransitionResultVariants = DataContractWASM | IdentityWASM | IdentifierWASM | VerifiedIdentityBalance | VerifiedIdentityTokenInfo | VerifiedTokenPricingSchedule | TokenStatus | VerifiedIdentityBalance[] | PartialIdentityWASM | VerifiedBalanceTransfer | VerifiedDocument[] | DocumentWASM | VerifiedTokenGroupActionWithDocument | VerifiedTokenGroupActionWithTokenBalance | VerifiedTokenGroupActionWithTokenIdentityInfo | VerifiedTokenGroupActionWithTokenPricingSchedule | VoteWASM | VerifiedPlatformAddressInfo[] | VerifiedIdentityFullWithAddressInfos | VerifiedIdentityWithAddressInfos;
-export type VerifiedStateTransitionResultVariantsRAW = protocol.DataContractNAPI | protocol.IdentityNAPI | protocol.IdentifierNAPI | protocol.VerifiedIdentityBalanceNAPI | protocol.VerifiedIdentityTokenInfoNAPI | protocol.VerifiedTokenPricingScheduleNAPI | protocol.TokenStatusNAPI | protocol.VerifiedIdentityBalanceNAPI[] | protocol.PartialIdentityNAPI | protocol.VerifiedBalanceTransferNAPI | protocol.VerifiedDocumentNAPI[] | protocol.DocumentNAPI | protocol.VerifiedTokenGroupActionWithDocumentNAPI | protocol.VerifiedTokenGroupActionWithTokenBalanceNAPI | protocol.VerifiedTokenGroupActionWithTokenIdentityInfoNAPI | protocol.VerifiedTokenGroupActionWithTokenPricingScheduleNAPI | protocol.VoteNAPI | protocol.PlatformAddressInfoNAPI[] | protocol.VerifiedIdentityFullWithAddressInfosNAPI | protocol.VerifiedIdentityWithAddressInfosNAPI;
+export interface AssetLockValue {
+    initialCreditValue: bigint;
+    txOutScript: Uint8Array;
+    remainingCreditValue: bigint;
+    usedTags: Uint8Array[];
+}
+export type StoredAssetLockInfoType = 'FullyConsumed' | 'PartiallyConsumed' | 'NotPresent';
+export interface StoredAssetLockInfo {
+    type: StoredAssetLockInfoType;
+    value?: AssetLockValue;
+}
+export type ShieldedNullifier = [Uint8Array, boolean];
+export interface VerifiedShieldedNullifiersWithAddressInfos {
+    nullifiers: ShieldedNullifier[];
+    infos: VerifiedPlatformAddressInfo[];
+}
+export interface VerifiedShieldedNullifiersWithWithdrawalDocument {
+    nullifiers: ShieldedNullifier[];
+    documents: VerifiedDocument[];
+}
+export interface VerifiedAssetLockConsumedWithAddressInfos {
+    storedAssetLockInfo: StoredAssetLockInfo;
+    infos: VerifiedPlatformAddressInfo[];
+}
+export interface VerifiedIdentityWithShieldedNullifiers {
+    identity: IdentityWASM;
+    nullifiers: ShieldedNullifier[];
+}
+export type VerifiedStateTransitionResultVariants = DataContractWASM | IdentityWASM | IdentifierWASM | VerifiedIdentityBalance | VerifiedIdentityTokenInfo | VerifiedTokenPricingSchedule | TokenStatus | VerifiedIdentityBalance[] | PartialIdentityWASM | VerifiedBalanceTransfer | VerifiedDocument[] | DocumentWASM | VerifiedTokenGroupActionWithDocument | VerifiedTokenGroupActionWithTokenBalance | VerifiedTokenGroupActionWithTokenIdentityInfo | VerifiedTokenGroupActionWithTokenPricingSchedule | VoteWASM | VerifiedPlatformAddressInfo[] | VerifiedIdentityFullWithAddressInfos | VerifiedIdentityWithAddressInfos | StoredAssetLockInfo | ShieldedNullifier[] | VerifiedShieldedNullifiersWithAddressInfos | VerifiedShieldedNullifiersWithWithdrawalDocument | VerifiedAssetLockConsumedWithAddressInfos | VerifiedIdentityWithShieldedNullifiers;
+export type VerifiedStateTransitionResultVariantsRAW = protocol.DataContractNAPI | protocol.IdentityNAPI | protocol.IdentifierNAPI | protocol.VerifiedIdentityBalanceNAPI | protocol.VerifiedIdentityTokenInfoNAPI | protocol.VerifiedTokenPricingScheduleNAPI | protocol.TokenStatusNAPI | protocol.VerifiedIdentityBalanceNAPI[] | protocol.PartialIdentityNAPI | protocol.VerifiedBalanceTransferNAPI | protocol.VerifiedDocumentNAPI[] | protocol.DocumentNAPI | protocol.VerifiedTokenGroupActionWithDocumentNAPI | protocol.VerifiedTokenGroupActionWithTokenBalanceNAPI | protocol.VerifiedTokenGroupActionWithTokenIdentityInfoNAPI | protocol.VerifiedTokenGroupActionWithTokenPricingScheduleNAPI | protocol.VoteNAPI | protocol.PlatformAddressInfoNAPI[] | protocol.VerifiedIdentityFullWithAddressInfosNAPI | protocol.VerifiedIdentityWithAddressInfosNAPI | protocol.StoredAssetLockInfoNAPI | Array<[Uint8Array, boolean]> | [Array<[Uint8Array, boolean]>, protocol.PlatformAddressInfoNAPI[]] | [Array<[Uint8Array, boolean]>, protocol.VerifiedDocumentNAPI[]] | [protocol.StoredAssetLockInfoNAPI, protocol.PlatformAddressInfoNAPI[]] | [protocol.IdentityNAPI, Array<[Uint8Array, boolean]>];
 export interface VerifiedStateTransitionResult {
     rootHash: Uint8Array;
     result: VerifiedStateTransitionResultVariants;
+    /**
+     * Whether the proof binds the execution of this specific state transition.
+     * When false, the result is a height-pinned snapshot of the state the
+     * transition affects, not evidence that the transition executed.
+     */
+    isExecutionProved: boolean;
 }
 export type WhereOperator = '=' | '==' | '>' | '>=' | '<' | '<=' | 'Between' | 'between' | 'BetweenExcludeBounds' | 'betweenExcludeBounds' | 'betweenexcludebounds' | 'between_exclude_bounds' | 'BetweenExcludeLeft' | 'betweenExcludeLeft' | 'betweenexcludeleft' | 'between_exclude_left' | 'BetweenExcludeRight' | 'betweenExcludeRight' | 'betweenexcluderight' | 'between_exclude_right' | 'In' | 'in' | 'StartsWith' | 'startsWith' | 'startswith' | 'starts_with';
 export type WhereClause = [
@@ -282,3 +339,120 @@ export interface VerifiedPlatformAddressesInfosWithRootHash {
     rootHash: Uint8Array;
     infos: VerifiedPlatformAddressInfo[];
 }
+export interface VerifiedShieldedEncryptedNote {
+    cmx: Uint8Array;
+    nullifier: Uint8Array;
+    cvNet: Uint8Array;
+    encryptedNote: Uint8Array;
+}
+export interface VerifiedShieldedEncryptedNotes {
+    rootHash: Uint8Array;
+    notes: VerifiedShieldedEncryptedNote[];
+    totalCount: bigint;
+}
+export interface VerifiedShieldedAnchors {
+    rootHash: Uint8Array;
+    anchors: Uint8Array[];
+}
+export interface VerifiedMostRecentShieldedAnchor {
+    rootHash: Uint8Array;
+    anchor?: Uint8Array;
+}
+export interface VerifiedShieldedPoolState {
+    rootHash: Uint8Array;
+    totalBalance?: bigint;
+}
+export interface VerifiedShieldedNotesCount {
+    rootHash: Uint8Array;
+    count?: bigint;
+}
+export interface VerifiedShieldedNullifier {
+    nullifier: Uint8Array;
+    isSpent: boolean;
+}
+export interface VerifiedShieldedNullifiers {
+    rootHash: Uint8Array;
+    nullifiers: VerifiedShieldedNullifier[];
+}
+export type AddressBalanceOperation = 'setCredits' | 'addToCredits';
+export interface AddressBalanceChange {
+    address: PlatformAddressWASM;
+    /** `setCredits` means `credits` is the new balance, `addToCredits` means it is the delta. */
+    operation: AddressBalanceOperation;
+    credits: bigint;
+}
+export interface BlockAddressBalanceChanges {
+    blockHeight: bigint;
+    changes: AddressBalanceChange[];
+}
+export interface VerifiedRecentAddressBalanceChanges {
+    rootHash: Uint8Array;
+    blocks: BlockAddressBalanceChanges[];
+}
+export type CompactedAddressBalanceOperation = 'setCredits' | 'addToCreditsOperations';
+export interface BlockHeightCredit {
+    blockHeight: bigint;
+    credits: bigint;
+}
+export interface CompactedAddressBalanceChange {
+    address: PlatformAddressWASM;
+    operation: CompactedAddressBalanceOperation;
+    /** Populated when `operation` is `setCredits`. */
+    setCredits?: bigint;
+    /** Populated when `operation` is `addToCreditsOperations`, otherwise empty. */
+    addToCreditsOperations: BlockHeightCredit[];
+}
+export interface CompactedBlockAddressBalanceChanges {
+    startBlockHeight: bigint;
+    endBlockHeight: bigint;
+    changes: CompactedAddressBalanceChange[];
+}
+export interface VerifiedRecentCompactedAddressBalanceChanges {
+    rootHash: Uint8Array;
+    ranges: CompactedBlockAddressBalanceChanges[];
+}
+export type GroveElementType = 'Item' | 'ItemWithSumItem' | 'SumItem' | 'Reference' | 'ReferenceWithSumItem' | 'Tree' | 'SumTree' | 'BigSumTree' | 'ProvableSumTree' | 'CountTree' | 'ProvableCountTree' | 'CountSumTree' | 'ProvableCountSumTree' | 'ProvableCountProvableSumTree' | 'CommitmentTree' | 'MmrTree' | 'BulkAppendTree' | 'DenseAppendOnlyFixedSizeTree';
+export type GroveElementWrapper = 'NonCounted' | 'NotSummed' | 'NotCountedOrSummed';
+export interface GroveElement {
+    type: GroveElementType;
+    /** Set when the element opts out of its parent's aggregates; `type` still describes the wrapped element. */
+    wrapper?: GroveElementWrapper;
+    /** An item's payload, or a subtree's root key. Absent for empty subtrees. */
+    value?: Uint8Array;
+    sum?: bigint;
+    count?: bigint;
+}
+export interface GroveElementEntry {
+    key: Uint8Array;
+    element: GroveElement;
+}
+export interface GroveLeafInfo {
+    key: Uint8Array;
+    /** Pass as `expectedRootHash` when verifying this key's branch proof. */
+    hash: Uint8Array;
+    count?: bigint;
+}
+export interface GroveAncestor {
+    levelsUp: number;
+    count: bigint;
+    key: Uint8Array;
+    hash: Uint8Array;
+}
+export interface VerifiedAddressesTrunkState {
+    rootHash: Uint8Array;
+    elements: GroveElementEntry[];
+    /** Subtrees the trunk stops at. Empty when the whole tree fit in the trunk. */
+    leafKeys: GroveLeafInfo[];
+    chunkDepths: number[];
+    maxTreeDepth: number;
+    /** Which truncated subtree would hold `key`, or undefined if it is already in `elements`. */
+    traceKeyToLeaf: (key: Uint8Array) => GroveLeafInfo | undefined;
+    getAncestor: (leafKey: Uint8Array, minPrivacyTreeCount: bigint) => GroveAncestor | undefined;
+}
+export interface VerifiedAddressesBranchState {
+    elements: GroveElementEntry[];
+    leafKeys: GroveLeafInfo[];
+    branchRootHash: Uint8Array;
+    traceKeyToLeaf: (key: Uint8Array) => GroveLeafInfo | undefined;
+    getAncestor: (leafKey: Uint8Array, minPrivacyTreeCount: bigint) => GroveAncestor | undefined;
+}

package/dist/src/dpp/verify/AddressFunds/utils.d.ts

@@ -0,0 +1,5 @@
+import type * as protocol from '../../../../binaries/bindingsTypes.js';
+import { GroveAncestor, GroveElementEntry, GroveLeafInfo } from '../../types.js';
+export declare function mapGroveElementEntry(entry: protocol.GroveElementEntryNAPI): GroveElementEntry;
+export declare function mapGroveLeafInfo(info: protocol.GroveLeafInfoNAPI): GroveLeafInfo;
+export declare function mapGroveAncestor(ancestor: protocol.GroveAncestorNAPI): GroveAncestor;

package/dist/src/dpp/verify/AddressFunds/utils.js

@@ -0,0 +1,28 @@
+export function mapGroveElementEntry(entry) {
+    const { element } = entry;
+    return {
+        key: entry.key,
+        element: {
+            type: element.type,
+            wrapper: element.wrapper != null ? element.wrapper : undefined,
+            value: element.value ?? undefined,
+            sum: element.sum != null ? BigInt(element.sum) : undefined,
+            count: element.count != null ? BigInt(element.count) : undefined
+        }
+    };
+}
+export function mapGroveLeafInfo(info) {
+    return {
+        key: info.key,
+        hash: info.hash,
+        count: info.count != null ? BigInt(info.count) : undefined
+    };
+}
+export function mapGroveAncestor(ancestor) {
+    return {
+        levelsUp: ancestor.levelsUp,
+        count: BigInt(ancestor.count),
+        key: ancestor.key,
+        hash: ancestor.hash
+    };
+}

package/dist/src/dpp/verify/AddressFunds/verifyAddressesBranchState.d.ts

@@ -0,0 +1,12 @@
+import { PlatformVersionLike, VerifiedAddressesBranchState } from '../../types.js';
+/**
+ * Verifies a branch chunk proof for the address funds tree.
+ *
+ * `expectedRootHash` must be the `hash` the parent trunk or branch reported for
+ * `key`; it is what anchors this subtree to the proven root, so the result
+ * carries no root hash of its own.
+ *
+ * `depth` is validated 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, platformVersion: PlatformVersionLike): VerifiedAddressesBranchState;

package/dist/src/dpp/verify/AddressFunds/verifyAddressesBranchState.js

@@ -0,0 +1,29 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { mapGroveAncestor, mapGroveElementEntry, mapGroveLeafInfo } from './utils.js';
+/**
+ * Verifies a branch chunk proof for the address funds tree.
+ *
+ * `expectedRootHash` must be the `hash` the parent trunk or branch reported for
+ * `key`; it is what anchors this subtree to the proven root, so the result
+ * carries no root hash of its own.
+ *
+ * `depth` is validated against an allowed range, so take it from the parent
+ * trunk's `chunkDepths` rather than picking a value.
+ */
+export function verifyAddressesBranchState(proof, key, depth, expectedRootHash, platformVersion) {
+    const result = dppProvider.dpp.verifyAddressesBranchState(proof, key, depth, expectedRootHash, valueToDynamicValue(platformVersion));
+    return {
+        elements: result.elements.map(mapGroveElementEntry),
+        leafKeys: result.leafKeys.map(mapGroveLeafInfo),
+        branchRootHash: result.branchRootHash,
+        traceKeyToLeaf: (traced) => {
+            const leaf = result.traceKeyToLeaf(traced);
+            return leaf != null ? mapGroveLeafInfo(leaf) : undefined;
+        },
+        getAncestor: (leafKey, minPrivacyTreeCount) => {
+            const ancestor = result.getAncestor(leafKey, minPrivacyTreeCount.toString());
+            return ancestor != null ? mapGroveAncestor(ancestor) : undefined;
+        }
+    };
+}

package/dist/src/dpp/verify/AddressFunds/verifyAddressesTrunkState.d.ts

@@ -0,0 +1,9 @@
+import { PlatformVersionLike, VerifiedAddressesTrunkState } from '../../types.js';
+/**
+ * Verifies a trunk chunk proof for the address funds tree.
+ *
+ * The trunk covers the top of the tree only. Subtrees below it are truncated
+ * and listed in `leafKeys`; use `traceKeyToLeaf` to find which one holds an
+ * address, then fetch it with `verifyAddressesBranchState`.
+ */
+export declare function verifyAddressesTrunkState(proof: Uint8Array, platformVersion: PlatformVersionLike): VerifiedAddressesTrunkState;

package/dist/src/dpp/verify/AddressFunds/verifyAddressesTrunkState.js

@@ -0,0 +1,30 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { mapGroveAncestor, mapGroveElementEntry, mapGroveLeafInfo } from './utils.js';
+/**
+ * Verifies a trunk chunk proof for the address funds tree.
+ *
+ * The trunk covers the top of the tree only. Subtrees below it are truncated
+ * and listed in `leafKeys`; use `traceKeyToLeaf` to find which one holds an
+ * address, then fetch it with `verifyAddressesBranchState`.
+ */
+export function verifyAddressesTrunkState(proof, platformVersion) {
+    const result = dppProvider.dpp.verifyAddressesTrunkState(proof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        elements: result.elements.map(mapGroveElementEntry),
+        leafKeys: result.leafKeys.map(mapGroveLeafInfo),
+        chunkDepths: result.chunkDepths,
+        maxTreeDepth: result.maxTreeDepth,
+        // These close over the verified result because tracing walks the proof's
+        // reconstructed tree, which is not projected into plain data.
+        traceKeyToLeaf: (key) => {
+            const leaf = result.traceKeyToLeaf(key);
+            return leaf != null ? mapGroveLeafInfo(leaf) : undefined;
+        },
+        getAncestor: (leafKey, minPrivacyTreeCount) => {
+            const ancestor = result.getAncestor(leafKey, minPrivacyTreeCount.toString());
+            return ancestor != null ? mapGroveAncestor(ancestor) : undefined;
+        }
+    };
+}

package/dist/src/dpp/verify/AddressFunds/verifyRecentAddressBalanceChanges.d.ts

@@ -0,0 +1,9 @@
+import { PlatformVersionLike, VerifiedRecentAddressBalanceChanges } from '../../types.js';
+/**
+ * Verifies a proof of the address balance changes from a block height onwards.
+ *
+ * `startHeightExclusive` must match the flag the proof was requested with: it
+ * selects a range starting just past `startBlockHeight` rather than at it, and
+ * the two produce different queries, so a mismatch fails verification.
+ */
+export declare function verifyRecentAddressBalanceChanges(proof: Uint8Array, startBlockHeight: bigint, startHeightExclusive: boolean, limit: number | undefined, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedRecentAddressBalanceChanges;

package/dist/src/dpp/verify/AddressFunds/verifyRecentAddressBalanceChanges.js

@@ -0,0 +1,24 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { PlatformAddressWASM } from '../../structs/PlatformAddress/PlatformAddress.js';
+/**
+ * Verifies a proof of the address balance changes from a block height onwards.
+ *
+ * `startHeightExclusive` must match the flag the proof was requested with: it
+ * selects a range starting just past `startBlockHeight` rather than at it, and
+ * the two produce different queries, so a mismatch fails verification.
+ */
+export function verifyRecentAddressBalanceChanges(proof, startBlockHeight, startHeightExclusive, limit, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyRecentAddressBalanceChanges(proof, startBlockHeight.toString(), startHeightExclusive, limit, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        blocks: result.blocks.map((block) => ({
+            blockHeight: BigInt(block.blockHeight),
+            changes: block.changes.map((change) => ({
+                address: PlatformAddressWASM.createFromRawInstance(change.address),
+                operation: change.operation,
+                credits: BigInt(change.credits)
+            }))
+        }))
+    };
+}

package/dist/src/dpp/verify/AddressFunds/verifyRecentCompactedAddressBalanceChanges.d.ts

@@ -0,0 +1,10 @@
+import { PlatformVersionLike, VerifiedRecentCompactedAddressBalanceChanges } from '../../types.js';
+/**
+ * Verifies a proof of the compacted address balance changes from a block height
+ * onwards, where each entry merges a range of blocks.
+ *
+ * There is no subset flag here: 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: bigint, limit: number | undefined, platformVersion: PlatformVersionLike): VerifiedRecentCompactedAddressBalanceChanges;

package/dist/src/dpp/verify/AddressFunds/verifyRecentCompactedAddressBalanceChanges.js

@@ -0,0 +1,30 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { PlatformAddressWASM } from '../../structs/PlatformAddress/PlatformAddress.js';
+/**
+ * Verifies a proof of the compacted address balance changes from a block height
+ * onwards, where each entry merges a range of blocks.
+ *
+ * There is no subset flag here: 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 function verifyRecentCompactedAddressBalanceChanges(proof, startBlockHeight, limit, platformVersion) {
+    const result = dppProvider.dpp.verifyRecentCompactedAddressBalanceChanges(proof, startBlockHeight.toString(), limit, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        ranges: result.ranges.map((range) => ({
+            startBlockHeight: BigInt(range.startBlockHeight),
+            endBlockHeight: BigInt(range.endBlockHeight),
+            changes: range.changes.map((change) => ({
+                address: PlatformAddressWASM.createFromRawInstance(change.address),
+                operation: change.operation,
+                setCredits: change.setCredits != null ? BigInt(change.setCredits) : undefined,
+                addToCreditsOperations: change.addToCreditsOperations.map((operation) => ({
+                    blockHeight: BigInt(operation.blockHeight),
+                    credits: BigInt(operation.credits)
+                }))
+            }))
+        }))
+    };
+}

package/dist/src/dpp/verify/Contested/verifyVotePollVoteStateProof.d.ts

@@ -1,3 +1,3 @@
 import { PlatformVersionLike, StartAt, VerifiedVoteState, VoteStateResultTypeLike } from '../../types.js';
 import { DataContractWASM } from '../../structs/DataContract.js';
-export declare function verifyVotePollVoteStateProof(proof: Uint8Array, contract: DataContractWASM, documentTypeName: string, indexName: string, indexValues: Uint8Array[], resultType: VoteStateResultTypeLike, allowIncludeLockedAndAbstainingVoteTally: boolean, count: number | undefined, startAt: StartAt | undefined, platformVersion: PlatformVersionLike): VerifiedVoteState;
+export declare function verifyVotePollVoteStateProof(proof: Uint8Array, contract: DataContractWASM, documentTypeName: string, indexName: string, indexValues: Uint8Array[], resultType: VoteStateResultTypeLike, allowIncludeLockedAndAbstainingVoteTally: boolean | undefined, count: number | undefined, startAt: StartAt | undefined, platformVersion: PlatformVersionLike): VerifiedVoteState;

package/dist/src/dpp/verify/Contested/verifyVotePollVoteStateProof.js

@@ -2,7 +2,7 @@ import { dppProvider } from '../../provider.js';
 import { valueFromDynamicValue, valueToDynamicValue } from '../../utils.js';
 import { IdentifierWASM } from '../../structs/Identifier.js';
 export function verifyVotePollVoteStateProof(proof, contract, documentTypeName, indexName, indexValues, resultType, allowIncludeLockedAndAbstainingVoteTally, count, startAt, platformVersion) {
-    const result = dppProvider.dpp.verifyVotePollVoteStateProof(proof, contract._rawDataContract, documentTypeName, indexName, indexValues, valueToDynamicValue(resultType), allowIncludeLockedAndAbstainingVoteTally ?? true, count, valueToDynamicValue(startAt), valueToDynamicValue(platformVersion));
+    const result = dppProvider.dpp.verifyVotePollVoteStateProof(proof, contract._rawDataContract, documentTypeName, indexName, indexValues, valueToDynamicValue(resultType), allowIncludeLockedAndAbstainingVoteTally ?? false, count, valueToDynamicValue(startAt), valueToDynamicValue(platformVersion));
     const winner = valueFromDynamicValue(result.result.winner);
     const winnerBlockInfo = winner?.blockInfo;
     const outWinner = winner != null

package/dist/src/dpp/verify/Shielded/verifyMostRecentShieldedAnchorProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedMostRecentShieldedAnchor } from '../../types.js';
+export declare function verifyMostRecentShieldedAnchorProof(proof: Uint8Array, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedMostRecentShieldedAnchor;

package/dist/src/dpp/verify/Shielded/verifyMostRecentShieldedAnchorProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyMostRecentShieldedAnchorProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyMostRecentShieldedAnchorProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        anchor: result.anchor ?? undefined
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedAnchorsProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedAnchors } from '../../types.js';
+export declare function verifyShieldedAnchorsProof(proof: Uint8Array, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedAnchors;

package/dist/src/dpp/verify/Shielded/verifyShieldedAnchorsProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedAnchorsProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedAnchorsProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        anchors: result.anchors
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedEncryptedNotesProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedEncryptedNotes } from '../../types.js';
+export declare function verifyShieldedEncryptedNotesProof(proof: Uint8Array, startIndex: bigint, count: number, maxElements: number, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedEncryptedNotes;

package/dist/src/dpp/verify/Shielded/verifyShieldedEncryptedNotesProof.js

@@ -0,0 +1,15 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedEncryptedNotesProof(proof, startIndex, count, maxElements, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedEncryptedNotesProof(proof, startIndex.toString(), count, maxElements, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        notes: result.notes.map((note) => ({
+            cmx: note.cmx,
+            nullifier: note.nullifier,
+            cvNet: note.cvNet,
+            encryptedNote: note.encryptedNote
+        })),
+        totalCount: BigInt(result.totalCount)
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedNotesCountProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedNotesCount } from '../../types.js';
+export declare function verifyShieldedNotesCountProof(proof: Uint8Array, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedNotesCount;

package/dist/src/dpp/verify/Shielded/verifyShieldedNotesCountProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedNotesCountProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedNotesCountProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        count: result.count != null ? BigInt(result.count) : undefined
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedNullifiersProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedNullifiers } from '../../types.js';
+export declare function verifyShieldedNullifiersProof(proof: Uint8Array, nullifiers: Uint8Array[], verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedNullifiers;

package/dist/src/dpp/verify/Shielded/verifyShieldedNullifiersProof.js

@@ -0,0 +1,12 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedNullifiersProof(proof, nullifiers, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedNullifiersProof(proof, nullifiers, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        nullifiers: result.nullifiers.map((nullifier) => ({
+            nullifier: nullifier.nullifier,
+            isSpent: nullifier.isSpent
+        }))
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedPoolStateProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedPoolState } from '../../types.js';
+export declare function verifyShieldedPoolStateProof(proof: Uint8Array, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedPoolState;

package/dist/src/dpp/verify/Shielded/verifyShieldedPoolStateProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedPoolStateProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedPoolStateProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        totalBalance: result.totalBalance != null ? BigInt(result.totalBalance) : undefined
+    };
+}