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

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenDestroyFrozenFundsTransition.d.ts

@@ -0,0 +1,16 @@
+import type { TokenDestroyFrozenFundsTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { IdentifierLike } from '../../../types.js';
+import { IdentifierWASM } from '../../Identifier.js';
+export declare class TokenDestroyFrozenFundsTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenDestroyFrozenFundsTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, frozenIdentityId: IdentifierLike, publicNote?: string);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get frozenIdentityId(): IdentifierWASM;
+    set frozenIdentityId(value: IdentifierLike);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    static createFromRawInstance(rawInstance: TokenDestroyFrozenFundsTransitionNAPI): TokenDestroyFrozenFundsTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenDestroyFrozenFundsTransition.js

@@ -0,0 +1,34 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { dppProvider } from '../../../provider.js';
+import { prepareIdentifierValue } from '../../../utils.js';
+import { IdentifierWASM } from '../../Identifier.js';
+export class TokenDestroyFrozenFundsTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, frozenIdentityId, publicNote) {
+        this._rawTransition = new dppProvider.dpp.TokenDestroyFrozenFundsTransitionNAPI(base._rawTokenBaseTransition, prepareIdentifierValue(frozenIdentityId), publicNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get frozenIdentityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTransition.frozenIdentityId);
+    }
+    set frozenIdentityId(value) {
+        this._rawTransition.frozenIdentityId = prepareIdentifierValue(value);
+    }
+    get publicNote() {
+        return this._rawTransition.publicNote ?? undefined;
+    }
+    set publicNote(value) {
+        this._rawTransition.publicNote = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenDirectPurchaseTransition.d.ts

@@ -0,0 +1,14 @@
+import type { TokenDirectPurchaseTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+export declare class TokenDirectPurchaseTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenDirectPurchaseTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, tokenCount: bigint, totalAgreedPrice: bigint);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get tokenCount(): bigint;
+    set tokenCount(value: bigint);
+    get totalAgreedPrice(): bigint;
+    set totalAgreedPrice(value: bigint);
+    static createFromRawInstance(rawInstance: TokenDirectPurchaseTransitionNAPI): TokenDirectPurchaseTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenDirectPurchaseTransition.js

@@ -0,0 +1,32 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { dppProvider } from '../../../provider.js';
+export class TokenDirectPurchaseTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, tokenCount, totalAgreedPrice) {
+        this._rawTransition = new dppProvider.dpp.TokenDirectPurchaseTransitionNAPI(base._rawTokenBaseTransition, tokenCount.toString(), totalAgreedPrice.toString());
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get tokenCount() {
+        return BigInt(this._rawTransition.tokenCount);
+    }
+    set tokenCount(value) {
+        this._rawTransition.tokenCount = value.toString();
+    }
+    get totalAgreedPrice() {
+        return BigInt(this._rawTransition.totalAgreedPrice);
+    }
+    set totalAgreedPrice(value) {
+        this._rawTransition.totalAgreedPrice = value.toString();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenEmergencyActionTransition.d.ts

@@ -0,0 +1,15 @@
+import type { TokenEmergencyActionTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { TokenEmergencyActionLike } from '../../../types.js';
+export declare class TokenEmergencyActionTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenEmergencyActionTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, emergencyAction: TokenEmergencyActionLike, publicNote?: string);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get emergencyAction(): string;
+    set emergencyAction(value: TokenEmergencyActionLike);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    static createFromRawInstance(rawInstance: TokenEmergencyActionTransitionNAPI): TokenEmergencyActionTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenEmergencyActionTransition.js

@@ -0,0 +1,33 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { dppProvider } from '../../../provider.js';
+import { valueToDynamicValue } from '../../../utils.js';
+export class TokenEmergencyActionTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, emergencyAction, publicNote) {
+        this._rawTransition = new dppProvider.dpp.TokenEmergencyActionTransitionNAPI(base._rawTokenBaseTransition, valueToDynamicValue(emergencyAction), publicNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get emergencyAction() {
+        return this._rawTransition.emergencyAction;
+    }
+    set emergencyAction(value) {
+        this._rawTransition.emergencyAction = valueToDynamicValue(value);
+    }
+    get publicNote() {
+        return this._rawTransition.publicNote ?? undefined;
+    }
+    set publicNote(value) {
+        this._rawTransition.publicNote = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenFreezeTransition.d.ts

@@ -0,0 +1,16 @@
+import type { TokenFreezeTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { IdentifierLike } from '../../../types.js';
+import { IdentifierWASM } from '../../Identifier.js';
+export declare class TokenFreezeTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenFreezeTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, identityIdToFreeze: IdentifierLike, publicNote?: string);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get frozenIdentityId(): IdentifierWASM;
+    set frozenIdentityId(value: IdentifierLike);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    static createFromRawInstance(rawInstance: TokenFreezeTransitionNAPI): TokenFreezeTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenFreezeTransition.js

@@ -0,0 +1,34 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { dppProvider } from '../../../provider.js';
+import { prepareIdentifierValue } from '../../../utils.js';
+import { IdentifierWASM } from '../../Identifier.js';
+export class TokenFreezeTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, identityIdToFreeze, publicNote) {
+        this._rawTransition = new dppProvider.dpp.TokenFreezeTransitionNAPI(base._rawTokenBaseTransition, prepareIdentifierValue(identityIdToFreeze), publicNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get frozenIdentityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTransition.frozenIdentityId);
+    }
+    set frozenIdentityId(value) {
+        this._rawTransition.frozenIdentityId = prepareIdentifierValue(value);
+    }
+    get publicNote() {
+        return this._rawTransition.publicNote ?? undefined;
+    }
+    set publicNote(value) {
+        this._rawTransition.publicNote = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenMintTransition.d.ts

@@ -0,0 +1,18 @@
+import type { TokenMintTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { IdentifierLike } from '../../../types.js';
+import { IdentifierWASM } from '../../Identifier.js';
+export declare class TokenMintTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenMintTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, issueToIdentityId: IdentifierLike | undefined, amount: bigint, publicNote?: string);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get issuedToIdentityId(): IdentifierWASM | undefined;
+    set issuedToIdentityId(value: IdentifierLike | undefined);
+    get amount(): bigint;
+    set amount(value: bigint);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    static createFromRawInstance(rawInstance: TokenMintTransitionNAPI): TokenMintTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenMintTransition.js

@@ -0,0 +1,43 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { dppProvider } from '../../../provider.js';
+import { prepareIdentifierValue } from '../../../utils.js';
+import { IdentifierWASM } from '../../Identifier.js';
+export class TokenMintTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, issueToIdentityId, amount, publicNote) {
+        this._rawTransition = new dppProvider.dpp.TokenMintTransitionNAPI(base._rawTokenBaseTransition, issueToIdentityId != null ? prepareIdentifierValue(issueToIdentityId) : undefined, amount.toString(), publicNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get issuedToIdentityId() {
+        const id = this._rawTransition.issuedToIdentityId;
+        if (id != null) {
+            return IdentifierWASM.createFromRawInstance(id);
+        }
+    }
+    set issuedToIdentityId(value) {
+        this._rawTransition.issuedToIdentityId = value != null ? prepareIdentifierValue(value) : undefined;
+    }
+    get amount() {
+        return BigInt(this._rawTransition.amount);
+    }
+    set amount(value) {
+        this._rawTransition.amount = value.toString();
+    }
+    get publicNote() {
+        return this._rawTransition.publicNote ?? undefined;
+    }
+    set publicNote(value) {
+        this._rawTransition.publicNote = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenSetPriceForDirectPurchaseTransition.d.ts

@@ -0,0 +1,15 @@
+import type { TokenSetPriceForDirectPurchaseTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { TokenPricingScheduleWASM } from '../TokenPricingSchedule.js';
+export declare class TokenSetPriceForDirectPurchaseTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenSetPriceForDirectPurchaseTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, prices?: TokenPricingScheduleWASM, publicNote?: string);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get price(): TokenPricingScheduleWASM | undefined;
+    set price(value: TokenPricingScheduleWASM | undefined);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    static createFromRawInstance(rawInstance: TokenSetPriceForDirectPurchaseTransitionNAPI): TokenSetPriceForDirectPurchaseTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenSetPriceForDirectPurchaseTransition.js

@@ -0,0 +1,36 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { TokenPricingScheduleWASM } from '../TokenPricingSchedule.js';
+import { dppProvider } from '../../../provider.js';
+export class TokenSetPriceForDirectPurchaseTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, prices, publicNote) {
+        this._rawTransition = new dppProvider.dpp.TokenSetPriceForDirectPurchaseTransitionNAPI(base._rawTokenBaseTransition, prices?._rawTokenPricingSchedule, publicNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get price() {
+        const price = this._rawTransition.price;
+        if (price != null) {
+            return TokenPricingScheduleWASM.createFromRawInstance(price);
+        }
+    }
+    set price(value) {
+        this._rawTransition.price = value?._rawTokenPricingSchedule;
+    }
+    get publicNote() {
+        return this._rawTransition.publicNote ?? undefined;
+    }
+    set publicNote(value) {
+        this._rawTransition.publicNote = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenTransferTransition.d.ts

@@ -0,0 +1,21 @@
+import type { TokenTransferTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { IdentifierLike } from '../../../types.js';
+import { SharedEncryptedNoteWASM } from '../../EncryptedNote/SharedEncryptedNote.js';
+import { PrivateEncryptedNoteWASM } from '../../EncryptedNote/PrivateEncryptedNote.js';
+export declare class TokenTransferTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenTransferTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, recipientId: IdentifierLike, amount: bigint, publicNote?: string, sharedEncryptedNote?: SharedEncryptedNoteWASM, privateEncryptedNote?: PrivateEncryptedNoteWASM);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get amount(): bigint;
+    set amount(value: bigint);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    get sharedEncryptedNote(): SharedEncryptedNoteWASM | undefined;
+    set sharedEncryptedNote(value: SharedEncryptedNoteWASM | undefined);
+    get privateEncryptedNote(): PrivateEncryptedNoteWASM | undefined;
+    set privateEncryptedNote(value: PrivateEncryptedNoteWASM | undefined);
+    static createFromRawInstance(rawInstance: TokenTransferTransitionNAPI): TokenTransferTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenTransferTransition.js

@@ -0,0 +1,53 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { SharedEncryptedNoteWASM } from '../../EncryptedNote/SharedEncryptedNote.js';
+import { PrivateEncryptedNoteWASM } from '../../EncryptedNote/PrivateEncryptedNote.js';
+import { dppProvider } from '../../../provider.js';
+import { prepareIdentifierValue } from '../../../utils.js';
+export class TokenTransferTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, recipientId, amount, publicNote, sharedEncryptedNote, privateEncryptedNote) {
+        this._rawTransition = new dppProvider.dpp.TokenTransferTransitionNAPI(base._rawTokenBaseTransition, prepareIdentifierValue(recipientId), amount.toString(), publicNote, sharedEncryptedNote?._rawSharedNote, privateEncryptedNote?._rawEncryptedNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get amount() {
+        return BigInt(this._rawTransition.amount);
+    }
+    set amount(value) {
+        this._rawTransition.amount = value.toString();
+    }
+    get publicNote() {
+        return this._rawTransition.publicNote ?? undefined;
+    }
+    set publicNote(value) {
+        this._rawTransition.publicNote = value;
+    }
+    get sharedEncryptedNote() {
+        const note = this._rawTransition.sharedEncryptedNote;
+        if (note != null) {
+            return SharedEncryptedNoteWASM.createFromRawInstance(note);
+        }
+    }
+    set sharedEncryptedNote(value) {
+        this._rawTransition.sharedEncryptedNote = value?._rawSharedNote;
+    }
+    get privateEncryptedNote() {
+        const note = this._rawTransition.privateEncryptedNote;
+        if (note != null) {
+            return PrivateEncryptedNoteWASM.createFromRawInstance(note);
+        }
+    }
+    set privateEncryptedNote(value) {
+        this._rawTransition.privateEncryptedNote = value?._rawEncryptedNote;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenUnFreezeTransition.d.ts

@@ -0,0 +1,16 @@
+import type { TokenUnFreezeTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { IdentifierLike } from '../../../types.js';
+import { IdentifierWASM } from '../../Identifier.js';
+export declare class TokenUnFreezeTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenUnFreezeTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, frozenIdentityId: IdentifierLike, publicNote?: string);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get frozenIdentityId(): IdentifierWASM;
+    set frozenIdentityId(value: IdentifierLike);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    static createFromRawInstance(rawInstance: TokenUnFreezeTransitionNAPI): TokenUnFreezeTransitionWASM;
+}

package/dist/src/dpp/structs/Batch/TokenTransitions/TokenUnFreezeTransition.js

@@ -0,0 +1,34 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { dppProvider } from '../../../provider.js';
+import { prepareIdentifierValue } from '../../../utils.js';
+import { IdentifierWASM } from '../../Identifier.js';
+export class TokenUnFreezeTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, frozenIdentityId, publicNote) {
+        this._rawTransition = new dppProvider.dpp.TokenUnFreezeTransitionNAPI(base._rawTokenBaseTransition, prepareIdentifierValue(frozenIdentityId), publicNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get frozenIdentityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTransition.frozenIdentityId);
+    }
+    set frozenIdentityId(value) {
+        this._rawTransition.frozenIdentityId = prepareIdentifierValue(value);
+    }
+    get publicNote() {
+        return this._rawTransition.publicNote ?? undefined;
+    }
+    set publicNote(value) {
+        this._rawTransition.publicNote = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { ConsensusErrorNAPI } from '../../../binaries/bindingsTypes.js';
+export declare class ConsensusErrorWASM {
+    /** @private **/
+    _rawConsensusError: ConsensusErrorNAPI;
+    private constructor();
+    static deserialize(error: Uint8Array): ConsensusErrorWASM;
+    get message(): string;
+}

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

@@ -0,0 +1,22 @@
+import { dppProvider } from '../provider.js';
+export class ConsensusErrorWASM {
+    /** @private **/
+    _rawConsensusError;
+    constructor(rawData) {
+        if (rawData instanceof dppProvider.dpp.ConsensusErrorNAPI) {
+            this._rawConsensusError = rawData;
+        }
+        else if (rawData instanceof ConsensusErrorWASM) {
+            this._rawConsensusError = rawData._rawConsensusError;
+        }
+        else {
+            this._rawConsensusError = dppProvider.dpp.ConsensusErrorNAPI.deserialize(rawData);
+        }
+    }
+    static deserialize(error) {
+        return new ConsensusErrorWASM(dppProvider.dpp.ConsensusErrorNAPI.deserialize(error));
+    }
+    get message() {
+        return this._rawConsensusError.message;
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { ContractBoundsNAPI } from '../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../types.js';
+import { IdentifierWASM } from './Identifier.js';
+export declare class ContractBoundsWASM {
+    /** @private **/
+    _rawContractBounds: ContractBoundsNAPI;
+    constructor(contractId: IdentifierLike, documentTypeName?: string);
+    get identifier(): IdentifierWASM;
+    set identifier(value: IdentifierLike);
+    get documentTypeName(): string | null;
+    set documentTypeName(value: string);
+    get contractBoundsType(): string;
+    get contractBoundsTypeNumber(): number;
+    static SingleContract(contractId: IdentifierLike): ContractBoundsWASM;
+    static SingleContractDocumentType(contractId: IdentifierLike, documentTypeName: string): ContractBoundsWASM;
+    static createFromRawInstance(rawInstance: ContractBoundsNAPI): ContractBoundsWASM;
+}

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

@@ -0,0 +1,39 @@
+import { dppProvider } from '../provider.js';
+import { prepareIdentifierValue } from '../utils.js';
+import { IdentifierWASM } from './Identifier.js';
+export class ContractBoundsWASM {
+    /** @private **/
+    _rawContractBounds;
+    constructor(contractId, documentTypeName) {
+        this._rawContractBounds = new dppProvider.dpp.ContractBoundsNAPI(prepareIdentifierValue(contractId), documentTypeName);
+    }
+    get identifier() {
+        return IdentifierWASM.createFromRawInstance(this._rawContractBounds.identifier);
+    }
+    set identifier(value) {
+        this._rawContractBounds.identifier = prepareIdentifierValue(value);
+    }
+    get documentTypeName() {
+        return this._rawContractBounds.documentTypeName;
+    }
+    set documentTypeName(value) {
+        this._rawContractBounds.documentTypeName = value;
+    }
+    get contractBoundsType() {
+        return this._rawContractBounds.contractBoundsType;
+    }
+    get contractBoundsTypeNumber() {
+        return this._rawContractBounds.contractBoundsTypeNumber;
+    }
+    static SingleContract(contractId) {
+        return new ContractBoundsWASM(contractId);
+    }
+    static SingleContractDocumentType(contractId, documentTypeName) {
+        return new ContractBoundsWASM(contractId, documentTypeName);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawContractBounds = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { CoreScriptNAPI } from '../../../binaries/bindingsTypes.js';
+import { NetworkLike } from '../types.js';
+export declare class CoreScriptWASM {
+    _rawCoreScript: CoreScriptNAPI;
+    toAddress(network: NetworkLike): string;
+    toString(): string;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    ASMString(): string;
+    static fromBytes(bytes: Uint8Array): CoreScriptWASM;
+    static newP2PKH(keyHash: Uint8Array): CoreScriptWASM;
+    static newP2SH(scriptHash: Uint8Array): CoreScriptWASM;
+    static createFromRawInstance(rawInstance: CoreScriptNAPI): CoreScriptWASM;
+}

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

@@ -0,0 +1,37 @@
+import { dppProvider } from '../provider.js';
+import { valueToDynamicValue } from '../utils.js';
+export class CoreScriptWASM {
+    _rawCoreScript;
+    toAddress(network) {
+        return this._rawCoreScript.toAddress(valueToDynamicValue(network));
+    }
+    toString() {
+        return this._rawCoreScript.toString();
+    }
+    bytes() {
+        return this._rawCoreScript.bytes();
+    }
+    hex() {
+        return this._rawCoreScript.hex();
+    }
+    base64() {
+        return this._rawCoreScript.base64();
+    }
+    ASMString() {
+        return this._rawCoreScript.ASMString();
+    }
+    static fromBytes(bytes) {
+        return CoreScriptWASM.createFromRawInstance(dppProvider.dpp.CoreScriptNAPI.fromBytes(bytes));
+    }
+    static newP2PKH(keyHash) {
+        return CoreScriptWASM.createFromRawInstance(dppProvider.dpp.CoreScriptNAPI.newP2PKH(keyHash));
+    }
+    static newP2SH(scriptHash) {
+        return CoreScriptWASM.createFromRawInstance(dppProvider.dpp.CoreScriptNAPI.newP2SH(scriptHash));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawCoreScript = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { DataContractNAPI } from '../../../binaries/bindingsTypes.js';
+import { DataContractGroups, DataContractTokens, IdentifierLike, PlatformVersionLike } from '../types.js';
+import { IdentifierWASM } from './Identifier.js';
+export declare class DataContractWASM {
+    /** @private **/
+    _rawDataContract: DataContractNAPI;
+    constructor(ownerId: IdentifierLike, identityNonce: bigint, schema?: object, definitions?: object, tokens?: DataContractTokens[], fullValidation?: boolean, platformVersion?: PlatformVersionLike);
+    get systemVersion(): number;
+    set systemVersion(value: number);
+    get version(): number;
+    set version(value: number);
+    get id(): IdentifierWASM;
+    set id(value: IdentifierLike);
+    get tokens(): DataContractTokens[];
+    set tokens(tokens: DataContractTokens[]);
+    get groups(): DataContractGroups[];
+    set groups(groups: DataContractGroups[]);
+    get description(): string | undefined;
+    set description(value: string | undefined);
+    get keywords(): string[];
+    set keywords(value: string[]);
+    getSchemas(): object;
+    getConfig(): object;
+    setConfig(value: object, platformVersion?: PlatformVersionLike): void;
+    bytes(platformVersion: PlatformVersionLike): Uint8Array;
+    hex(platformVersion: PlatformVersionLike): string;
+    base64(platformVersion: PlatformVersionLike): string;
+    toJSON(platformVersion: PlatformVersionLike): object;
+    toValue(platformVersion: PlatformVersionLike): object;
+    static fromValue(value: object, fullValidation: boolean, platformVersion?: PlatformVersionLike): DataContractWASM;
+    static fromBytes(bytes: Uint8Array, fullValidation: boolean, platformVersion?: PlatformVersionLike): DataContractWASM;
+    static fromHex(hex: string, fullValidation: boolean, platformVersion?: PlatformVersionLike): DataContractWASM;
+    static fromBase64(base64: string, fullValidation: boolean, platformVersion?: PlatformVersionLike): DataContractWASM;
+    static generateId(ownerId: IdentifierLike, identityNonce: bigint): IdentifierWASM;
+    static createFromRawInstance(rawInstance: DataContractNAPI): DataContractWASM;
+}