pshenmic-dpp 1.1.2-dev.8 → 2.0.0-dev.10

package/dist/src/dpp/structs/TokenConfiguration/TokenTradeMode.js

@@ -0,0 +1,17 @@
+import { dppProvider } from '../../provider.js';
+export class TokenTradeModeWASM {
+    /** @private **/
+    _rawTokenTradeMode;
+    constructor(rawInstance) {
+        this._rawTokenTradeMode = rawInstance;
+    }
+    getValue() {
+        return this._rawTokenTradeMode.getValue();
+    }
+    static NotTradeable() {
+        return TokenTradeModeWASM.createFromRawInstance(dppProvider.dpp.TokenTradeModeNAPI.NotTradeable());
+    }
+    static createFromRawInstance(rawInstance) {
+        return new TokenTradeModeWASM(rawInstance);
+    }
+}

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

@@ -0,0 +1,284 @@
+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 { IdentifierWASM } from './structs/Identifier.js';
+import { languageCodes } from './constants.js';
+import { DistributionFunctionWASM } from './structs/TokenConfiguration/DistributionFunction.js';
+import { TokenConfigurationWASM } from './structs/TokenConfiguration/TokenConfiguration.js';
+import { GroupWASM } from './structs/TokenConfiguration/Group.js';
+import { DocumentCreateTransitionWASM } from './structs/Batch/DocumentTransitions/DocumentCreateTransition.js';
+import { DocumentDeleteTransitionWASM } from './structs/Batch/DocumentTransitions/DocumentDeleteTransition.js';
+import { DocumentPurchaseTransitionWASM } from './structs/Batch/DocumentTransitions/DocumentPurchaseTransition.js';
+import { DocumentReplaceTransitionWASM } from './structs/Batch/DocumentTransitions/DocumentReplaceTransition.js';
+import { DocumentTransferTransitionWASM } from './structs/Batch/DocumentTransitions/DocumentTransferTransition.js';
+import { DocumentUpdatePriceTransitionWASM } from './structs/Batch/DocumentTransitions/DocumentUpdatePriceTransition.js';
+import { TokenConfigUpdateTransitionWASM } from './structs/Batch/TokenTransitions/TokenConfigUpdateTransition.js';
+import { TokenDirectPurchaseTransitionWASM } from './structs/Batch/TokenTransitions/TokenDirectPurchaseTransition.js';
+import { TokenSetPriceForDirectPurchaseTransitionWASM } from './structs/Batch/TokenTransitions/TokenSetPriceForDirectPurchaseTransition.js';
+import { TokenBurnTransitionWASM } from './structs/Batch/TokenTransitions/TokenBurnTransition.js';
+import { TokenClaimTransitionWASM } from './structs/Batch/TokenTransitions/TokenClaimTransition.js';
+import { TokenUnFreezeTransitionWASM } from './structs/Batch/TokenTransitions/TokenUnFreezeTransition.js';
+import { TokenTransferTransitionWASM } from './structs/Batch/TokenTransitions/TokenTransferTransition.js';
+import { TokenMintTransitionWASM } from './structs/Batch/TokenTransitions/TokenMintTransition.js';
+import { TokenFreezeTransitionWASM } from './structs/Batch/TokenTransitions/TokenFreezeTransition.js';
+import { TokenEmergencyActionTransitionWASM } from './structs/Batch/TokenTransitions/TokenEmergencyActionTransition.js';
+import { TokenDestroyFrozenFundsTransitionWASM } from './structs/Batch/TokenTransitions/TokenDestroyFrozenFundsTransition.js';
+import { DataContractWASM } from './structs/DataContract.js';
+import { IdentityWASM } from './structs/Identity.js';
+import { PartialIdentityWASM } from './structs/PartialIdentity.js';
+import { DocumentWASM } from './structs/Document.js';
+import { VoteWASM } from './structs/MasternodeVote/Vote.js';
+import { TokenPricingScheduleWASM } from './structs/Batch/TokenPricingSchedule.js';
+import { PlatformAddressWASM } from './structs/PlatformAddress/PlatformAddress.js';
+export type DashPlatformProtocol = typeof protocol;
+export type IdentifierLike = string | Uint8Array | protocol.IdentifierNAPI | IdentifierWASM;
+export type PlatformAddressLike = string | Uint8Array | protocol.PlatformAddressNAPI | PlatformAddressWASM;
+export type KeyTypeLike = KeyType | keyof typeof KeyType | Lowercase<keyof typeof KeyType>;
+export type NetworkLike = NetworkWASM | keyof typeof NetworkWASM | Lowercase<keyof typeof NetworkWASM>;
+export type SecurityLevelLike = SecurityLevel | keyof typeof SecurityLevel | Lowercase<keyof typeof SecurityLevel>;
+export type PlatformVersionLike = PlatformVersionWASM | Lowercase<keyof typeof PlatformVersionWASM>;
+export type PurposeLike = Purpose | keyof typeof Purpose | Lowercase<keyof typeof Purpose>;
+export type ActionGoalLike = ActionGoal | keyof typeof ActionGoal | Lowercase<keyof typeof ActionGoal>;
+export type GasFeesPaidByLike = GasFeesPaidByWASM | keyof typeof GasFeesPaidByWASM | Lowercase<keyof typeof GasFeesPaidByWASM>;
+export type TokenDistributionLike = TokenDistributionType | keyof typeof TokenDistributionType | Lowercase<keyof typeof TokenDistributionType>;
+export type TokenEmergencyActionLike = TokenEmergencyActionWASM | keyof typeof TokenEmergencyActionWASM | Lowercase<keyof typeof TokenEmergencyActionWASM>;
+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 AddressWitnessP2PKH = protocol.AddressWitnessP2pkhNAPI;
+export type AddressWitnessP2SH = protocol.AddressWitnessP2shNAPI;
+export type TokenConfigurationLocalizationJson = protocol.TokenConfigurationLocalizationJsonNAPI;
+export type DistributionFixedAmount = protocol.DistributionFixedAmountNAPI;
+export type DistributionRandom = protocol.DistributionRandomNAPI;
+export type DistributionStepDecreasingAmount = protocol.DistributionStepDecreasingAmountNAPI;
+export interface DistributionStepwiseStep {
+    step: bigint;
+    amount: bigint;
+}
+export type DistributionStepwise = DistributionStepwiseStep[];
+export type DistributionLinear = protocol.DistributionLinearNAPI;
+export type DistributionPolynomial = protocol.DistributionPolynomialNAPI;
+export type DistributionExponential = protocol.DistributionExponentialNAPI;
+export type DistributionLogarithmic = protocol.DistributionLogarithmicNAPI;
+export type DistributionInvertedLogarithmic = protocol.DistributionInvertedLogarithmicNAPI;
+export interface RewardDistribution {
+    interval: bigint | number;
+    function: DistributionFunctionWASM;
+    distributionType: 'BlockBasedDistribution' | 'TimeBasedDistribution' | 'EpochBasedDistribution';
+}
+export type ISO639_CODES = typeof languageCodes[number];
+export interface DataContractTokens {
+    position: number;
+    tokenConfiguration: TokenConfigurationWASM;
+}
+export interface DataContractGroups {
+    position: number;
+    group: GroupWASM;
+}
+export type DocumentTransitionLike = DocumentCreateTransitionWASM | DocumentDeleteTransitionWASM | DocumentPurchaseTransitionWASM | DocumentReplaceTransitionWASM | DocumentTransferTransitionWASM | DocumentUpdatePriceTransitionWASM;
+export type TokenTransitionLike = TokenConfigUpdateTransitionWASM | TokenDirectPurchaseTransitionWASM | TokenSetPriceForDirectPurchaseTransitionWASM | TokenBurnTransitionWASM | TokenClaimTransitionWASM | TokenDestroyFrozenFundsTransitionWASM | TokenEmergencyActionTransitionWASM | TokenFreezeTransitionWASM | TokenMintTransitionWASM | TokenTransferTransitionWASM | TokenUnFreezeTransitionWASM;
+export interface ExtendedEpochInfo {
+    index: number;
+    firstBlockTime: bigint;
+    firstBlockHeight: bigint;
+    firstCoreBlockHeight: number;
+    feeMultiplierPermille: bigint;
+    protocolVersion: number;
+}
+export interface VerifiedEpochsInfo {
+    rootHash: Uint8Array;
+    epochsInfo: ExtendedEpochInfo[];
+}
+export interface VerifiedTotalCredits {
+    rootHash: Uint8Array;
+    totalCredits: bigint;
+}
+export interface StartAt {
+    startIdentifier: IdentifierLike;
+    startIdentifierIncluded: boolean;
+}
+export type Winner = undefined | NoWinner | LockedWinner | WonByIdentityWinner;
+export type WinnerType = 'NoWinner' | 'Locked' | 'WonByIdentity';
+export interface NoWinner {
+    type: WinnerType;
+    blockInfo: BlockInfo;
+}
+export interface LockedWinner {
+    type: WinnerType;
+    blockInfo: BlockInfo;
+}
+export interface WonByIdentityWinner {
+    type: WinnerType;
+    identityId: Uint8Array;
+    blockInfo: BlockInfo;
+}
+export interface BlockInfo {
+    height: bigint;
+    coreHeight: number;
+    timeMs: bigint;
+    epoch?: number;
+}
+export interface ContenderWithSerializedDocument {
+    identityId: IdentifierWASM;
+    serializedDocument?: Uint8Array;
+    voteTally?: number;
+}
+export interface ContestedDocumentVotePollQueryExecutionResult {
+    contenders: ContenderWithSerializedDocument[];
+    lockedVoteTally?: number;
+    abstainingVoteTally?: number;
+    winner?: Winner;
+    skipped: number;
+}
+export interface VerifiedVoteState {
+    rootHash: Uint8Array;
+    result: ContestedDocumentVotePollQueryExecutionResult;
+}
+export interface VerifiedContract {
+    rootHash: Uint8Array;
+    dataContract?: DataContractWASM;
+}
+export interface IdentityTokenInfo {
+    frozen: boolean;
+}
+export interface TokenStatus {
+    paused: boolean;
+}
+export interface VerifiedIdentityBalance {
+    balance: bigint;
+    id: IdentifierWASM;
+}
+export interface VerifiedIdentityTokenInfo {
+    tokenId: IdentifierWASM;
+    identityTokenInfo: IdentityTokenInfo;
+}
+export interface VerifiedTokenPricingSchedule {
+    tokenId: IdentifierWASM;
+    pricingSchedule?: TokenPricingScheduleWASM;
+}
+export interface VerifiedBalanceTransfer {
+    sender: PartialIdentityWASM;
+    recipient: PartialIdentityWASM;
+}
+export interface VerifiedDocument {
+    id: IdentifierWASM;
+    document?: DocumentWASM;
+}
+export interface VerifiedTokenGroupActionWithDocument {
+    groupSumPower: number;
+    document?: DocumentWASM;
+}
+export interface VerifiedTokenGroupActionWithTokenBalance {
+    groupSumPower: number;
+    groupActionStatus: string;
+    amount?: bigint;
+}
+export interface VerifiedTokenGroupActionWithTokenIdentityInfo {
+    groupSumPower: number;
+    groupActionStatus: string;
+    identityTokenInfo?: IdentityTokenInfo;
+}
+export interface VerifiedTokenGroupActionWithTokenPricingSchedule {
+    groupSumPower: number;
+    groupActionStatus: string;
+    pricingSchedule?: TokenPricingScheduleWASM;
+}
+export interface VerifiedPlatformAddressInfo {
+    address?: PlatformAddressWASM;
+    nonce?: number;
+    balance?: bigint;
+}
+export interface VerifiedIdentityFullWithAddressInfos {
+    identity: IdentityWASM;
+    infos: VerifiedPlatformAddressInfo[];
+}
+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 VerifiedStateTransitionResult {
+    rootHash: Uint8Array;
+    result: VerifiedStateTransitionResultVariants;
+}
+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 = [
+    field: string,
+    operator: WhereOperator,
+    value: unknown
+];
+export interface VerifiedDocuments {
+    rootHash: Uint8Array;
+    documents: DocumentWASM[];
+}
+export interface VerifiedIdentifierByNonUniquePublicKeyHash {
+    rootHash: Uint8Array;
+    identifier?: IdentifierWASM;
+}
+export interface VerifiedIdentityBalanceRootHash {
+    rootHash: Uint8Array;
+    balance?: bigint;
+}
+export interface VerifiedIdentityByIdentifier {
+    rootHash: Uint8Array;
+    identity?: IdentityWASM;
+}
+export interface VerifiedIdentityByUniqueKeyHash {
+    rootHash: Uint8Array;
+    identity?: IdentityWASM;
+}
+export interface VerifiedIdentityContractNonce {
+    rootHash: Uint8Array;
+    contractNonce?: bigint;
+}
+export interface VerifiedIdentityKeysByIdentifier {
+    rootHash: Uint8Array;
+    identity?: PartialIdentityWASM;
+}
+export interface VerifiedIdentityNonce {
+    rootHash: Uint8Array;
+    nonce?: bigint;
+}
+export interface IdentityTokenBalance {
+    balance: bigint;
+    id: IdentifierWASM;
+}
+export interface IdentityTokenBalanceOptional {
+    balance?: bigint;
+    id: IdentifierWASM;
+}
+export interface VerifiedTokenBalancesForIdentities {
+    rootHash: Uint8Array;
+    balances: IdentityTokenBalanceOptional[];
+}
+export interface TokenContractInfo {
+    contractId: IdentifierWASM;
+    tokenContractPosition: number;
+}
+export interface VerifiedTokenContractInfo {
+    rootHash: Uint8Array;
+    contractInfo?: TokenContractInfo;
+}
+export interface VerifiedTokenDirectPurchasePrices {
+    rootHash: Uint8Array;
+    prices: VerifiedTokenPricingSchedule[];
+}
+export interface TotalSingleTokenBalance {
+    tokenSupply: bigint;
+    aggregatedTokenAccountBalances: bigint;
+}
+export interface VerifiedTokenTotalSupply {
+    rootHash: Uint8Array;
+    totalBalance: TotalSingleTokenBalance;
+}
+export interface VerifiedTokensBalancesForIdentity {
+    rootHash: Uint8Array;
+    balances: IdentityTokenBalanceOptional[];
+}
+export type VerifiedPlatformAddressInfoWithRootHash = VerifiedPlatformAddressInfo & {
+    rootHash: Uint8Array;
+};
+export interface VerifiedPlatformAddressesInfosWithRootHash {
+    rootHash: Uint8Array;
+    infos: VerifiedPlatformAddressInfo[];
+}

