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

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

@@ -0,0 +1,78 @@
+import { InputAddressWASM } from '../AddressTransitions/entities/InputAddress.js';
+import { AddressFundsFeeStrategyStepWASM } from '../AddressTransitions/entities/AddressFundsFeeStrategyStep.js';
+import { AddressWitnessWASM } from '../PlatformAddress/AddressWitness.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { dppProvider } from '../../provider.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class ShieldTransitionWASM {
+    /** @private **/
+    _rawShieldTransition;
+    constructor(inputs, actions, amount, anchor, proof, bindingsSignature, feeStrategy, userFeeIncrease, inputWitnesses) {
+        this._rawShieldTransition = new dppProvider.dpp.ShieldTransitionNAPI(inputs.map(i => i._rawInputAddress), actions.map(a => a._rawSerializedAction), amount.toString(), anchor, proof, bindingsSignature, feeStrategy.map(s => s._rawAddressFundsFeeStrategyStep), userFeeIncrease, inputWitnesses.map(w => w._rawWitness));
+    }
+    get inputs() {
+        return this._rawShieldTransition.inputs.map(InputAddressWASM.createFromRawInstance);
+    }
+    set inputs(value) {
+        this._rawShieldTransition.inputs = value.map(i => i._rawInputAddress);
+    }
+    get actions() {
+        return this._rawShieldTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawShieldTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get amount() {
+        return BigInt(this._rawShieldTransition.amount);
+    }
+    set amount(value) {
+        this._rawShieldTransition.amount = value.toString();
+    }
+    get anchor() {
+        return this._rawShieldTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawShieldTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawShieldTransition.proof;
+    }
+    set proof(value) {
+        this._rawShieldTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawShieldTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawShieldTransition.bindingsSignature = value;
+    }
+    get feeStrategy() {
+        return this._rawShieldTransition.feeStrategy.map(AddressFundsFeeStrategyStepWASM.createFromRawInstance);
+    }
+    set feeStrategy(value) {
+        this._rawShieldTransition.feeStrategy = value.map(s => s._rawAddressFundsFeeStrategyStep);
+    }
+    get userFeeIncrease() {
+        return this._rawShieldTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(value) {
+        this._rawShieldTransition.userFeeIncrease = value;
+    }
+    get inputWitnesses() {
+        return this._rawShieldTransition.inputWitnesses.map(AddressWitnessWASM.createFromRawInstance);
+    }
+    set inputWitnesses(value) {
+        this._rawShieldTransition.inputWitnesses = value.map(w => w._rawWitness);
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return ShieldTransitionWASM.createFromRawInstance(dppProvider.dpp.ShieldTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldTransitionWASM.prototype);
+        instance._rawShieldTransition = rawInstance;
+        return instance;
+    }
+}

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,47 @@ 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[];
+}
+export interface VerifiedShieldedEncryptedNote {
+    cmx: Uint8Array;
+    nullifier: Uint8Array;
+    cvNet: Uint8Array;
+    encryptedNote: Uint8Array;
+}
+export interface VerifiedShieldedEncryptedNotes {
+    rootHash: Uint8Array;
+    notes: VerifiedShieldedEncryptedNote[];
+    totalCount: bigint;
+}
+export interface VerifiedShieldedAnchors {
+    rootHash: Uint8Array;
+    anchors: Uint8Array[];
+}
+export interface VerifiedMostRecentShieldedAnchor {
+    rootHash: Uint8Array;
+    anchor?: Uint8Array;
+}
+export interface VerifiedShieldedPoolState {
+    rootHash: Uint8Array;
+    totalBalance?: bigint;
+}
+export interface VerifiedShieldedNotesCount {
+    rootHash: Uint8Array;
+    count?: bigint;
+}
+export interface VerifiedShieldedNullifier {
+    nullifier: Uint8Array;
+    isSpent: boolean;
+}
+export interface VerifiedShieldedNullifiers {
+    rootHash: Uint8Array;
+    nullifiers: VerifiedShieldedNullifier[];
 }

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;