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

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

@@ -0,0 +1,274 @@
+import * as protocol from '../../binaries/bindingsTypes.js';
+import { AddressWitnessP2pkhNAPI, AddressWitnessP2shNAPI, DataContractNAPI, DistributionLinearNAPI, DistributionExponentialNAPI, DistributionFixedAmountNAPI, DistributionInvertedLogarithmicNAPI, DistributionLogarithmicNAPI, DistributionPolynomialNAPI, DistributionRandomNAPI, DistributionStepDecreasingAmountNAPI, DocumentNAPI, IdentifierNAPI, IdentityNAPI, PartialIdentityNAPI, TokenConfigurationLocalizationJsonNAPI, TokenStatusNAPI, VerifiedAddressInfosNAPI, VerifiedBalanceTransferNAPI, VerifiedDocumentNAPI, VerifiedIdentityBalanceNAPI, VerifiedIdentityFullWithAddressInfosNAPI, VerifiedIdentityTokenInfoNAPI, VerifiedIdentityWithAddressInfosNAPI, VerifiedTokenGroupActionWithDocumentNAPI, VerifiedTokenGroupActionWithTokenBalanceNAPI, VerifiedTokenGroupActionWithTokenIdentityInfoNAPI, VerifiedTokenGroupActionWithTokenPricingScheduleNAPI, VerifiedTokenPricingScheduleNAPI, VoteNAPI } from '../../binaries/bindingsTypes.js';
+import { ActionGoal, AssetLockProofType, GasFeesPaidBy, KeyType, NetworkWASM, PlatformVersionWASM, Pooling, Purpose, SecurityLevel, TokenDistributionType, TokenEmergencyAction, 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/Address/PlatformAddress.js';
+export type DashPlatformProtocol = typeof protocol;
+export type IdentifierLike = string | Uint8Array | IdentifierNAPI | IdentifierWASM;
+export type KeyTypeLike = KeyType | keyof typeof KeyType;
+export type NetworkLike = NetworkWASM | keyof typeof NetworkWASM;
+export type SecurityLevelLike = SecurityLevel | keyof typeof SecurityLevel;
+export type PlatformVersionLike = PlatformVersionWASM | keyof typeof PlatformVersionWASM;
+export type PurposeLike = Purpose | keyof typeof Purpose;
+export type ActionGoalLike = ActionGoal | keyof typeof ActionGoal;
+export type GasFeesPaidByLike = GasFeesPaidBy | keyof typeof GasFeesPaidBy;
+export type TokenDistributionLike = TokenDistributionType | keyof typeof TokenDistributionType;
+export type TokenEmergencyActionLike = TokenEmergencyAction | keyof typeof TokenEmergencyAction;
+export type AssetLockProofTypeLike = AssetLockProofType | keyof typeof AssetLockProofType;
+export type PoolingLike = Pooling | keyof typeof Pooling;
+export type VoteStateResultTypeLike = VoteStateResultType | keyof typeof VoteStateResultType;
+export type EnumLike = KeyTypeLike | NetworkLike | SecurityLevelLike | PlatformVersionLike | PurposeLike;
+export type AddressWitnessP2PKH = AddressWitnessP2pkhNAPI;
+export type AddressWitnessP2SH = AddressWitnessP2shNAPI;
+export type TokenConfigurationLocalizationJson = TokenConfigurationLocalizationJsonNAPI;
+export type DistributionFixedAmount = DistributionFixedAmountNAPI;
+export type DistributionRandom = DistributionRandomNAPI;
+export type DistributionStepDecreasingAmount = DistributionStepDecreasingAmountNAPI;
+export interface DistributionStepwiseStep {
+    step: bigint;
+    amount: bigint;
+}
+export type DistributionStepwise = DistributionStepwiseStep[];
+export type DistributionLinear = DistributionLinearNAPI;
+export type DistributionPolynomial = DistributionPolynomialNAPI;
+export type DistributionExponential = DistributionExponentialNAPI;
+export type DistributionLogarithmic = DistributionLogarithmicNAPI;
+export type DistributionInvertedLogarithmic = 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 {
+    id: IdentifierWASM;
+    identityTokenInfo: IdentityTokenInfo;
+}
+export interface VerifiedTokenPricingSchedule {
+    id: 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 VerifiedAddressInfo {
+    nonce?: number;
+    address: PlatformAddressWASM;
+    credits?: bigint;
+}
+export interface VerifiedIdentityFullWithAddressInfos {
+    identity: IdentityWASM;
+    infos: VerifiedAddressInfo[];
+}
+export interface VerifiedIdentityWithAddressInfos {
+    identity: PartialIdentityWASM;
+    infos: VerifiedAddressInfo[];
+}
+export type VerifiedStateTransitionResultVariants = DataContractWASM | IdentityWASM | IdentifierWASM | VerifiedIdentityBalance | VerifiedIdentityTokenInfo | VerifiedTokenPricingSchedule | TokenStatus | VerifiedIdentityBalance[] | PartialIdentityWASM | VerifiedBalanceTransfer | VerifiedDocument[] | DocumentWASM | VerifiedTokenGroupActionWithDocument | VerifiedTokenGroupActionWithTokenBalance | VerifiedTokenGroupActionWithTokenIdentityInfo | VerifiedTokenGroupActionWithTokenPricingSchedule | VoteWASM | VerifiedAddressInfo[] | VerifiedIdentityFullWithAddressInfos | VerifiedIdentityWithAddressInfos;
+export type VerifiedStateTransitionResultVariantsRAW = DataContractNAPI | IdentityNAPI | IdentifierNAPI | VerifiedIdentityBalanceNAPI | VerifiedIdentityTokenInfoNAPI | VerifiedTokenPricingScheduleNAPI | TokenStatusNAPI | VerifiedIdentityBalanceNAPI[] | PartialIdentityNAPI | VerifiedBalanceTransferNAPI | VerifiedDocumentNAPI[] | DocumentNAPI | VerifiedTokenGroupActionWithDocumentNAPI | VerifiedTokenGroupActionWithTokenBalanceNAPI | VerifiedTokenGroupActionWithTokenIdentityInfoNAPI | VerifiedTokenGroupActionWithTokenPricingScheduleNAPI | VoteNAPI | VerifiedAddressInfosNAPI[] | VerifiedIdentityFullWithAddressInfosNAPI | 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 VerifiedTokenBalancesForIdentities {
+    rootHash: Uint8Array;
+    balances: IdentityTokenBalance[];
+}
+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: IdentityTokenBalance[];
+}

package/dist/src/dpp/types.js

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

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

@@ -0,0 +1,5 @@
+import { DynamicValue, IdentifierLikeNAPI } from '../../binaries/bindingsTypes.js';
+import { IdentifierLike } from './types.js';
+export declare function valueToDynamicValue(value: any): DynamicValue;
+export declare function valueFromDynamicValue(dynamicValue: DynamicValue): any;
+export declare function prepareIdentifierValue(identifier: IdentifierLike): IdentifierLikeNAPI;

package/dist/src/dpp/utils.js

@@ -0,0 +1,64 @@
+import { dppProvider } from './provider.js';
+import { UINT32MAX } from './constants.js';
+import { IdentifierWASM } from './structs/Identifier.js';
+export function valueToDynamicValue(value) {
+    if (typeof value === 'bigint' || value > UINT32MAX) {
+        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');
+    }
+    else {
+        return new dppProvider.dpp.DynamicValue(value);
+    }
+}
+export function valueFromDynamicValue(dynamicValue) {
+    if (dynamicValue.value instanceof dppProvider.dpp.DynamicValue) {
+        return valueToDynamicValue(dynamicValue.value);
+    }
+    else if (dynamicValue.isBigInt()) {
+        return BigInt(dynamicValue.value);
+    }
+    else if (Array.isArray(dynamicValue.value)) {
+        return dynamicValue.value.map(valueFromDynamicValue);
+    }
+    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]);
+        }
+        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);
+    }
+}

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: string[], resultType: VoteStateResultTypeLike, allowIncludeLockedAndAbstainingVoteTally: boolean, 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, valueToDynamicValue(indexValues), valueToDynamicValue(resultType), allowIncludeLockedAndAbstainingVoteTally, 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[], orderBy: string[][], 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/StateTransition/utils.d.ts

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