package/dist/src/dpp/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,6 @@
+import type { DynamicValue, IdentifierLikeNAPI, PlatformAddressLikeNAPI } from '../../binaries/bindingsTypes.js';
+import { IdentifierLike, PlatformAddressLike } from './types.js';
+export declare function valueToDynamicValue(value: any): DynamicValue;
+export declare function valueFromDynamicValue(dynamicValue: DynamicValue, jsonLike?: boolean): any;
+export declare function prepareIdentifierValue(identifier: IdentifierLike): IdentifierLikeNAPI;
+export declare function preparePlatformAddressValue(address: PlatformAddressLike): PlatformAddressLikeNAPI;

package/dist/src/dpp/utils.js

@@ -0,0 +1,96 @@
+import { dppProvider } from './provider.js';
+import { UINT32MAX } from './constants.js';
+import { IdentifierWASM } from './structs/Identifier.js';
+import { PlatformAddressWASM } from './structs/PlatformAddress/PlatformAddress.js';
+export function valueToDynamicValue(value) {
+    if (typeof value === 'bigint' || (value > UINT32MAX && typeof value !== 'string')) {
+        return dppProvider.dpp.DynamicValue.fromBigIntString(BigInt(value.toString()).toString());
+    }
+    else if (value instanceof IdentifierWASM || value instanceof dppProvider.dpp.IdentifierNAPI) {
+        return new dppProvider.dpp.DynamicValue(value.bytes());
+    }
+    else if (value instanceof Uint8Array) {
+        return new dppProvider.dpp.DynamicValue(value);
+    }
+    else if (Array.isArray(value)) {
+        return new dppProvider.dpp.DynamicValue(value.map(valueToDynamicValue));
+    }
+    else if (typeof value === 'object' && value !== null) {
+        const keys = Object.keys(value);
+        const objectWithDynamicValue = Object.assign({}, value);
+        for (const key of keys) {
+            objectWithDynamicValue[key] = valueToDynamicValue(value[key]);
+        }
+        return new dppProvider.dpp.DynamicValue(objectWithDynamicValue);
+    }
+    else if (typeof value === 'function') {
+        throw new Error('Cannot parse value from function');
+    }
+    if (typeof value === 'number') {
+        // we cannot strongly pass uint or float without js layer check
+        if (Number.isInteger(value)) {
+            if (value > 4294967295 || value < 0) {
+                return dppProvider.dpp.DynamicValue.fromInt(value);
+            }
+            else {
+                return dppProvider.dpp.DynamicValue.fromUInt(value);
+            }
+        }
+        else {
+            return dppProvider.dpp.DynamicValue.fromFloat(value);
+        }
+    }
+    else {
+        return new dppProvider.dpp.DynamicValue(value);
+    }
+}
+export function valueFromDynamicValue(dynamicValue, jsonLike = false) {
+    if (dynamicValue.value instanceof dppProvider.dpp.DynamicValue) {
+        return valueFromDynamicValue(dynamicValue.value, jsonLike);
+    }
+    else if (dynamicValue.isBigInt()) {
+        const num = BigInt(dynamicValue.value);
+        if (jsonLike && num < BigInt(Number.MAX_SAFE_INTEGER) && num > BigInt(Number.MIN_SAFE_INTEGER)) {
+            return Number(dynamicValue.value);
+        }
+        else {
+            return num;
+        }
+    }
+    else if (Array.isArray(dynamicValue.value)) {
+        return dynamicValue.value.map(v => valueFromDynamicValue(v, jsonLike));
+    }
+    else if (typeof dynamicValue.value === 'object' && !(dynamicValue.value instanceof Uint8Array) && dynamicValue.value !== null) {
+        const obj = {};
+        const keys = Object.keys(dynamicValue.value);
+        for (const key of keys) {
+            obj[key] = valueFromDynamicValue(dynamicValue.value[key], jsonLike);
+        }
+        return obj;
+    }
+    else {
+        return dynamicValue.value;
+    }
+}
+export function prepareIdentifierValue(identifier) {
+    if (identifier instanceof IdentifierWASM) {
+        return identifier._rawIdentifier;
+    }
+    else if (identifier instanceof dppProvider.dpp.IdentifierNAPI) {
+        return identifier;
+    }
+    else {
+        return new dppProvider.dpp.DynamicValue(identifier);
+    }
+}
+export function preparePlatformAddressValue(address) {
+    if (address instanceof PlatformAddressWASM) {
+        return address._rawPlatformAddress;
+    }
+    else if (address instanceof dppProvider.dpp.PlatformAddressNAPI) {
+        return address;
+    }
+    else {
+        return new dppProvider.dpp.DynamicValue(address);
+    }
+}

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

