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

package/dist/src/dpp/structs/ShieldedTransitions/ShieldedTransferTransition.d.ts

@@ -0,0 +1,21 @@
+import type { ShieldedTransferTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class ShieldedTransferTransitionWASM {
+    /** @private **/
+    _rawShieldedTransferTransition: ShieldedTransferTransitionNAPI;
+    constructor(actions: SerializedActionWASM[], valueBalance: bigint, anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get valueBalance(): bigint;
+    set valueBalance(value: bigint);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): ShieldedTransferTransitionWASM;
+    static createFromRawInstance(rawInstance: ShieldedTransferTransitionNAPI): ShieldedTransferTransitionWASM;
+}

package/dist/src/dpp/structs/ShieldedTransitions/ShieldedTransferTransition.js

@@ -0,0 +1,51 @@
+import { SerializedActionWASM } from './SerializedAction.js';
+import { dppProvider } from '../../provider.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class ShieldedTransferTransitionWASM {
+    /** @private **/
+    _rawShieldedTransferTransition;
+    constructor(actions, valueBalance, anchor, proof, bindingsSignature) {
+        this._rawShieldedTransferTransition = new dppProvider.dpp.ShieldedTransferTransitionNAPI(actions.map(a => a._rawSerializedAction), valueBalance.toString(), anchor, proof, bindingsSignature);
+    }
+    get actions() {
+        return this._rawShieldedTransferTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawShieldedTransferTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get valueBalance() {
+        return BigInt(this._rawShieldedTransferTransition.valueBalance);
+    }
+    set valueBalance(value) {
+        this._rawShieldedTransferTransition.valueBalance = value.toString();
+    }
+    get anchor() {
+        return this._rawShieldedTransferTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawShieldedTransferTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawShieldedTransferTransition.proof;
+    }
+    set proof(value) {
+        this._rawShieldedTransferTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawShieldedTransferTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawShieldedTransferTransition.bindingsSignature = value;
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedTransferTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return ShieldedTransferTransitionWASM.createFromRawInstance(dppProvider.dpp.ShieldedTransferTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedTransferTransitionWASM.prototype);
+        instance._rawShieldedTransferTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/ShieldedTransitions/ShieldedWithdrawalTransition.d.ts

@@ -0,0 +1,29 @@
+import type { ShieldedWithdrawalTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { CoreScriptWASM } from '../CoreScript.js';
+import { PoolingLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class ShieldedWithdrawalTransitionWASM {
+    /** @private **/
+    _rawShieldedWithdrawalTransition: ShieldedWithdrawalTransitionNAPI;
+    constructor(actions: SerializedActionWASM[], unshieldingAmount: bigint, anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array, coreFeePerByte: number, pooling: PoolingLike, outputScript: CoreScriptWASM);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get unshieldingAmount(): bigint;
+    set unshieldingAmount(value: bigint);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    get coreFeePerByte(): number;
+    set coreFeePerByte(value: number);
+    get pooling(): string;
+    set pooling(value: PoolingLike);
+    get outputScript(): CoreScriptWASM;
+    set outputScript(value: CoreScriptWASM);
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): ShieldedWithdrawalTransitionWASM;
+    static createFromRawInstance(rawInstance: ShieldedWithdrawalTransitionNAPI): ShieldedWithdrawalTransitionWASM;
+}

package/dist/src/dpp/structs/ShieldedTransitions/ShieldedWithdrawalTransition.js

@@ -0,0 +1,71 @@
+import { SerializedActionWASM } from './SerializedAction.js';
+import { CoreScriptWASM } from '../CoreScript.js';
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class ShieldedWithdrawalTransitionWASM {
+    /** @private **/
+    _rawShieldedWithdrawalTransition;
+    constructor(actions, unshieldingAmount, anchor, proof, bindingsSignature, coreFeePerByte, pooling, outputScript) {
+        this._rawShieldedWithdrawalTransition = new dppProvider.dpp.ShieldedWithdrawalTransitionNAPI(actions.map(a => a._rawSerializedAction), unshieldingAmount.toString(), anchor, proof, bindingsSignature, coreFeePerByte, valueToDynamicValue(pooling), outputScript._rawCoreScript);
+    }
+    get actions() {
+        return this._rawShieldedWithdrawalTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawShieldedWithdrawalTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get unshieldingAmount() {
+        return BigInt(this._rawShieldedWithdrawalTransition.unshieldingAmount);
+    }
+    set unshieldingAmount(value) {
+        this._rawShieldedWithdrawalTransition.unshieldingAmount = value.toString();
+    }
+    get anchor() {
+        return this._rawShieldedWithdrawalTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawShieldedWithdrawalTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawShieldedWithdrawalTransition.proof;
+    }
+    set proof(value) {
+        this._rawShieldedWithdrawalTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawShieldedWithdrawalTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawShieldedWithdrawalTransition.bindingsSignature = value;
+    }
+    get coreFeePerByte() {
+        return this._rawShieldedWithdrawalTransition.coreFeePerByte;
+    }
+    set coreFeePerByte(value) {
+        this._rawShieldedWithdrawalTransition.coreFeePerByte = value;
+    }
+    get pooling() {
+        return this._rawShieldedWithdrawalTransition.pooling;
+    }
+    set pooling(value) {
+        this._rawShieldedWithdrawalTransition.pooling = valueToDynamicValue(value);
+    }
+    get outputScript() {
+        return CoreScriptWASM.createFromRawInstance(this._rawShieldedWithdrawalTransition.outputScript);
+    }
+    set outputScript(value) {
+        this._rawShieldedWithdrawalTransition.outputScript = value._rawCoreScript;
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedWithdrawalTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return ShieldedWithdrawalTransitionWASM.createFromRawInstance(dppProvider.dpp.ShieldedWithdrawalTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedWithdrawalTransitionWASM.prototype);
+        instance._rawShieldedWithdrawalTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/ShieldedTransitions/UnshieldTransition.d.ts

@@ -0,0 +1,25 @@
+import type { UnshieldTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { PlatformAddressLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class UnshieldTransitionWASM {
+    /** @private **/
+    _rawUnshieldTransition: UnshieldTransitionNAPI;
+    constructor(outputAddress: PlatformAddressLike, actions: SerializedActionWASM[], unshieldingAmount: bigint, anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array);
+    get outputAddress(): PlatformAddressWASM;
+    set outputAddress(value: PlatformAddressLike);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get unshieldingAmount(): bigint;
+    set unshieldingAmount(value: bigint);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): UnshieldTransitionWASM;
+    static createFromRawInstance(rawInstance: UnshieldTransitionNAPI): UnshieldTransitionWASM;
+}

package/dist/src/dpp/structs/ShieldedTransitions/UnshieldTransition.js

@@ -0,0 +1,59 @@
+import { SerializedActionWASM } from './SerializedAction.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class UnshieldTransitionWASM {
+    /** @private **/
+    _rawUnshieldTransition;
+    constructor(outputAddress, actions, unshieldingAmount, anchor, proof, bindingsSignature) {
+        this._rawUnshieldTransition = new dppProvider.dpp.UnshieldTransitionNAPI(preparePlatformAddressValue(outputAddress), actions.map(a => a._rawSerializedAction), unshieldingAmount.toString(), anchor, proof, bindingsSignature);
+    }
+    get outputAddress() {
+        return PlatformAddressWASM.createFromRawInstance(this._rawUnshieldTransition.outputAddress);
+    }
+    set outputAddress(value) {
+        this._rawUnshieldTransition.outputAddress = preparePlatformAddressValue(value);
+    }
+    get actions() {
+        return this._rawUnshieldTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawUnshieldTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get unshieldingAmount() {
+        return BigInt(this._rawUnshieldTransition.unshieldingAmount);
+    }
+    set unshieldingAmount(value) {
+        this._rawUnshieldTransition.unshieldingAmount = value.toString();
+    }
+    get anchor() {
+        return this._rawUnshieldTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawUnshieldTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawUnshieldTransition.proof;
+    }
+    set proof(value) {
+        this._rawUnshieldTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawUnshieldTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawUnshieldTransition.bindingsSignature = value;
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawUnshieldTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return UnshieldTransitionWASM.createFromRawInstance(dppProvider.dpp.UnshieldTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(UnshieldTransitionWASM.prototype);
+        instance._rawUnshieldTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -28,6 +28,7 @@ export declare class StateTransitionWASM {
     setOwnerId(ownerId: IdentifierLike): void;
     setIdentityContractNonce(nonce: bigint): void;
     setIdentityNonce(nonce: bigint): void;
+    getSignableBytes(): Uint8Array;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

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

@@ -76,6 +76,9 @@ export class StateTransitionWASM {
     setIdentityNonce(nonce) {
         this._rawStateTransition.setIdentityNonce(nonce.toString());
     }
+    getSignableBytes() {
+        return this._rawStateTransition.getSignableBytes();
+    }
     bytes() {
         return this._rawStateTransition.bytes();
     }

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

@@ -37,7 +37,7 @@ export class ActionTakerWASM {
         this._rawActionTaker.value = normalValue;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(ActionTakerWASM.prototype);
         instance._rawActionTaker = rawInstance;
         return instance;
     }

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

@@ -45,7 +45,7 @@ export class ChangeControlRulesWASM {
         return this._rawChangeControlRules.canChangeAdminActionTakers(adminActionTakers._rawAuthorizedActionTakers, prepareIdentifierValue(contractOwnerId), mainGroup, normalGroups, actionTaker._rawActionTaker, valueToDynamicValue(goal));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(ChangeControlRulesWASM.prototype);
         instance._rawChangeControlRules = rawInstance;
         return instance;
     }

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

@@ -37,7 +37,7 @@ export class GroupWASM {
         this._rawGroup.setMemberRequiredPower(prepareIdentifierValue(member), power);
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(GroupWASM.prototype);
         instance._rawGroup = rawInstance;
         return instance;
     }

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

@@ -132,7 +132,7 @@ export class TokenConfigurationWASM {
         return IdentifierWASM.createFromRawInstance(dppProvider.dpp.TokenConfigurationNAPI.calculateTokenId(prepareIdentifierValue(contractId), tokenPosition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(TokenConfigurationWASM.prototype);
         instance._rawTokenConfiguration = rawInstance;
         return instance;
     }

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

@@ -40,7 +40,7 @@ export class TokenConfigurationConventionWASM {
         this._rawTokenConfigurationConvention.localizations = normalLocalization;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(TokenConfigurationConventionWASM.prototype);
         instance._rawTokenConfigurationConvention = rawInstance;
         return instance;
     }

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

@@ -27,7 +27,7 @@ export class TokenConfigurationLocalizationWASM {
         return this._rawTokenConfigurationLocalization.toJSON();
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(TokenConfigurationLocalizationWASM.prototype);
         instance._rawTokenConfigurationLocalization = rawInstance;
         return instance;
     }

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

@@ -68,7 +68,7 @@ export class TokenDistributionRulesWASM {
         this._rawTokenDistributionRules.changeDirectPurchasePricingRules = changeDirectPurchasePricingRules._rawChangeControlRules;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(TokenDistributionRulesWASM.prototype);
         instance._rawTokenDistributionRules = rawInstance;
         return instance;
     }

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

@@ -42,7 +42,7 @@ export class TokenKeepsHistoryRulesWASM {
         this._rawTokenKeepsHistoryRules.keepsDirectPurchaseHistory = keepsDirectPurchaseHistory;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(TokenKeepsHistoryRulesWASM.prototype);
         instance._rawTokenKeepsHistoryRules = rawInstance;
         return instance;
     }

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

@@ -20,7 +20,7 @@ export class TokenMarketplaceRulesWASM {
         this._rawTokenMarketplaceRules.tradeModeChangeRules = value._rawChangeControlRules;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(TokenMarketplaceRulesWASM.prototype);
         instance._rawTokenMarketplaceRules = rawInstance;
         return instance;
     }

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

@@ -20,7 +20,7 @@ export class TokenPerpetualDistributionWASM {
         this._rawTokenPerpetualDistribution.distributionRecipient = value._rawTokenDistributionRecipient;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(TokenPerpetualDistributionWASM.prototype);
         instance._rawTokenPerpetualDistribution = rawInstance;
         return instance;
     }

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

@@ -35,7 +35,7 @@ export class TokenPreProgrammedDistributionWASM {
         this._rawTokenPreProgrammedDistribution.distributions = objectToDistributionArray(distributions);
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(TokenPreProgrammedDistributionWASM.prototype);
         instance._rawTokenPreProgrammedDistribution = rawInstance;
         return instance;
     }

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

@@ -28,9 +28,10 @@ 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';
+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>;
@@ -43,7 +44,6 @@ 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 EnumLike = KeyTypeLike | NetworkLike | SecurityLevelLike | PlatformVersionLike | PurposeLike;
 export type AddressWitnessP2PKH = protocol.AddressWitnessP2pkhNAPI;
 export type AddressWitnessP2SH = protocol.AddressWitnessP2shNAPI;
 export type TokenConfigurationLocalizationJson = protocol.TokenConfigurationLocalizationJsonNAPI;
@@ -182,21 +182,49 @@ export interface VerifiedTokenGroupActionWithTokenPricingSchedule {
     groupActionStatus: string;
     pricingSchedule?: TokenPricingScheduleWASM;
 }
-export interface VerifiedAddressInfo {
+export interface VerifiedPlatformAddressInfo {
+    address?: PlatformAddressWASM;
     nonce?: number;
-    address: PlatformAddressWASM;
-    credits?: bigint;
+    balance?: bigint;
 }
 export interface VerifiedIdentityFullWithAddressInfos {
     identity: IdentityWASM;
-    infos: VerifiedAddressInfo[];
+    infos: VerifiedPlatformAddressInfo[];
 }
 export interface VerifiedIdentityWithAddressInfos {
     identity: PartialIdentityWASM;
-    infos: VerifiedAddressInfo[];
+    infos: VerifiedPlatformAddressInfo[];
+}
+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 | VerifiedAddressInfo[] | 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.VerifiedAddressInfosNAPI[] | protocol.VerifiedIdentityFullWithAddressInfosNAPI | protocol.VerifiedIdentityWithAddressInfosNAPI;
+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;
@@ -243,9 +271,13 @@ export interface IdentityTokenBalance {
     balance: bigint;
     id: IdentifierWASM;
 }
+export interface IdentityTokenBalanceOptional {
+    balance?: bigint;
+    id: IdentifierWASM;
+}
 export interface VerifiedTokenBalancesForIdentities {
     rootHash: Uint8Array;
-    balances: IdentityTokenBalance[];
+    balances: IdentityTokenBalanceOptional[];
 }
 export interface TokenContractInfo {
     contractId: IdentifierWASM;
@@ -269,5 +301,12 @@ export interface VerifiedTokenTotalSupply {
 }
 export interface VerifiedTokensBalancesForIdentity {
     rootHash: Uint8Array;
-    balances: IdentityTokenBalance[];
+    balances: IdentityTokenBalanceOptional[];
+}
+export type VerifiedPlatformAddressInfoWithRootHash = VerifiedPlatformAddressInfo & {
+    rootHash: Uint8Array;
+};
+export interface VerifiedPlatformAddressesInfosWithRootHash {
+    rootHash: Uint8Array;
+    infos: VerifiedPlatformAddressInfo[];
 }

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

@@ -1,5 +1,6 @@
-import type { DynamicValue, IdentifierLikeNAPI } from '../../binaries/bindingsTypes.js';
-import { IdentifierLike } from './types.js';
+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): any;
+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

@@ -1,8 +1,9 @@
 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) {
+    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) {
@@ -43,21 +44,27 @@ export function valueToDynamicValue(value) {
         return new dppProvider.dpp.DynamicValue(value);
     }
 }
-export function valueFromDynamicValue(dynamicValue) {
+export function valueFromDynamicValue(dynamicValue, jsonLike = false) {
     if (dynamicValue.value instanceof dppProvider.dpp.DynamicValue) {
-        return valueToDynamicValue(dynamicValue.value);
+        return valueFromDynamicValue(dynamicValue.value, jsonLike);
     }
     else if (dynamicValue.isBigInt()) {
-        return BigInt(dynamicValue.value);
+        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(valueFromDynamicValue);
+        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]);
+            obj[key] = valueFromDynamicValue(dynamicValue.value[key], jsonLike);
         }
         return obj;
     }
@@ -76,3 +83,14 @@ export function prepareIdentifierValue(identifier) {
         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

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