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

package/dist/src/dpp/structs/AssetLockProof/TxOut.js

@@ -0,0 +1,34 @@
+import { dppProvider } from '../../provider.js';
+export class TxOutWASM {
+    _rawTxOut;
+    constructor(value, scriptPubKey) {
+        const rsValue = value.toString();
+        this._rawTxOut = new dppProvider.dpp.TxOutNAPI(rsValue, scriptPubKey);
+    }
+    get value() {
+        return BigInt(this._rawTxOut.value);
+    }
+    set value(value) {
+        this._rawTxOut.value = value.toString();
+    }
+    get scriptPubKeyHex() {
+        return this._rawTxOut.scriptPubKeyHex;
+    }
+    set scriptPubKeyHex(script) {
+        this._rawTxOut.scriptPubKeyHex = script;
+    }
+    get scriptPubKeyBytes() {
+        return this._rawTxOut.scriptPubKeyBytes;
+    }
+    set scriptPubKeyBytes(script) {
+        this._rawTxOut.scriptPubKeyBytes = script;
+    }
+    getScriptPubKeyASM() {
+        return this._rawTxOut.getScriptPubKeyASM();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTxOut = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/AssetLockProof/Witness.d.ts

@@ -0,0 +1,11 @@
+import { WitnessNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class WitnessWASM {
+    /** @private **/
+    _rawWitness: WitnessNAPI;
+    constructor(bytes?: Uint8Array[]);
+    getBytes(): Uint8Array[];
+    isEmpty(): boolean;
+    clear(): void;
+    push(value: Uint8Array): void;
+    static createFromRawInstance(rawInstance: WitnessNAPI): WitnessWASM;
+}

package/dist/src/dpp/structs/AssetLockProof/Witness.js

@@ -0,0 +1,25 @@
+import { dppProvider } from '../../provider.js';
+export class WitnessWASM {
+    /** @private **/
+    _rawWitness;
+    constructor(bytes) {
+        this._rawWitness = new dppProvider.dpp.WitnessNAPI(bytes);
+    }
+    getBytes() {
+        return this._rawWitness.getBytes();
+    }
+    isEmpty() {
+        return this._rawWitness.isEmpty();
+    }
+    clear() {
+        this._rawWitness.clear();
+    }
+    push(value) {
+        this._rawWitness.push(value);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawWitness = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/BatchTransition.d.ts

@@ -0,0 +1,34 @@
+import { BatchTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { BatchedTransitionWASM } from './BatchedTransition.js';
+import { DocumentTransitionWASM } from './DocumentTransition.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class BatchTransitionWASM {
+    /** @private **/
+    _rawBatchTransition: BatchTransitionNAPI;
+    constructor(transitions: BatchedTransitionWASM[], ownerId: IdentifierLike, userFeeIncrease?: number, signaturePublicKeyId?: number, signature?: Uint8Array);
+    constructor(transitions: DocumentTransitionWASM[], ownerId: IdentifierLike, userFeeIncrease?: number, signaturePublicKeyId?: number, signature?: Uint8Array);
+    get transitions(): BatchedTransitionWASM[];
+    set transitions(value: BatchedTransitionWASM[]);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    get signaturePublicKeyId(): number;
+    set signaturePublicKeyId(value: number);
+    get allPurchasesAmount(): bigint | undefined;
+    get ownerId(): IdentifierWASM;
+    get modifiedDataIds(): IdentifierWASM[];
+    get allConflictingIndexCollateralVotingFunds(): bigint | undefined;
+    setIdentityContractNonce(nonce: bigint): void;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    toStateTransition(): StateTransitionWASM;
+    static fromV1BatchedTransitions(batchedTransitions: BatchedTransitionWASM[], ownerId: IdentifierLike, userFeeIncrease?: number, signaturePublicKeyId?: number, signature?: Uint8Array): BatchTransitionWASM;
+    static fromV0Transitions(documentTransitions: DocumentTransitionWASM[], ownerId: IdentifierLike, userFeeIncrease?: number, signaturePublicKeyId?: number, signature?: Uint8Array): BatchTransitionWASM;
+    static fromBytes(bytes: Uint8Array): BatchTransitionWASM;
+    static fromBase64(base64: string): BatchTransitionWASM;
+    static fromHex(hex: string): BatchTransitionWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): BatchTransitionWASM;
+    static createFromRawInstance(rawInstance: BatchTransitionNAPI): BatchTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/BatchTransition.js

@@ -0,0 +1,95 @@
+import { dppProvider } from '../../provider.js';
+import { BatchedTransitionWASM } from './BatchedTransition.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class BatchTransitionWASM {
+    /** @private **/
+    _rawBatchTransition;
+    constructor(transitions, ownerId, userFeeIncrease, signaturePublicKeyId, signature) {
+        if (transitions.length === 0) {
+            throw new Error('transitions array must not be empty');
+        }
+        const [transition] = transitions;
+        if (transition instanceof BatchedTransitionWASM) {
+            this._rawBatchTransition = dppProvider.dpp.BatchTransitionNAPI.fromV1BatchedTransitions(transitions.map(t => t._rawTransition), prepareIdentifierValue(ownerId), userFeeIncrease, signaturePublicKeyId, signature);
+        }
+        else {
+            this._rawBatchTransition = dppProvider.dpp.BatchTransitionNAPI.fromV0Transitions(transitions.map(t => t._rawTransition), prepareIdentifierValue(ownerId), userFeeIncrease, signaturePublicKeyId, signature);
+        }
+    }
+    get transitions() {
+        return this._rawBatchTransition.transitions.map(BatchedTransitionWASM.createFromRawInstance);
+    }
+    set transitions(value) {
+        this._rawBatchTransition.transitions = value.map(t => t._rawTransition);
+    }
+    get signature() {
+        return this._rawBatchTransition.signature;
+    }
+    set signature(value) {
+        this._rawBatchTransition.signature = value;
+    }
+    get signaturePublicKeyId() {
+        return this._rawBatchTransition.signaturePublicKeyId;
+    }
+    set signaturePublicKeyId(value) {
+        this._rawBatchTransition.signaturePublicKeyId = value;
+    }
+    get allPurchasesAmount() {
+        const amount = this._rawBatchTransition.allPurchasesAmount;
+        if (amount != null) {
+            return BigInt(amount);
+        }
+    }
+    get ownerId() {
+        return IdentifierWASM.createFromRawInstance(this._rawBatchTransition.ownerId);
+    }
+    get modifiedDataIds() {
+        return this._rawBatchTransition.modifiedDataIds.map(IdentifierWASM.createFromRawInstance);
+    }
+    get allConflictingIndexCollateralVotingFunds() {
+        const funds = this._rawBatchTransition.allConflictingIndexCollateralVotingFunds;
+        if (funds != null) {
+            return BigInt(funds);
+        }
+    }
+    setIdentityContractNonce(nonce) {
+        this._rawBatchTransition.setIdentityContractNonce(nonce.toString());
+    }
+    bytes() {
+        return this._rawBatchTransition.bytes();
+    }
+    hex() {
+        return this._rawBatchTransition.hex();
+    }
+    base64() {
+        return this._rawBatchTransition.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawBatchTransition.toStateTransition());
+    }
+    static fromV1BatchedTransitions(batchedTransitions, ownerId, userFeeIncrease, signaturePublicKeyId, signature) {
+        return BatchTransitionWASM.createFromRawInstance(dppProvider.dpp.BatchTransitionNAPI.fromV1BatchedTransitions(batchedTransitions.map(t => t._rawTransition), prepareIdentifierValue(ownerId), userFeeIncrease, signaturePublicKeyId, signature));
+    }
+    static fromV0Transitions(documentTransitions, ownerId, userFeeIncrease, signaturePublicKeyId, signature) {
+        return BatchTransitionWASM.createFromRawInstance(dppProvider.dpp.BatchTransitionNAPI.fromV0Transitions(documentTransitions.map(t => t._rawTransition), prepareIdentifierValue(ownerId), userFeeIncrease, signaturePublicKeyId, signature));
+    }
+    static fromBytes(bytes) {
+        return BatchTransitionWASM.createFromRawInstance(dppProvider.dpp.BatchTransitionNAPI.fromBytes(bytes));
+    }
+    static fromBase64(base64) {
+        return BatchTransitionWASM.createFromRawInstance(dppProvider.dpp.BatchTransitionNAPI.fromBase64(base64));
+    }
+    static fromHex(hex) {
+        return BatchTransitionWASM.createFromRawInstance(dppProvider.dpp.BatchTransitionNAPI.fromHex(hex));
+    }
+    static fromStateTransition(stateTransition) {
+        return BatchTransitionWASM.createFromRawInstance(dppProvider.dpp.BatchTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawBatchTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/BatchedTransition.d.ts

@@ -0,0 +1,13 @@
+import { BatchedTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TokenTransitionWASM } from './TokenTransition.js';
+import { DocumentTransitionWASM } from './DocumentTransition.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class BatchedTransitionWASM {
+    /** @private **/
+    _rawTransition: BatchedTransitionNAPI;
+    constructor(transition: TokenTransitionWASM | DocumentTransitionWASM);
+    get dataContractId(): IdentifierWASM;
+    set dataContractId(value: IdentifierWASM);
+    toTransition(): DocumentTransitionWASM | TokenTransitionWASM;
+    static createFromRawInstance(rawInstance: BatchedTransitionNAPI): BatchedTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/BatchedTransition.js

@@ -0,0 +1,39 @@
+import { TokenTransitionWASM } from './TokenTransition.js';
+import { DocumentTransitionWASM } from './DocumentTransition.js';
+import { dppProvider } from '../../provider.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { prepareIdentifierValue } from '../../utils.js';
+export class BatchedTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(transition) {
+        let raw;
+        if (transition instanceof DocumentTransitionWASM) {
+            raw = new dppProvider.dpp.BatchedTransitionNAPI(transition._rawTransition);
+        }
+        else {
+            raw = new dppProvider.dpp.BatchedTransitionNAPI(transition._rawTokenTransition);
+        }
+        this._rawTransition = raw;
+    }
+    get dataContractId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTransition.dataContractId);
+    }
+    set dataContractId(value) {
+        this._rawTransition.dataContractId = prepareIdentifierValue(value);
+    }
+    toTransition() {
+        const raw = this._rawTransition.toTransition();
+        if (raw instanceof dppProvider.dpp.DocumentTransitionNAPI) {
+            return DocumentTransitionWASM.createFromRawInstance(raw);
+        }
+        else {
+            return TokenTransitionWASM.createFromRawInstance(raw);
+        }
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/DocumentBaseTransition.d.ts

@@ -0,0 +1,20 @@
+import { DocumentBaseTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { TokenPaymentInfoWASM } from './TokenPaymentInfo.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class DocumentBaseTransitionWASM {
+    /** @private **/
+    _rawDocumentBaseTransition: DocumentBaseTransitionNAPI;
+    constructor(documentId: IdentifierLike, identityContractNonce: bigint, documentTypeName: string, dataContractId: IdentifierLike, tokenPaymentInfo?: TokenPaymentInfoWASM);
+    get id(): IdentifierWASM;
+    set id(id: IdentifierWASM);
+    get identityContractNonce(): bigint;
+    set identityContractNonce(identityContractNonce: bigint);
+    get dataContractId(): IdentifierWASM;
+    set dataContractId(id: IdentifierWASM);
+    get documentTypeName(): string;
+    set documentTypeName(name: string);
+    get tokenPaymentInfo(): TokenPaymentInfoWASM | undefined;
+    set tokenPaymentInfo(tokenPaymentInfo: TokenPaymentInfoWASM | undefined);
+    static createFromRawInstance(rawInstance: DocumentBaseTransitionNAPI): DocumentBaseTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/DocumentBaseTransition.js

@@ -0,0 +1,54 @@
+import { TokenPaymentInfoWASM } from './TokenPaymentInfo.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class DocumentBaseTransitionWASM {
+    /** @private **/
+    _rawDocumentBaseTransition;
+    constructor(documentId, identityContractNonce, documentTypeName, dataContractId, tokenPaymentInfo) {
+        this._rawDocumentBaseTransition = new dppProvider.dpp.DocumentBaseTransitionNAPI(prepareIdentifierValue(documentId), identityContractNonce?.toString(), documentTypeName, prepareIdentifierValue(dataContractId), tokenPaymentInfo?._rawTokenPaymentInfo);
+    }
+    get id() {
+        return IdentifierWASM.createFromRawInstance(this._rawDocumentBaseTransition.id);
+    }
+    set id(id) {
+        this._rawDocumentBaseTransition.id = id._rawIdentifier;
+    }
+    get identityContractNonce() {
+        return BigInt(this._rawDocumentBaseTransition.identityContractNonce);
+    }
+    set identityContractNonce(identityContractNonce) {
+        this._rawDocumentBaseTransition.identityContractNonce = identityContractNonce?.toString();
+    }
+    get dataContractId() {
+        return IdentifierWASM.createFromRawInstance(this._rawDocumentBaseTransition.dataContractId);
+    }
+    set dataContractId(id) {
+        this._rawDocumentBaseTransition.dataContractId = id._rawIdentifier;
+    }
+    get documentTypeName() {
+        return this._rawDocumentBaseTransition.documentTypeName;
+    }
+    set documentTypeName(name) {
+        this._rawDocumentBaseTransition.documentTypeName = name;
+    }
+    get tokenPaymentInfo() {
+        const info = this._rawDocumentBaseTransition.tokenPaymentInfo;
+        if (info != null) {
+            return TokenPaymentInfoWASM.crateFromRawInstance(info);
+        }
+    }
+    set tokenPaymentInfo(tokenPaymentInfo) {
+        if (tokenPaymentInfo != null) {
+            this._rawDocumentBaseTransition.tokenPaymentInfo = tokenPaymentInfo._rawTokenPaymentInfo;
+        }
+        else {
+            this._rawDocumentBaseTransition.clearTokenPaymentInfo();
+        }
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDocumentBaseTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/DocumentTransition.d.ts

@@ -0,0 +1,32 @@
+import { DocumentTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { DocumentCreateTransitionWASM } from './DocumentTransitions/DocumentCreateTransition.js';
+import { DocumentReplaceTransitionWASM } from './DocumentTransitions/DocumentReplaceTransition.js';
+import { DocumentDeleteTransitionWASM } from './DocumentTransitions/DocumentDeleteTransition.js';
+import { DocumentPurchaseTransitionWASM } from './DocumentTransitions/DocumentPurchaseTransition.js';
+import { DocumentTransferTransitionWASM } from './DocumentTransitions/DocumentTransferTransition.js';
+import { DocumentUpdatePriceTransitionWASM } from './DocumentTransitions/DocumentUpdatePriceTransition.js';
+import { DocumentTransitionLike, IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class DocumentTransitionWASM {
+    /** @private **/
+    _rawTransition: DocumentTransitionNAPI;
+    constructor(transition: DocumentTransitionLike);
+    get actionType(): string;
+    get actionTypeNumber(): number;
+    get dataContractId(): IdentifierWASM;
+    set dataContractId(value: IdentifierLike);
+    get id(): IdentifierWASM;
+    get documentTypeName(): string;
+    get identityContractNonce(): bigint;
+    set identityContractNonce(value: bigint);
+    get revision(): bigint | undefined;
+    set revision(value: bigint);
+    get entropy(): Uint8Array | undefined;
+    get createTransition(): DocumentCreateTransitionWASM;
+    get deleteTransition(): DocumentDeleteTransitionWASM;
+    get purchaseTransition(): DocumentPurchaseTransitionWASM;
+    get replaceTransition(): DocumentReplaceTransitionWASM;
+    get transferTransition(): DocumentTransferTransitionWASM;
+    get updatePriceTransition(): DocumentUpdatePriceTransitionWASM;
+    static createFromRawInstance(rawInstance: DocumentTransitionNAPI): DocumentTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/DocumentTransition.js

@@ -0,0 +1,74 @@
+import { DocumentCreateTransitionWASM } from './DocumentTransitions/DocumentCreateTransition.js';
+import { DocumentReplaceTransitionWASM } from './DocumentTransitions/DocumentReplaceTransition.js';
+import { DocumentDeleteTransitionWASM } from './DocumentTransitions/DocumentDeleteTransition.js';
+import { DocumentPurchaseTransitionWASM } from './DocumentTransitions/DocumentPurchaseTransition.js';
+import { DocumentTransferTransitionWASM } from './DocumentTransitions/DocumentTransferTransition.js';
+import { DocumentUpdatePriceTransitionWASM } from './DocumentTransitions/DocumentUpdatePriceTransition.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { prepareIdentifierValue } from '../../utils.js';
+export class DocumentTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(transition) {
+        this._rawTransition = transition.toDocumentTransition()._rawTransition;
+    }
+    get actionType() {
+        return this._rawTransition.actionType;
+    }
+    get actionTypeNumber() {
+        return this._rawTransition.actionTypeNumber;
+    }
+    get dataContractId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTransition.dataContractId);
+    }
+    set dataContractId(value) {
+        this._rawTransition.dataContractId = prepareIdentifierValue(value);
+    }
+    get id() {
+        return IdentifierWASM.createFromRawInstance(this._rawTransition.id);
+    }
+    get documentTypeName() {
+        return this._rawTransition.documentTypeName;
+    }
+    get identityContractNonce() {
+        return BigInt(this._rawTransition.identityContractNonce);
+    }
+    set identityContractNonce(value) {
+        this._rawTransition.identityContractNonce = value.toString();
+    }
+    get revision() {
+        const rev = this._rawTransition.revision;
+        if (rev != null) {
+            return BigInt(rev);
+        }
+    }
+    set revision(value) {
+        this._rawTransition.revision = value.toString();
+    }
+    get entropy() {
+        return this._rawTransition.entropy ?? undefined;
+    }
+    get createTransition() {
+        return DocumentCreateTransitionWASM.createFromRawInstance(this._rawTransition.createTransition);
+    }
+    get deleteTransition() {
+        return DocumentDeleteTransitionWASM.createFromRawInstance(this._rawTransition.deleteTransition);
+    }
+    get purchaseTransition() {
+        return DocumentPurchaseTransitionWASM.createFromRawInstance(this._rawTransition.purchaseTransition);
+    }
+    get replaceTransition() {
+        return DocumentReplaceTransitionWASM.createFromRawInstance(this._rawTransition.replaceTransition);
+    }
+    get transferTransition() {
+        return DocumentTransferTransitionWASM.createFromRawInstance(this._rawTransition.transferTransition);
+    }
+    get updatePriceTransition() {
+        return DocumentUpdatePriceTransitionWASM.createFromRawInstance(this._rawTransition.updatePriceTransition);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/DocumentTransitions/DocumentCreateTransition.d.ts

@@ -0,0 +1,23 @@
+import { DocumentCreateTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { DocumentWASM } from '../../Document.js';
+import { PrefundedVotingBalanceWASM } from '../PrefundedVotingBalance.js';
+import { TokenPaymentInfoWASM } from '../TokenPaymentInfo.js';
+import { DocumentBaseTransitionWASM } from '../DocumentBaseTransition.js';
+import { DocumentTransitionWASM } from '../DocumentTransition.js';
+export declare class DocumentCreateTransitionWASM {
+    /** @private **/
+    _rawDocumentCreateTransition: DocumentCreateTransitionNAPI;
+    constructor(document: DocumentWASM, identityContractNonce: bigint, prefundedVotingBalance?: PrefundedVotingBalanceWASM, tokenPaymentInfo?: TokenPaymentInfoWASM);
+    get data(): object;
+    set data(value: object);
+    get base(): DocumentBaseTransitionWASM;
+    set base(value: DocumentBaseTransitionWASM);
+    get entropy(): Uint8Array;
+    set entropy(value: Uint8Array);
+    get prefundedVotingBalance(): PrefundedVotingBalanceWASM | undefined;
+    set prefundedVotingBalance(value: PrefundedVotingBalanceWASM | undefined);
+    clearPrefundedVotingBalance(): void;
+    toDocumentTransition(): DocumentTransitionWASM;
+    static fromDocumentTransition(transition: DocumentTransitionWASM): DocumentCreateTransitionWASM;
+    static createFromRawInstance(rawInstance: DocumentCreateTransitionNAPI): DocumentCreateTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/DocumentTransitions/DocumentCreateTransition.js

@@ -0,0 +1,58 @@
+import { PrefundedVotingBalanceWASM } from '../PrefundedVotingBalance.js';
+import { dppProvider } from '../../../provider.js';
+import { valueFromDynamicValue, valueToDynamicValue } from '../../../utils.js';
+import { DocumentBaseTransitionWASM } from '../DocumentBaseTransition.js';
+import { DocumentTransitionWASM } from '../DocumentTransition.js';
+export class DocumentCreateTransitionWASM {
+    /** @private **/
+    _rawDocumentCreateTransition;
+    constructor(document, identityContractNonce, prefundedVotingBalance, tokenPaymentInfo) {
+        this._rawDocumentCreateTransition = new dppProvider.dpp.DocumentCreateTransitionNAPI(document._rawDocument, identityContractNonce.toString(), prefundedVotingBalance?._rawPrefundedVotingBalance, tokenPaymentInfo?._rawTokenPaymentInfo);
+    }
+    get data() {
+        return valueFromDynamicValue(this._rawDocumentCreateTransition.data);
+    }
+    set data(value) {
+        this._rawDocumentCreateTransition.data = valueToDynamicValue(value);
+    }
+    get base() {
+        return DocumentBaseTransitionWASM.createFromRawInstance(this._rawDocumentCreateTransition.base);
+    }
+    set base(value) {
+        this._rawDocumentCreateTransition.base = value._rawDocumentBaseTransition;
+    }
+    get entropy() {
+        return this._rawDocumentCreateTransition.entropy;
+    }
+    set entropy(value) {
+        this._rawDocumentCreateTransition.entropy = value;
+    }
+    get prefundedVotingBalance() {
+        const balance = this._rawDocumentCreateTransition.prefundedVotingBalance;
+        if (balance != null) {
+            return PrefundedVotingBalanceWASM.createFromRawInstance(balance);
+        }
+    }
+    set prefundedVotingBalance(value) {
+        if (value != null) {
+            this._rawDocumentCreateTransition.prefundedVotingBalance = value._rawPrefundedVotingBalance;
+        }
+        else {
+            this._rawDocumentCreateTransition.clearPrefundedVotingBalance();
+        }
+    }
+    clearPrefundedVotingBalance() {
+        this._rawDocumentCreateTransition.clearPrefundedVotingBalance();
+    }
+    toDocumentTransition() {
+        return DocumentTransitionWASM.createFromRawInstance(this._rawDocumentCreateTransition.toDocumentTransition());
+    }
+    static fromDocumentTransition(transition) {
+        return DocumentCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.DocumentCreateTransitionNAPI.fromDocumentTransition(transition._rawTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDocumentCreateTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/DocumentTransitions/DocumentDeleteTransition.d.ts

@@ -0,0 +1,14 @@
+import { DocumentDeleteTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { DocumentWASM } from '../../Document.js';
+import { TokenPaymentInfoWASM } from '../TokenPaymentInfo.js';
+import { DocumentBaseTransitionWASM, DocumentTransitionWASM } from '../../../dpp.js';
+export declare class DocumentDeleteTransitionWASM {
+    /** @private **/
+    _rawDocumentDeleteTransition: DocumentDeleteTransitionNAPI;
+    constructor(document: DocumentWASM, identityContractNonce: bigint, tokenPaymentInfo?: TokenPaymentInfoWASM);
+    get base(): DocumentBaseTransitionWASM;
+    set base(value: DocumentBaseTransitionWASM);
+    toDocumentTransition(): DocumentTransitionWASM;
+    static fromDocumentTransition(transition: DocumentTransitionWASM): DocumentDeleteTransitionWASM;
+    static createFromRawInstance(rawInstance: DocumentDeleteTransitionNAPI): DocumentDeleteTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/DocumentTransitions/DocumentDeleteTransition.js

@@ -0,0 +1,26 @@
+import { DocumentBaseTransitionWASM, DocumentTransitionWASM } from '../../../dpp.js';
+import { dppProvider } from '../../../provider.js';
+export class DocumentDeleteTransitionWASM {
+    /** @private **/
+    _rawDocumentDeleteTransition;
+    constructor(document, identityContractNonce, tokenPaymentInfo) {
+        this._rawDocumentDeleteTransition = new dppProvider.dpp.DocumentDeleteTransitionNAPI(document._rawDocument, identityContractNonce?.toString(), tokenPaymentInfo?._rawTokenPaymentInfo);
+    }
+    get base() {
+        return DocumentBaseTransitionWASM.createFromRawInstance(this._rawDocumentDeleteTransition.base);
+    }
+    set base(value) {
+        this._rawDocumentDeleteTransition.base = value._rawDocumentBaseTransition;
+    }
+    toDocumentTransition() {
+        return DocumentTransitionWASM.createFromRawInstance(this._rawDocumentDeleteTransition.toDocumentTransition());
+    }
+    static fromDocumentTransition(transition) {
+        return DocumentDeleteTransitionWASM.createFromRawInstance(dppProvider.dpp.DocumentDeleteTransitionNAPI.fromDocumentTransition(transition._rawTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDocumentDeleteTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/DocumentTransitions/DocumentPurchaseTransition.d.ts

@@ -0,0 +1,19 @@
+import { DocumentPurchaseTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { DocumentWASM } from '../../Document.js';
+import { TokenPaymentInfoWASM } from '../TokenPaymentInfo.js';
+import { DocumentBaseTransitionWASM } from '../DocumentBaseTransition.js';
+import { DocumentTransitionWASM } from '../DocumentTransition.js';
+export declare class DocumentPurchaseTransitionWASM {
+    /** @private **/
+    _rawDocumentPurchaseTransition: DocumentPurchaseTransitionNAPI;
+    constructor(document: DocumentWASM, identityContractNonce: bigint, amount: bigint, tokenPaymentInfo?: TokenPaymentInfoWASM);
+    get base(): DocumentBaseTransitionWASM;
+    set base(value: DocumentBaseTransitionWASM);
+    get price(): bigint;
+    set price(value: bigint);
+    get revision(): bigint;
+    set revision(value: bigint);
+    toDocumentTransition(): DocumentTransitionWASM;
+    static fromDocumentTransition(transition: DocumentTransitionWASM): DocumentPurchaseTransitionWASM;
+    static createFromRawInstance(rawInstance: DocumentPurchaseTransitionNAPI): DocumentPurchaseTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/DocumentTransitions/DocumentPurchaseTransition.js

@@ -0,0 +1,39 @@
+import { dppProvider } from '../../../provider.js';
+import { DocumentBaseTransitionWASM } from '../DocumentBaseTransition.js';
+import { DocumentTransitionWASM } from '../DocumentTransition.js';
+export class DocumentPurchaseTransitionWASM {
+    /** @private **/
+    _rawDocumentPurchaseTransition;
+    constructor(document, identityContractNonce, amount, tokenPaymentInfo) {
+        this._rawDocumentPurchaseTransition = new dppProvider.dpp.DocumentPurchaseTransitionNAPI(document._rawDocument, identityContractNonce.toString(), amount.toString(), tokenPaymentInfo?._rawTokenPaymentInfo);
+    }
+    get base() {
+        return DocumentBaseTransitionWASM.createFromRawInstance(this._rawDocumentPurchaseTransition.base);
+    }
+    set base(value) {
+        this._rawDocumentPurchaseTransition.base = value._rawDocumentBaseTransition;
+    }
+    get price() {
+        return BigInt(this._rawDocumentPurchaseTransition.price);
+    }
+    set price(value) {
+        this._rawDocumentPurchaseTransition.price = value.toString();
+    }
+    get revision() {
+        return BigInt(this._rawDocumentPurchaseTransition.revision);
+    }
+    set revision(value) {
+        this._rawDocumentPurchaseTransition.revision = value.toString();
+    }
+    toDocumentTransition() {
+        return DocumentTransitionWASM.createFromRawInstance(this._rawDocumentPurchaseTransition.toDocumentTransition());
+    }
+    static fromDocumentTransition(transition) {
+        return DocumentPurchaseTransitionWASM.createFromRawInstance(dppProvider.dpp.DocumentPurchaseTransitionNAPI.fromDocumentTransition(transition._rawTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDocumentPurchaseTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/DocumentTransitions/DocumentReplaceTransition.d.ts

@@ -0,0 +1,19 @@
+import { DocumentReplaceTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { DocumentWASM } from '../../Document.js';
+import { TokenPaymentInfoWASM } from '../TokenPaymentInfo.js';
+import { DocumentBaseTransitionWASM } from '../DocumentBaseTransition.js';
+import { DocumentTransitionWASM } from '../DocumentTransition.js';
+export declare class DocumentReplaceTransitionWASM {
+    /** @private **/
+    _rawDocumentReplaceTransition: DocumentReplaceTransitionNAPI;
+    constructor(document: DocumentWASM, identityContractNonce: bigint, tokenPaymentInfo?: TokenPaymentInfoWASM);
+    get data(): object;
+    set data(value: object);
+    get base(): DocumentBaseTransitionWASM;
+    set base(value: DocumentBaseTransitionWASM);
+    get revision(): bigint;
+    set revision(value: bigint);
+    toDocumentTransition(): DocumentTransitionWASM;
+    static fromDocumentTransition(transition: DocumentTransitionWASM): DocumentReplaceTransitionWASM;
+    static createFromRawInstance(rawInstance: DocumentReplaceTransitionNAPI): DocumentReplaceTransitionWASM;
+}