@@ -0,0 +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 | undefined, count: number | undefined, startAt: StartAt | undefined, platformVersion: PlatformVersionLike): VerifiedVoteState;

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

@@ -0,0 +1,34 @@
+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 ?? false, count, valueToDynamicValue(startAt), valueToDynamicValue(platformVersion));
+    const winner = valueFromDynamicValue(result.result.winner);
+    const winnerBlockInfo = winner?.blockInfo;
+    const outWinner = winner != null
+        ? {
+            type: winner.type,
+            identityId: winner.identityId,
+            blockInfo: {
+                height: BigInt(winnerBlockInfo.height),
+                coreHeight: winnerBlockInfo.coreHeight,
+                timeMs: BigInt(winnerBlockInfo.timeMs),
+                epoch: winnerBlockInfo.epoch != null ? winnerBlockInfo?.epoch : undefined
+            }
+        }
+        : undefined;
+    return {
+        rootHash: result.rootHash,
+        result: {
+            lockedVoteTally: result.result.lockedVoteTally ?? undefined,
+            contenders: result.result.contenders.map(c => ({
+                identityId: IdentifierWASM.createFromRawInstance(c.identityId),
+                serializedDocument: c.serializedDocument ?? undefined,
+                voteTally: c.voteTally ?? undefined
+            })),
+            abstainingVoteTally: result.result.abstainingVoteTally ?? undefined,
+            winner: outWinner,
+            skipped: result.result.skipped
+        }
+    };
+}

