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

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

@@ -0,0 +1,116 @@
+import { dppProvider } from '../provider.js';
+import { prepareIdentifierValue, valueFromDynamicValue, valueToDynamicValue } from '../utils.js';
+import { IdentifierWASM } from './Identifier.js';
+import { TokenConfigurationWASM } from './TokenConfiguration/TokenConfiguration.js';
+import { GroupWASM } from './TokenConfiguration/Group.js';
+export class DataContractWASM {
+    /** @private **/
+    _rawDataContract;
+    constructor(ownerId, identityNonce, schema, definitions, tokens, fullValidation, platformVersion) {
+        let normalTokens;
+        if (tokens != null) {
+            normalTokens = [];
+            for (const token of tokens) {
+                normalTokens.push([token.position, token.tokenConfiguration._rawTokenConfiguration]);
+            }
+        }
+        this._rawDataContract = new dppProvider.dpp.DataContractNAPI(prepareIdentifierValue(ownerId), identityNonce.toString(), valueToDynamicValue(schema), valueToDynamicValue(definitions), normalTokens, fullValidation, valueToDynamicValue(platformVersion));
+    }
+    get systemVersion() {
+        return this._rawDataContract.systemVersion;
+    }
+    set systemVersion(value) {
+        this._rawDataContract.systemVersion = value;
+    }
+    get version() {
+        return this._rawDataContract.version;
+    }
+    set version(value) {
+        this._rawDataContract.version = value;
+    }
+    get id() {
+        return IdentifierWASM.createFromRawInstance(this._rawDataContract.id);
+    }
+    set id(value) {
+        this._rawDataContract.id = value._rawIdentifier;
+    }
+    get tokens() {
+        const tokens = this._rawDataContract.tokens;
+        return tokens.map(([position, token]) => ({
+            position,
+            tokenConfiguration: TokenConfigurationWASM.createFromRawInstance(token)
+        }));
+    }
+    set tokens(tokens) {
+        let normalTokens;
+        if (tokens != null) {
+            normalTokens = [];
+            for (const token of tokens) {
+                normalTokens.push([token.position, token.tokenConfiguration._rawTokenConfiguration]);
+            }
+        }
+        this._rawDataContract.tokens = normalTokens;
+    }
+    get groups() {
+        return this._rawDataContract.groups.map(([position, group]) => ({
+            position,
+            group: GroupWASM.createFromRawInstance(group)
+        }));
+    }
+    set groups(groups) {
+        this._rawDataContract.groups = groups.map(({ group, position }) => ([position, group._rawGroup]));
+    }
+    get description() {
+        return this._rawDataContract.description ?? undefined;
+    }
+    set description(value) {
+        this._rawDataContract.description = value;
+    }
+    get keywords() {
+        return this._rawDataContract.keywords;
+    }
+    set keywords(value) {
+        this._rawDataContract.keywords = value;
+    }
+    getSchemas() {
+        return valueFromDynamicValue(this._rawDataContract.getSchemas());
+    }
+    getConfig() {
+        return valueFromDynamicValue(this._rawDataContract.getConfig());
+    }
+    bytes(platformVersion) {
+        return this._rawDataContract.bytes(valueToDynamicValue(platformVersion));
+    }
+    hex(platformVersion) {
+        return this._rawDataContract.hex(valueToDynamicValue(platformVersion));
+    }
+    base64(platformVersion) {
+        return this._rawDataContract.base64(valueToDynamicValue(platformVersion));
+    }
+    toJSON(platformVersion) {
+        return this._rawDataContract.toJson(valueToDynamicValue(platformVersion));
+    }
+    toValue(platformVersion) {
+        return valueFromDynamicValue(this._rawDataContract.toValue(valueToDynamicValue(platformVersion)));
+    }
+    static fromValue(value, fullValidation, platformVersion) {
+        return DataContractWASM.createFromRawInstance(dppProvider.dpp.DataContractNAPI.fromValue(valueToDynamicValue(value), fullValidation, valueToDynamicValue(platformVersion)));
+    }
+    static fromBytes(bytes, fullValidation, platformVersion) {
+        return DataContractWASM.createFromRawInstance(dppProvider.dpp.DataContractNAPI.fromBytes(bytes, fullValidation, valueToDynamicValue(platformVersion)));
+    }
+    static fromHex(hex, fullValidation, platformVersion) {
+        return DataContractWASM.createFromRawInstance(dppProvider.dpp.DataContractNAPI.fromHex(hex, fullValidation, valueToDynamicValue(platformVersion)));
+    }
+    static fromBase64(base64, fullValidation, platformVersion) {
+        return DataContractWASM.createFromRawInstance(dppProvider.dpp.DataContractNAPI.fromBase64(base64, fullValidation, valueToDynamicValue(platformVersion)));
+    }
+    static generateId(ownerId, identityNonce) {
+        return IdentifierWASM.createFromRawInstance(dppProvider.dpp.DataContractNAPI.generateId(prepareIdentifierValue(ownerId), identityNonce.toString()));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDataContract = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/DataContractTransitions/DataContractCreateTransition.d.ts

@@ -0,0 +1,23 @@
+import { DataContractCreateTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { DataContractWASM } from '../DataContract.js';
+import { PlatformVersionLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class DataContractCreateTransitionWASM {
+    /** @private **/
+    _rawDataContractCreateTransition: DataContractCreateTransitionNAPI;
+    constructor(dataContract: DataContractWASM, identityNonce: bigint, platformVersion?: PlatformVersionLike);
+    get featureVersion(): number;
+    get identityNonce(): bigint;
+    verifyProtocolVersion(protocolVersion: number): boolean;
+    setDataContract(dataContract: DataContractWASM, platformVersion?: PlatformVersionLike): void;
+    getDataContract(platformVersion?: PlatformVersionLike, fullValidation?: boolean): DataContractWASM;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    toStateTransition(): StateTransitionWASM;
+    static fromBytes(bytes: Uint8Array): DataContractCreateTransitionWASM;
+    static fromHex(hex: string): DataContractCreateTransitionWASM;
+    static fromBase64(base64: string): DataContractCreateTransitionWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): DataContractCreateTransitionWASM;
+    static createFromRawInstance(rawInstance: DataContractCreateTransitionNAPI): DataContractCreateTransitionWASM;
+}

package/dist/src/dpp/structs/DataContractTransitions/DataContractCreateTransition.js

@@ -0,0 +1,55 @@
+import { DataContractWASM } from '../DataContract.js';
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class DataContractCreateTransitionWASM {
+    /** @private **/
+    _rawDataContractCreateTransition;
+    constructor(dataContract, identityNonce, platformVersion) {
+        this._rawDataContractCreateTransition = new dppProvider.dpp.DataContractCreateTransitionNAPI(dataContract._rawDataContract, identityNonce.toString(), valueToDynamicValue(platformVersion));
+    }
+    get featureVersion() {
+        return this._rawDataContractCreateTransition.featureVersion;
+    }
+    get identityNonce() {
+        return BigInt(this._rawDataContractCreateTransition.identityNonce);
+    }
+    verifyProtocolVersion(protocolVersion) {
+        return this._rawDataContractCreateTransition.verifyProtocolVersion(protocolVersion);
+    }
+    setDataContract(dataContract, platformVersion) {
+        this._rawDataContractCreateTransition.setDataContract(dataContract._rawDataContract, valueToDynamicValue(platformVersion));
+    }
+    getDataContract(platformVersion, fullValidation) {
+        return DataContractWASM.createFromRawInstance(this._rawDataContractCreateTransition.getDataContract(valueToDynamicValue(platformVersion), fullValidation));
+    }
+    bytes() {
+        return this._rawDataContractCreateTransition.bytes();
+    }
+    hex() {
+        return this._rawDataContractCreateTransition.hex();
+    }
+    base64() {
+        return this._rawDataContractCreateTransition.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawDataContractCreateTransition.toStateTransition());
+    }
+    static fromBytes(bytes) {
+        return DataContractCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.DataContractCreateTransitionNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return DataContractCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.DataContractCreateTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return DataContractCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.DataContractCreateTransitionNAPI.fromBase64(base64));
+    }
+    static fromStateTransition(stateTransition) {
+        return DataContractCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.DataContractCreateTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDataContractCreateTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/DataContractTransitions/DataContractUpdateTransition.d.ts

@@ -0,0 +1,23 @@
+import { DataContractUpdateTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { DataContractWASM } from '../DataContract.js';
+import { PlatformVersionLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class DataContractUpdateTransitionWASM {
+    /** @private **/
+    _rawDataContractUpdateTransition: DataContractUpdateTransitionNAPI;
+    constructor(dataContract: DataContractWASM, identityNonce: bigint, platformVersion?: PlatformVersionLike);
+    get featureVersion(): number;
+    get identityContractNonce(): bigint;
+    verifyProtocolVersion(protocolVersion: number): boolean;
+    setDataContract(dataContract: DataContractWASM, platformVersion?: PlatformVersionLike): void;
+    getDataContract(fullValidation?: boolean, platformVersion?: PlatformVersionLike): DataContractWASM;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    toStateTransition(): StateTransitionWASM;
+    static fromBytes(bytes: Uint8Array): DataContractUpdateTransitionWASM;
+    static fromHex(hex: string): DataContractUpdateTransitionWASM;
+    static fromBase64(base64: string): DataContractUpdateTransitionWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): DataContractUpdateTransitionWASM;
+    static createFromRawInstance(rawInstance: DataContractUpdateTransitionNAPI): DataContractUpdateTransitionWASM;
+}

package/dist/src/dpp/structs/DataContractTransitions/DataContractUpdateTransition.js

@@ -0,0 +1,55 @@
+import { DataContractWASM } from '../DataContract.js';
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class DataContractUpdateTransitionWASM {
+    /** @private **/
+    _rawDataContractUpdateTransition;
+    constructor(dataContract, identityNonce, platformVersion) {
+        this._rawDataContractUpdateTransition = new dppProvider.dpp.DataContractUpdateTransitionNAPI(dataContract._rawDataContract, identityNonce.toString(), valueToDynamicValue(platformVersion));
+    }
+    get featureVersion() {
+        return this._rawDataContractUpdateTransition.featureVersion;
+    }
+    get identityContractNonce() {
+        return BigInt(this._rawDataContractUpdateTransition.identityContractNonce);
+    }
+    verifyProtocolVersion(protocolVersion) {
+        return this._rawDataContractUpdateTransition.verifyProtocolVersion(protocolVersion);
+    }
+    setDataContract(dataContract, platformVersion) {
+        this._rawDataContractUpdateTransition.setDataContract(dataContract._rawDataContract, valueToDynamicValue(platformVersion));
+    }
+    getDataContract(fullValidation, platformVersion) {
+        return DataContractWASM.createFromRawInstance(this._rawDataContractUpdateTransition.getDataContract(fullValidation, valueToDynamicValue(platformVersion)));
+    }
+    bytes() {
+        return this._rawDataContractUpdateTransition.bytes();
+    }
+    hex() {
+        return this._rawDataContractUpdateTransition.hex();
+    }
+    base64() {
+        return this._rawDataContractUpdateTransition.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawDataContractUpdateTransition.toStateTransition());
+    }
+    static fromBytes(bytes) {
+        return DataContractUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.DataContractUpdateTransitionNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return DataContractUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.DataContractUpdateTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return DataContractUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.DataContractUpdateTransitionNAPI.fromBase64(base64));
+    }
+    static fromStateTransition(stateTransition) {
+        return DataContractUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.DataContractUpdateTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDataContractUpdateTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,51 @@
+import { DocumentNAPI } from '../../../binaries/bindingsTypes.js';
+import { IdentifierLike, PlatformVersionLike } from '../types.js';
+import { IdentifierWASM } from './Identifier.js';
+import { DataContractWASM } from './DataContract.js';
+export declare class DocumentWASM {
+    /** @private **/
+    _rawDocument: DocumentNAPI;
+    constructor(documentContent: object, documentTypeName: string, revision: bigint, dataContractId: IdentifierLike, ownerId: IdentifierLike, documentId?: IdentifierLike, creatorId?: IdentifierLike);
+    get id(): IdentifierWASM;
+    set id(id: IdentifierWASM);
+    get entropy(): Uint8Array | undefined;
+    set entropy(value: Uint8Array | undefined);
+    get dataContractId(): IdentifierWASM;
+    set dataContractId(value: IdentifierLike);
+    get ownerId(): IdentifierWASM;
+    set ownerId(value: IdentifierLike);
+    get properties(): object;
+    set properties(value: object);
+    get revision(): bigint | undefined;
+    set revision(value: bigint | undefined);
+    get createdAt(): bigint | undefined;
+    set createdAt(timestamp: Date | number | bigint | undefined);
+    get updatedAt(): bigint | undefined;
+    set updatedAt(timestamp: Date | number | bigint | undefined);
+    get transferredAt(): bigint | undefined;
+    set transferredAt(timestamp: Date | number | bigint | undefined);
+    get createdAtBlockHeight(): bigint | undefined;
+    set createdAtBlockHeight(value: bigint | undefined);
+    get updatedAtBlockHeight(): bigint | undefined;
+    set updatedAtBlockHeight(value: bigint | undefined);
+    get transferredAtBlockHeight(): bigint | undefined;
+    set transferredAtBlockHeight(value: bigint | undefined);
+    get createdAtCoreBlockHeight(): number | undefined;
+    set createdAtCoreBlockHeight(value: number | undefined);
+    get updatedAtCoreBlockHeight(): number | undefined;
+    set updatedAtCoreBlockHeight(value: number | undefined);
+    get transferredAtCoreBlockHeight(): number | undefined;
+    set transferredAtCoreBlockHeight(value: number | undefined);
+    get documentTypeName(): string;
+    set documentTypeName(value: string);
+    get creatorId(): IdentifierWASM | undefined;
+    set creatorId(value: IdentifierLike);
+    bytes(dataContract: DataContractWASM, platformVersion?: PlatformVersionLike): Uint8Array;
+    hex(dataContract: DataContractWASM, platformVersion?: PlatformVersionLike): string;
+    base64(dataContract: DataContractWASM, platformVersion?: PlatformVersionLike): string;
+    static fromBytes(bytes: Uint8Array, dataContract: DataContractWASM, documentTypeName: string, platformVersion?: PlatformVersionLike): DocumentWASM;
+    static fromHex(hex: string, dataContract: DataContractWASM, documentTypeName: string, platformVersion?: PlatformVersionLike): DocumentWASM;
+    static fromBase64(base64: string, dataContract: DataContractWASM, documentTypeName: string, platformVersion?: PlatformVersionLike): DocumentWASM;
+    static generateId(documentTypeName: string, ownerId: IdentifierLike, dataContractId: IdentifierLike, entropy?: Uint8Array): IdentifierWASM;
+    static createFromRawInstance(rawInstance: DocumentNAPI): DocumentWASM;
+}

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

@@ -0,0 +1,184 @@
+import { dppProvider } from '../provider.js';
+import { prepareIdentifierValue, valueFromDynamicValue, valueToDynamicValue } from '../utils.js';
+import { IdentifierWASM } from './Identifier.js';
+export class DocumentWASM {
+    /** @private **/
+    _rawDocument;
+    constructor(documentContent, documentTypeName, revision, dataContractId, ownerId, documentId, creatorId) {
+        this._rawDocument = new dppProvider.dpp.DocumentNAPI(valueToDynamicValue(documentContent), documentTypeName, revision.toString(), prepareIdentifierValue(dataContractId), prepareIdentifierValue(ownerId), documentId != null ? prepareIdentifierValue(documentId) : undefined, creatorId != null ? prepareIdentifierValue(creatorId) : undefined);
+    }
+    get id() {
+        return IdentifierWASM.createFromRawInstance(this._rawDocument.id);
+    }
+    set id(id) {
+        this._rawDocument.id = id._rawIdentifier;
+    }
+    get entropy() {
+        return this._rawDocument.entropy ?? undefined;
+    }
+    set entropy(value) {
+        this._rawDocument.entropy = value;
+    }
+    get dataContractId() {
+        return IdentifierWASM.createFromRawInstance(this._rawDocument.dataContractId);
+    }
+    set dataContractId(value) {
+        this._rawDocument.dataContractId = prepareIdentifierValue(value);
+    }
+    get ownerId() {
+        return IdentifierWASM.createFromRawInstance(this._rawDocument.ownerId);
+    }
+    set ownerId(value) {
+        this._rawDocument.ownerId = prepareIdentifierValue(value);
+    }
+    get properties() {
+        return valueFromDynamicValue(this._rawDocument.properties);
+    }
+    set properties(value) {
+        this._rawDocument.properties = valueToDynamicValue(value);
+    }
+    get revision() {
+        const revision = this._rawDocument.revision;
+        return revision != null ? BigInt(revision) : undefined;
+    }
+    set revision(value) {
+        this._rawDocument.revision = value?.toString();
+    }
+    get createdAt() {
+        const createdAt = this._rawDocument.createdAt;
+        if (createdAt != null) {
+            return BigInt(createdAt);
+        }
+    }
+    set createdAt(timestamp) {
+        if (timestamp instanceof Date) {
+            this._rawDocument.createdAt = timestamp.getTime().toString();
+        }
+        else if (timestamp == null) {
+            this._rawDocument.createdAt = undefined;
+        }
+        else {
+            this._rawDocument.createdAt = timestamp.toString();
+        }
+    }
+    get updatedAt() {
+        const updatedAt = this._rawDocument.updatedAt;
+        if (updatedAt != null) {
+            return BigInt(updatedAt);
+        }
+    }
+    set updatedAt(timestamp) {
+        if (timestamp instanceof Date) {
+            this._rawDocument.updatedAt = timestamp.getTime().toString();
+        }
+        else if (timestamp == null) {
+            this._rawDocument.updatedAt = undefined;
+        }
+        else {
+            this._rawDocument.updatedAt = timestamp.toString();
+        }
+    }
+    get transferredAt() {
+        const transferredAt = this._rawDocument.transferredAt;
+        if (transferredAt != null) {
+            return BigInt(transferredAt);
+        }
+    }
+    set transferredAt(timestamp) {
+        if (timestamp instanceof Date) {
+            this._rawDocument.transferredAt = timestamp.getTime().toString();
+        }
+        else if (timestamp == null) {
+            this._rawDocument.transferredAt = undefined;
+        }
+        else {
+            this._rawDocument.transferredAt = timestamp.toString();
+        }
+    }
+    get createdAtBlockHeight() {
+        const createdAtBlockHeight = this._rawDocument.createdAtBlockHeight;
+        if (createdAtBlockHeight != null) {
+            return BigInt(createdAtBlockHeight);
+        }
+    }
+    set createdAtBlockHeight(value) {
+        this._rawDocument.createdAtBlockHeight = value?.toString();
+    }
+    get updatedAtBlockHeight() {
+        const updatedAtBlockHeight = this._rawDocument.createdAtBlockHeight;
+        if (updatedAtBlockHeight != null) {
+            return BigInt(updatedAtBlockHeight);
+        }
+    }
+    set updatedAtBlockHeight(value) {
+        this._rawDocument.createdAtBlockHeight = value?.toString();
+    }
+    get transferredAtBlockHeight() {
+        const transferredAtBlockHeight = this._rawDocument.createdAtBlockHeight;
+        if (transferredAtBlockHeight != null) {
+            return BigInt(transferredAtBlockHeight);
+        }
+    }
+    set transferredAtBlockHeight(value) {
+        this._rawDocument.createdAtBlockHeight = value?.toString();
+    }
+    get createdAtCoreBlockHeight() {
+        return this._rawDocument.createdAtCoreBlockHeight ?? undefined;
+    }
+    set createdAtCoreBlockHeight(value) {
+        this._rawDocument.createdAtCoreBlockHeight = value;
+    }
+    get updatedAtCoreBlockHeight() {
+        return this._rawDocument.updatedAtCoreBlockHeight ?? undefined;
+    }
+    set updatedAtCoreBlockHeight(value) {
+        this._rawDocument.createdAtCoreBlockHeight = value;
+    }
+    get transferredAtCoreBlockHeight() {
+        return this._rawDocument.transferredAtCoreBlockHeight ?? undefined;
+    }
+    set transferredAtCoreBlockHeight(value) {
+        this._rawDocument.createdAtCoreBlockHeight = value;
+    }
+    get documentTypeName() {
+        return this._rawDocument.documentTypeName;
+    }
+    set documentTypeName(value) {
+        this._rawDocument.documentTypeName = value;
+    }
+    get creatorId() {
+        const id = this._rawDocument.creatorId;
+        if (id != null) {
+            return IdentifierWASM.createFromRawInstance(id);
+        }
+    }
+    set creatorId(value) {
+        this._rawDocument.creatorId = prepareIdentifierValue(value);
+    }
+    bytes(dataContract, platformVersion) {
+        return this._rawDocument.bytes(dataContract._rawDataContract, valueToDynamicValue(platformVersion));
+    }
+    hex(dataContract, platformVersion) {
+        return this._rawDocument.hex(dataContract._rawDataContract, valueToDynamicValue(platformVersion));
+    }
+    base64(dataContract, platformVersion) {
+        return this._rawDocument.base64(dataContract._rawDataContract, valueToDynamicValue(platformVersion));
+    }
+    static fromBytes(bytes, dataContract, documentTypeName, platformVersion) {
+        return DocumentWASM.createFromRawInstance(dppProvider.dpp.DocumentNAPI.fromBytes(bytes, dataContract._rawDataContract, documentTypeName, valueToDynamicValue(platformVersion)));
+    }
+    static fromHex(hex, dataContract, documentTypeName, platformVersion) {
+        return DocumentWASM.createFromRawInstance(dppProvider.dpp.DocumentNAPI.fromHex(hex, dataContract._rawDataContract, documentTypeName, valueToDynamicValue(platformVersion)));
+    }
+    static fromBase64(base64, dataContract, documentTypeName, platformVersion) {
+        return DocumentWASM.createFromRawInstance(dppProvider.dpp.DocumentNAPI.fromBase64(base64, dataContract._rawDataContract, documentTypeName, valueToDynamicValue(platformVersion)));
+    }
+    static generateId(documentTypeName, ownerId, dataContractId, entropy) {
+        return IdentifierWASM.createFromRawInstance(dppProvider.dpp.DocumentNAPI.generateId(documentTypeName, prepareIdentifierValue(ownerId), prepareIdentifierValue(dataContractId), entropy));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDocument = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/EncryptedNote/PrivateEncryptedNote.d.ts

@@ -0,0 +1,13 @@
+import { PrivateEncryptedNoteNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class PrivateEncryptedNoteWASM {
+    /** @private **/
+    _rawEncryptedNote: PrivateEncryptedNoteNAPI;
+    constructor(rootEncryptionKeyIndex: number, derivationEncryptionKeyIndex: number, value: Uint8Array);
+    get rootEncryptionKeyIndex(): number;
+    set rootEncryptionKeyIndex(index: number);
+    get derivationEncryptionKeyIndex(): number;
+    set derivationEncryptionKeyIndex(index: number);
+    get value(): Uint8Array;
+    set value(value: Uint8Array);
+    static createFromRawInstance(rawInstance: PrivateEncryptedNoteNAPI): PrivateEncryptedNoteWASM;
+}

package/dist/src/dpp/structs/EncryptedNote/PrivateEncryptedNote.js

@@ -0,0 +1,31 @@
+import { dppProvider } from '../../provider.js';
+export class PrivateEncryptedNoteWASM {
+    /** @private **/
+    _rawEncryptedNote;
+    constructor(rootEncryptionKeyIndex, derivationEncryptionKeyIndex, value) {
+        this._rawEncryptedNote = new dppProvider.dpp.PrivateEncryptedNoteNAPI(rootEncryptionKeyIndex, derivationEncryptionKeyIndex, value);
+    }
+    get rootEncryptionKeyIndex() {
+        return this._rawEncryptedNote.rootEncryptionKeyIndex;
+    }
+    set rootEncryptionKeyIndex(index) {
+        this._rawEncryptedNote.rootEncryptionKeyIndex = index;
+    }
+    get derivationEncryptionKeyIndex() {
+        return this._rawEncryptedNote.derivationEncryptionKeyIndex;
+    }
+    set derivationEncryptionKeyIndex(index) {
+        this._rawEncryptedNote.derivationEncryptionKeyIndex = index;
+    }
+    get value() {
+        return this._rawEncryptedNote.value;
+    }
+    set value(value) {
+        this._rawEncryptedNote.value = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawEncryptedNote = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/EncryptedNote/SharedEncryptedNote.d.ts

@@ -0,0 +1,13 @@
+import { SharedEncryptedNoteNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class SharedEncryptedNoteWASM {
+    /** @private **/
+    _rawSharedNote: SharedEncryptedNoteNAPI;
+    constructor(senderKeyIndex: number, recipientKeyIndex: number, value: Uint8Array);
+    get senderKeyIndex(): number;
+    set senderKeyIndex(index: number);
+    get recipientKeyIndex(): number;
+    set recipientKeyIndex(index: number);
+    get value(): Uint8Array;
+    set value(value: Uint8Array);
+    static createFromRawInstance(rawInstance: SharedEncryptedNoteNAPI): SharedEncryptedNoteWASM;
+}

package/dist/src/dpp/structs/EncryptedNote/SharedEncryptedNote.js

@@ -0,0 +1,31 @@
+import { dppProvider } from '../../provider.js';
+export class SharedEncryptedNoteWASM {
+    /** @private **/
+    _rawSharedNote;
+    constructor(senderKeyIndex, recipientKeyIndex, value) {
+        this._rawSharedNote = new dppProvider.dpp.SharedEncryptedNoteNAPI(senderKeyIndex, recipientKeyIndex, value);
+    }
+    get senderKeyIndex() {
+        return this._rawSharedNote.senderKeyIndex;
+    }
+    set senderKeyIndex(index) {
+        this._rawSharedNote.senderKeyIndex = index;
+    }
+    get recipientKeyIndex() {
+        return this._rawSharedNote.recipientKeyIndex;
+    }
+    set recipientKeyIndex(index) {
+        this._rawSharedNote.recipientKeyIndex = index;
+    }
+    get value() {
+        return this._rawSharedNote.value;
+    }
+    set value(value) {
+        this._rawSharedNote.value = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawSharedNote = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { GroupStateTransitionInfoNAPI } from '../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../types.js';
+import { IdentifierWASM } from './Identifier.js';
+export declare class GroupStateTransitionInfoWASM {
+    /** @private **/
+    _rawGroupStateTransitionInfo: GroupStateTransitionInfoNAPI;
+    constructor(groupContractPosition: number, actionId: IdentifierLike, actionIsProposer: boolean);
+    get groupContractPosition(): number;
+    set groupContractPosition(groupContractPosition: number);
+    get actionId(): IdentifierWASM;
+    set actionId(actionId: IdentifierLike);
+    get actionIsProposer(): boolean;
+    set actionIsProposer(actionIsProposer: boolean);
+    static createFromRawInstance(rawInstance: GroupStateTransitionInfoNAPI): GroupStateTransitionInfoWASM;
+}

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

@@ -0,0 +1,33 @@
+import { dppProvider } from '../provider.js';
+import { prepareIdentifierValue } from '../utils.js';
+import { IdentifierWASM } from './Identifier.js';
+export class GroupStateTransitionInfoWASM {
+    /** @private **/
+    _rawGroupStateTransitionInfo;
+    constructor(groupContractPosition, actionId, actionIsProposer) {
+        this._rawGroupStateTransitionInfo = new dppProvider.dpp.GroupStateTransitionInfoNAPI(groupContractPosition, prepareIdentifierValue(actionId), actionIsProposer);
+    }
+    get groupContractPosition() {
+        return this._rawGroupStateTransitionInfo.groupContractPosition;
+    }
+    set groupContractPosition(groupContractPosition) {
+        this._rawGroupStateTransitionInfo.groupContractPosition = groupContractPosition;
+    }
+    get actionId() {
+        return IdentifierWASM.createFromRawInstance(this._rawGroupStateTransitionInfo.actionId);
+    }
+    set actionId(actionId) {
+        this._rawGroupStateTransitionInfo.actionId = prepareIdentifierValue(actionId);
+    }
+    get actionIsProposer() {
+        return this._rawGroupStateTransitionInfo.actionIsProposer;
+    }
+    set actionIsProposer(actionIsProposer) {
+        this._rawGroupStateTransitionInfo.actionIsProposer = actionIsProposer;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawGroupStateTransitionInfo = rawInstance;
+        return instance;
+    }
+}