package/dist/src/dpp/verify/Contract/verifyContract.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedContract } from '../../types.js';
+export declare function verifyContractProof(proof: Uint8Array, contractKnownKeepsHistory: boolean | undefined, isProofSubset: boolean, inMultipleContractProofForm: boolean, contractId: IdentifierLike, platformVersion: PlatformVersionLike): VerifiedContract;

package/dist/src/dpp/verify/Contract/verifyContract.js

@@ -0,0 +1,14 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { DataContractWASM } from '../../structs/DataContract.js';
+export function verifyContractProof(proof, contractKnownKeepsHistory, isProofSubset, inMultipleContractProofForm, contractId, platformVersion) {
+    const result = dppProvider.dpp.verifyContractProof(proof, contractKnownKeepsHistory, isProofSubset, inMultipleContractProofForm, prepareIdentifierValue(contractId), valueToDynamicValue(platformVersion));
+    let dataContract;
+    if (result.dataContract != null) {
+        dataContract = DataContractWASM.createFromRawInstance(result.dataContract);
+    }
+    return {
+        rootHash: result.rootHash,
+        dataContract
+    };
+}

package/dist/src/dpp/verify/Document/verifyDocumentsProof.d.ts

@@ -0,0 +1,3 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedDocuments, WhereClause } from '../../types.js';
+import { DataContractWASM } from '../../structs/DataContract.js';
+export declare function verifyDocumentsProof(proof: Uint8Array, contract: DataContractWASM, documentTypeName: string, whereClauses: WhereClause[] | undefined, orderBy: string[][] | undefined, limit: number | undefined | null, startAt: IdentifierLike | undefined | null, startAtIncluded: boolean, blockTimeMs: bigint | undefined | null, platformVersion: PlatformVersionLike): VerifiedDocuments;

package/dist/src/dpp/verify/Document/verifyDocumentsProof.js

@@ -0,0 +1,10 @@
+import { dppProvider } from '../../provider.js';
+import { DocumentWASM } from '../../structs/Document.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+export function verifyDocumentsProof(proof, contract, documentTypeName, whereClauses, orderBy, limit, startAt, startAtIncluded, blockTimeMs, platformVersion) {
+    const result = dppProvider.dpp.verifyDocumentsProof(proof, contract._rawDataContract, documentTypeName, valueToDynamicValue(whereClauses), orderBy ?? [], limit, startAt != null ? prepareIdentifierValue(startAt) : undefined, startAtIncluded, blockTimeMs?.toString(), valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        documents: result.documents.map(DocumentWASM.createFromRawInstance)
+    };
+}

package/dist/src/dpp/verify/Identity/verifyIdentifierByNonUniquePublicKeyHashProof.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedIdentifierByNonUniquePublicKeyHash } from '../../types.js';
+export declare function verifyIdentifierByNonUniquePublicKeyHashProof(proof: Uint8Array, proofSubset: boolean, publicKeyHash: Uint8Array, after: IdentifierLike | undefined | null, platformVersion: PlatformVersionLike): VerifiedIdentifierByNonUniquePublicKeyHash;

package/dist/src/dpp/verify/Identity/verifyIdentifierByNonUniquePublicKeyHashProof.js

@@ -0,0 +1,10 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../../structs/Identifier.js';
+export function verifyIdentifierByNonUniquePublicKeyHashProof(proof, proofSubset, publicKeyHash, after, platformVersion) {
+    const result = dppProvider.dpp.verifyIdentifierByNonUniquePublicKeyHashProof(proof, proofSubset, publicKeyHash, after != null ? prepareIdentifierValue(after) : undefined, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        identifier: result.identifier != null ? IdentifierWASM.createFromRawInstance(result.identifier) : undefined
+    };
+}

package/dist/src/dpp/verify/Identity/verifyIdentityBalanceProof.d.ts

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

package/dist/src/dpp/verify/Identity/verifyIdentityBalanceProof.js

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

package/dist/src/dpp/verify/Identity/verifyIdentityByIdentifierProof.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedIdentityByIdentifier } from '../../types.js';
+export declare function verifyIdentityByIdentifierProof(proof: Uint8Array, identityId: IdentifierLike, isProofSubset: boolean, platformVersion: PlatformVersionLike): VerifiedIdentityByIdentifier;

package/dist/src/dpp/verify/Identity/verifyIdentityByIdentifierProof.js

@@ -0,0 +1,10 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentityWASM } from '../../structs/Identity.js';
+export function verifyIdentityByIdentifierProof(proof, identityId, isProofSubset, platformVersion) {
+    const result = dppProvider.dpp.verifyIdentityByIdentifierProof(proof, prepareIdentifierValue(identityId), isProofSubset, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        identity: result.identity != null ? IdentityWASM.createFromRawInstance(result.identity) : undefined
+    };
+}

package/dist/src/dpp/verify/Identity/verifyIdentityByUniqueKeyHashProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedIdentityByUniqueKeyHash } from '../../types.js';
+export declare function verifyIdentityByUniqueKeyHashProof(proof: Uint8Array, publicKeyHash: Uint8Array, platformVersion: PlatformVersionLike): VerifiedIdentityByUniqueKeyHash;

package/dist/src/dpp/verify/Identity/verifyIdentityByUniqueKeyHashProof.js

@@ -0,0 +1,10 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { IdentityWASM } from '../../structs/Identity.js';
+export function verifyIdentityByUniqueKeyHashProof(proof, publicKeyHash, platformVersion) {
+    const result = dppProvider.dpp.verifyIdentityByUniqueKeyHashProof(proof, publicKeyHash, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        identity: result.identity != null ? IdentityWASM.createFromRawInstance(result.identity) : undefined
+    };
+}

package/dist/src/dpp/verify/Identity/verifyIdentityContractNonceProof.d.ts

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

package/dist/src/dpp/verify/Identity/verifyIdentityContractNonceProof.js

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

package/dist/src/dpp/verify/Identity/verifyIdentityKeysByIdentifierProof.d.ts

@@ -0,0 +1,2 @@
+import { IdentifierLike, PlatformVersionLike, VerifiedIdentityKeysByIdentifier } from '../../types.js';
+export declare function verifyIdentityKeysByIdentifierProof(proof: Uint8Array, identityId: IdentifierLike, specificKeyIds: number[] | undefined | null, withRevision: boolean, withBalance: boolean, isProofSubset: boolean, limit: number | undefined | null, offset: number | undefined | null, platformVersion: PlatformVersionLike): VerifiedIdentityKeysByIdentifier;

package/dist/src/dpp/verify/Identity/verifyIdentityKeysByIdentifierProof.js

@@ -0,0 +1,10 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { PartialIdentityWASM } from '../../structs/PartialIdentity.js';
+export function verifyIdentityKeysByIdentifierProof(proof, identityId, specificKeyIds, withRevision, withBalance, isProofSubset, limit, offset, platformVersion) {
+    const result = dppProvider.dpp.verifyIdentityKeysByIdentifierProof(proof, prepareIdentifierValue(identityId), specificKeyIds, withRevision, withBalance, isProofSubset, limit, offset, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        identity: result.identity != null ? PartialIdentityWASM.createFromRawInstance(result.identity) : undefined
+    };
+}

package/dist/src/dpp/verify/Identity/verifyIdentityNonceProof.d.ts

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

package/dist/src/dpp/verify/Identity/verifyIdentityNonceProof.js

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

package/dist/src/dpp/verify/PlatformAddress/verifyPlatformAddressInfo.d.ts

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

package/dist/src/dpp/verify/PlatformAddress/verifyPlatformAddressInfo.js

@@ -0,0 +1,12 @@
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
+import { PlatformAddressWASM } from '../../structs/PlatformAddress/PlatformAddress.js';
+export function verifyPlatformAddressInfo(proof, platformAddress, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyAddressInfo(proof, preparePlatformAddressValue(platformAddress), verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        address: result.address != null ? PlatformAddressWASM.createFromRawInstance(result.address) : undefined,
+        balance: result.balance != null ? BigInt(result.balance) : undefined,
+        nonce: result.nonce
+    };
+}

package/dist/src/dpp/verify/PlatformAddress/verifyPlatformAddressesInfos.d.ts

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

package/dist/src/dpp/verify/PlatformAddress/verifyPlatformAddressesInfos.js

@@ -0,0 +1,14 @@
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
+import { PlatformAddressWASM } from '../../structs/PlatformAddress/PlatformAddress.js';
+export function verifyPlatformAddressesInfos(proof, platformAddresses, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyAddressesInfos(proof, platformAddresses.map(preparePlatformAddressValue), verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        infos: result.infos.map(({ nonce, credits, address }) => ({
+            nonce,
+            balance: credits != null ? BigInt(credits) : undefined,
+            address: PlatformAddressWASM.createFromRawInstance(address)
+        }))
+    };
+}

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

@@ -0,0 +1,2 @@
+import { VerifiedStateTransitionResultVariants, VerifiedStateTransitionResultVariantsRAW } from '../../types.js';
+export declare function convertResult(result: VerifiedStateTransitionResultVariantsRAW): VerifiedStateTransitionResultVariants;