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

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

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

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

@@ -0,0 +1,19 @@
+import { DocumentTransferTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { DocumentWASM } from '../../Document.js';
+import { IdentifierLike } from '../../../types.js';
+import { TokenPaymentInfoWASM } from '../TokenPaymentInfo.js';
+import { DocumentBaseTransitionWASM } from '../DocumentBaseTransition.js';
+import { IdentifierWASM } from '../../Identifier.js';
+import { DocumentTransitionWASM } from '../DocumentTransition.js';
+export declare class DocumentTransferTransitionWASM {
+    /** @private **/
+    _rawDocumentTransferTransition: DocumentTransferTransitionNAPI;
+    constructor(document: DocumentWASM, identityContractNonce: bigint, recipient: IdentifierLike, tokenPaymentInfo?: TokenPaymentInfoWASM);
+    get base(): DocumentBaseTransitionWASM;
+    set base(value: DocumentBaseTransitionWASM);
+    get recipientId(): IdentifierWASM;
+    set recipientId(value: IdentifierLike);
+    toDocumentTransition(): DocumentTransitionWASM;
+    static fromDocumentTransition(transition: DocumentTransitionWASM): DocumentTransferTransitionWASM;
+    static createFromRawInstance(rawInstance: DocumentTransferTransitionNAPI): DocumentTransferTransitionWASM;
+}

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

@@ -0,0 +1,35 @@
+import { dppProvider } from '../../../provider.js';
+import { prepareIdentifierValue } from '../../../utils.js';
+import { DocumentBaseTransitionWASM } from '../DocumentBaseTransition.js';
+import { IdentifierWASM } from '../../Identifier.js';
+import { DocumentTransitionWASM } from '../DocumentTransition.js';
+export class DocumentTransferTransitionWASM {
+    /** @private **/
+    _rawDocumentTransferTransition;
+    constructor(document, identityContractNonce, recipient, tokenPaymentInfo) {
+        this._rawDocumentTransferTransition = new dppProvider.dpp.DocumentTransferTransitionNAPI(document._rawDocument, identityContractNonce.toString(), prepareIdentifierValue(recipient), tokenPaymentInfo?._rawTokenPaymentInfo);
+    }
+    get base() {
+        return DocumentBaseTransitionWASM.createFromRawInstance(this._rawDocumentTransferTransition.base);
+    }
+    set base(value) {
+        this._rawDocumentTransferTransition.base = value._rawDocumentBaseTransition;
+    }
+    get recipientId() {
+        return IdentifierWASM.createFromRawInstance(this._rawDocumentTransferTransition.recipientId);
+    }
+    set recipientId(value) {
+        this._rawDocumentTransferTransition.recipientId = prepareIdentifierValue(value);
+    }
+    toDocumentTransition() {
+        return DocumentTransitionWASM.createFromRawInstance(this._rawDocumentTransferTransition.toDocumentTransition());
+    }
+    static fromDocumentTransition(transition) {
+        return DocumentTransferTransitionWASM.createFromRawInstance(dppProvider.dpp.DocumentTransferTransitionNAPI.fromDocumentTransition(transition._rawTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawDocumentTransferTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { DocumentUpdatePriceTransitionNAPI } 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 DocumentUpdatePriceTransitionWASM {
+    /** @private **/
+    _rawDocumentUpdatePriceTransition: DocumentUpdatePriceTransitionNAPI;
+    constructor(document: DocumentWASM, identityContractNonce: bigint, price: bigint, tokenPaymentInfo?: TokenPaymentInfoWASM);
+    get base(): DocumentBaseTransitionWASM;
+    set base(value: DocumentBaseTransitionWASM);
+    get price(): bigint;
+    set price(value: bigint);
+    toDocumentTransition(): DocumentTransitionWASM;
+    static fromDocumentTransition(transition: DocumentTransitionWASM): DocumentUpdatePriceTransitionWASM;
+    static createFromRawInstance(rawInstance: DocumentUpdatePriceTransitionNAPI): DocumentUpdatePriceTransitionWASM;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { PrefundedVotingBalanceNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class PrefundedVotingBalanceWASM {
+    /** @private **/
+    _rawPrefundedVotingBalance: PrefundedVotingBalanceNAPI;
+    constructor(indexName: string, credits: bigint);
+    get indexName(): string;
+    get credits(): bigint;
+    static createFromRawInstance(rawInstance: PrefundedVotingBalanceNAPI): PrefundedVotingBalanceWASM;
+}

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

@@ -0,0 +1,19 @@
+import { dppProvider } from '../../provider.js';
+export class PrefundedVotingBalanceWASM {
+    /** @private **/
+    _rawPrefundedVotingBalance;
+    constructor(indexName, credits) {
+        this._rawPrefundedVotingBalance = new dppProvider.dpp.PrefundedVotingBalanceNAPI(indexName, credits?.toString());
+    }
+    get indexName() {
+        return this._rawPrefundedVotingBalance.indexName;
+    }
+    get credits() {
+        return BigInt(this._rawPrefundedVotingBalance.credits);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawPrefundedVotingBalance = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { TokenBaseTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { GroupStateTransitionInfoWASM } from '../GroupStateTransitionInfo.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class TokenBaseTransitionWASM {
+    /** @private **/
+    _rawTokenBaseTransition: TokenBaseTransitionNAPI;
+    constructor(identityContractNonce: bigint, tokenContractPosition: number, dataContractId: IdentifierLike, tokenId: IdentifierLike, usingGroupInfo?: GroupStateTransitionInfoWASM);
+    get identityContractNonce(): bigint;
+    set identityContractNonce(value: bigint);
+    get tokenContractPosition(): number;
+    set tokenContractPosition(value: number);
+    get dataContractId(): IdentifierWASM;
+    set dataContractId(value: IdentifierLike);
+    get tokenId(): IdentifierWASM;
+    set tokenId(value: IdentifierLike);
+    get usingGroupInfo(): GroupStateTransitionInfoWASM | undefined;
+    set usingGroupInfo(value: GroupStateTransitionInfoWASM | undefined);
+    static createFromRawInstance(rawInstance: TokenBaseTransitionNAPI): TokenBaseTransitionWASM;
+}

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

@@ -0,0 +1,49 @@
+import { GroupStateTransitionInfoWASM } from '../GroupStateTransitionInfo.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class TokenBaseTransitionWASM {
+    /** @private **/
+    _rawTokenBaseTransition;
+    constructor(identityContractNonce, tokenContractPosition, dataContractId, tokenId, usingGroupInfo) {
+        this._rawTokenBaseTransition = new dppProvider.dpp.TokenBaseTransitionNAPI(identityContractNonce.toString(), tokenContractPosition, prepareIdentifierValue(dataContractId), prepareIdentifierValue(tokenId), usingGroupInfo?._rawGroupStateTransitionInfo);
+    }
+    get identityContractNonce() {
+        return BigInt(this._rawTokenBaseTransition.identityContractNonce);
+    }
+    set identityContractNonce(value) {
+        this._rawTokenBaseTransition.identityContractNonce = value.toString();
+    }
+    get tokenContractPosition() {
+        return this._rawTokenBaseTransition.tokenContractPosition;
+    }
+    set tokenContractPosition(value) {
+        this._rawTokenBaseTransition.tokenContractPosition = value;
+    }
+    get dataContractId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTokenBaseTransition.dataContractId);
+    }
+    set dataContractId(value) {
+        this._rawTokenBaseTransition.dataContractId = prepareIdentifierValue(value);
+    }
+    get tokenId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTokenBaseTransition.tokenId);
+    }
+    set tokenId(value) {
+        this._rawTokenBaseTransition.tokenId = prepareIdentifierValue(value);
+    }
+    get usingGroupInfo() {
+        const info = this._rawTokenBaseTransition.usingGroupInfo;
+        if (info != null) {
+            return GroupStateTransitionInfoWASM.createFromRawInstance(info);
+        }
+    }
+    set usingGroupInfo(value) {
+        this._rawTokenBaseTransition.usingGroupInfo = value?._rawGroupStateTransitionInfo;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenBaseTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { TokenPaymentInfoNAPI } from '../../../../binaries/bindingsTypes.js';
+import { GasFeesPaidByLike, IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class TokenPaymentInfoWASM {
+    /** @private **/
+    _rawTokenPaymentInfo: TokenPaymentInfoNAPI;
+    constructor(tokenContractPosition: number, paymentTokenContractId?: IdentifierLike, minimumTokenCost?: bigint, maximumTokenCost?: bigint, gasFeesPaidBy?: GasFeesPaidByLike);
+    get paymentTokenContractId(): IdentifierWASM | undefined;
+    set paymentTokenContractId(id: IdentifierWASM | undefined);
+    get tokenContractPosition(): number;
+    set tokenContractPosition(position: number);
+    get minimumTokenCost(): bigint | undefined;
+    set minimumTokenCost(cost: bigint | undefined);
+    get maximumTokenCost(): bigint | undefined;
+    set maximumTokenCost(cost: bigint | undefined);
+    get gasFeesPaidBy(): string;
+    set gasFeesPaidBy(value: GasFeesPaidByLike);
+    static crateFromRawInstance(rawInstance: TokenPaymentInfoNAPI): TokenPaymentInfoWASM;
+}

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

@@ -0,0 +1,54 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class TokenPaymentInfoWASM {
+    /** @private **/
+    _rawTokenPaymentInfo;
+    constructor(tokenContractPosition, paymentTokenContractId, minimumTokenCost, maximumTokenCost, gasFeesPaidBy) {
+        this._rawTokenPaymentInfo = new dppProvider.dpp.TokenPaymentInfoNAPI(paymentTokenContractId != null ? prepareIdentifierValue(paymentTokenContractId) : undefined, tokenContractPosition, minimumTokenCost?.toString(), maximumTokenCost?.toString(), valueToDynamicValue(gasFeesPaidBy));
+    }
+    get paymentTokenContractId() {
+        const id = this._rawTokenPaymentInfo.paymentTokenContractId;
+        if (id != null) {
+            return IdentifierWASM.createFromRawInstance(id);
+        }
+    }
+    set paymentTokenContractId(id) {
+        this._rawTokenPaymentInfo.paymentTokenContractId = id != null ? prepareIdentifierValue(id) : undefined;
+    }
+    get tokenContractPosition() {
+        return this._rawTokenPaymentInfo.tokenContractPosition;
+    }
+    set tokenContractPosition(position) {
+        this._rawTokenPaymentInfo.tokenContractPosition = position;
+    }
+    get minimumTokenCost() {
+        const cost = this._rawTokenPaymentInfo.minimumTokenCost;
+        if (cost != null) {
+            return BigInt(cost);
+        }
+    }
+    set minimumTokenCost(cost) {
+        this._rawTokenPaymentInfo.minimumTokenCost = cost?.toString();
+    }
+    get maximumTokenCost() {
+        const cost = this._rawTokenPaymentInfo.maximumTokenCost;
+        if (cost != null) {
+            return BigInt(cost);
+        }
+    }
+    set maximumTokenCost(cost) {
+        this._rawTokenPaymentInfo.maximumTokenCost = cost?.toString();
+    }
+    get gasFeesPaidBy() {
+        return this._rawTokenPaymentInfo.gasFeesPaidBy;
+    }
+    set gasFeesPaidBy(value) {
+        this._rawTokenPaymentInfo.gasFeesPaidBy = valueToDynamicValue(value);
+    }
+    static crateFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenPaymentInfo = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { TokenPricingScheduleNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class TokenPricingScheduleWASM {
+    /** @private **/
+    _rawTokenPricingSchedule: TokenPricingScheduleNAPI;
+    constructor(prices: bigint | {
+        [key: string]: bigint;
+    });
+    getScheduleType(): string;
+    getValue(): bigint | {
+        [key: string]: string;
+    };
+    static SinglePrice(prices: bigint): TokenPricingScheduleWASM;
+    static SetPrices(prices: {
+        [key: string]: bigint;
+    }): TokenPricingScheduleWASM;
+    static createFromRawInstance(rawInstance: TokenPricingScheduleNAPI): TokenPricingScheduleWASM;
+}

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

@@ -0,0 +1,41 @@
+import { dppProvider } from '../../provider.js';
+import { valueFromDynamicValue, valueToDynamicValue } from '../../utils.js';
+export class TokenPricingScheduleWASM {
+    /** @private **/
+    _rawTokenPricingSchedule;
+    constructor(prices) {
+        if (typeof prices === 'bigint') {
+            return TokenPricingScheduleWASM.SinglePrice(prices);
+        }
+        else {
+            return TokenPricingScheduleWASM.SetPrices(prices);
+        }
+    }
+    getScheduleType() {
+        return this._rawTokenPricingSchedule.getScheduleType();
+    }
+    getValue() {
+        const value = this._rawTokenPricingSchedule.getValue();
+        if (typeof value === 'string') {
+            return BigInt(value);
+        }
+        else {
+            const normalValue = valueFromDynamicValue(value);
+            for (const key of Object.keys(normalValue)) {
+                normalValue[key] = BigInt(normalValue[key]);
+            }
+            return normalValue;
+        }
+    }
+    static SinglePrice(prices) {
+        return TokenPricingScheduleWASM.createFromRawInstance(dppProvider.dpp.TokenPricingScheduleNAPI.SinglePrice(prices.toString()));
+    }
+    static SetPrices(prices) {
+        return TokenPricingScheduleWASM.createFromRawInstance(dppProvider.dpp.TokenPricingScheduleNAPI.SetPrices(valueToDynamicValue(prices)));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenPricingSchedule = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { TokenTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike, TokenTransitionLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class TokenTransitionWASM {
+    /** @private **/
+    _rawTokenTransition: TokenTransitionNAPI;
+    constructor(transition: TokenTransitionLike);
+    get identityContractNonce(): bigint;
+    set identityContractNonce(value: bigint);
+    get tokenId(): IdentifierWASM;
+    set tokenId(value: IdentifierLike);
+    get contractId(): IdentifierWASM;
+    set contractId(value: IdentifierWASM);
+    getTransition(): TokenTransitionLike;
+    getTransitionTypeNumber(): number;
+    getTransitionType(): string;
+    getHistoricalDocumentTypeName(): string;
+    getHistoricalDocumentId(ownerId: IdentifierLike): IdentifierWASM;
+    static createFromRawInstance(rawInstance: TokenTransitionNAPI): TokenTransitionWASM;
+}

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

@@ -0,0 +1,92 @@
+import { dppProvider } from '../../provider.js';
+import { TokenBurnTransitionWASM } from './TokenTransitions/TokenBurnTransition.js';
+import { TokenDestroyFrozenFundsTransitionWASM } from './TokenTransitions/TokenDestroyFrozenFundsTransition.js';
+import { TokenConfigUpdateTransitionWASM } from './TokenTransitions/TokenConfigUpdateTransition.js';
+import { TokenClaimTransitionWASM } from './TokenTransitions/TokenClaimTransition.js';
+import { TokenSetPriceForDirectPurchaseTransitionWASM } from './TokenTransitions/TokenSetPriceForDirectPurchaseTransition.js';
+import { TokenTransferTransitionWASM } from './TokenTransitions/TokenTransferTransition.js';
+import { TokenUnFreezeTransitionWASM } from './TokenTransitions/TokenUnFreezeTransition.js';
+import { TokenMintTransitionWASM } from './TokenTransitions/TokenMintTransition.js';
+import { TokenFreezeTransitionWASM } from './TokenTransitions/TokenFreezeTransition.js';
+import { TokenEmergencyActionTransitionWASM } from './TokenTransitions/TokenEmergencyActionTransition.js';
+import { TokenDirectPurchaseTransitionWASM } from './TokenTransitions/TokenDirectPurchaseTransition.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { prepareIdentifierValue } from '../../utils.js';
+export class TokenTransitionWASM {
+    /** @private **/
+    _rawTokenTransition;
+    constructor(transition) {
+        this._rawTokenTransition = new dppProvider.dpp.TokenTransitionNAPI(transition._rawTransition);
+    }
+    get identityContractNonce() {
+        return BigInt(this._rawTokenTransition.identityContractNonce);
+    }
+    set identityContractNonce(value) {
+        this._rawTokenTransition.identityContractNonce = value.toString();
+    }
+    get tokenId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTokenTransition.tokenId);
+    }
+    set tokenId(value) {
+        this._rawTokenTransition.tokenId = prepareIdentifierValue(value);
+    }
+    get contractId() {
+        return IdentifierWASM.createFromRawInstance(this._rawTokenTransition.contractId);
+    }
+    set contractId(value) {
+        this._rawTokenTransition.contractId = prepareIdentifierValue(value);
+    }
+    getTransition() {
+        const transition = this._rawTokenTransition.getTransition();
+        if (transition instanceof dppProvider.dpp.TokenBurnTransitionNAPI) {
+            return TokenBurnTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenClaimTransitionNAPI) {
+            return TokenClaimTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenConfigUpdateTransitionNAPI) {
+            return TokenConfigUpdateTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenDestroyFrozenFundsTransitionNAPI) {
+            return TokenDestroyFrozenFundsTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenDirectPurchaseTransitionNAPI) {
+            return TokenDirectPurchaseTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenEmergencyActionTransitionNAPI) {
+            return TokenEmergencyActionTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenFreezeTransitionNAPI) {
+            return TokenFreezeTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenMintTransitionNAPI) {
+            return TokenMintTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenSetPriceForDirectPurchaseTransitionNAPI) {
+            return TokenSetPriceForDirectPurchaseTransitionWASM.createFromRawInstance(transition);
+        }
+        else if (transition instanceof dppProvider.dpp.TokenTransferTransitionNAPI) {
+            return TokenTransferTransitionWASM.createFromRawInstance(transition);
+        }
+        else {
+            return TokenUnFreezeTransitionWASM.createFromRawInstance(transition);
+        }
+    }
+    getTransitionTypeNumber() {
+        return this._rawTokenTransition.getTransitionTypeNumber();
+    }
+    getTransitionType() {
+        return this._rawTokenTransition.getTransitionType();
+    }
+    getHistoricalDocumentTypeName() {
+        return this._rawTokenTransition.getHistoricalDocumentTypeName();
+    }
+    getHistoricalDocumentId(ownerId) {
+        return IdentifierWASM.createFromRawInstance(this._rawTokenTransition.getHistoricalDocumentId(prepareIdentifierValue(ownerId)));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(this.prototype);
+        instance._rawTokenTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { TokenBurnTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+export declare class TokenBurnTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenBurnTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, burnAmount: bigint, publicNote?: string);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get burnAmount(): bigint;
+    set burnAmount(value: bigint);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    static createFromRawInstance(rawInstance: TokenBurnTransitionNAPI): TokenBurnTransitionWASM;
+}

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

@@ -0,0 +1,32 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { dppProvider } from '../../../provider.js';
+export class TokenBurnTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, burnAmount, publicNote) {
+        this._rawTransition = new dppProvider.dpp.TokenBurnTransitionNAPI(base._rawTokenBaseTransition, burnAmount.toString(), publicNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get burnAmount() {
+        return BigInt(this._rawTransition.burnAmount);
+    }
+    set burnAmount(value) {
+        this._rawTransition.burnAmount = 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/TokenClaimTransition.d.ts

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

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

@@ -0,0 +1,33 @@
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { dppProvider } from '../../../provider.js';
+import { valueToDynamicValue } from '../../../utils.js';
+export class TokenClaimTransitionWASM {
+    /** @private **/
+    _rawTransition;
+    constructor(base, distributionType, publicNote) {
+        this._rawTransition = new dppProvider.dpp.TokenClaimTransitionNAPI(base._rawTokenBaseTransition, valueToDynamicValue(distributionType), publicNote);
+    }
+    get base() {
+        return TokenBaseTransitionWASM.createFromRawInstance(this._rawTransition.base);
+    }
+    set base(value) {
+        this._rawTransition.base = value._rawTokenBaseTransition;
+    }
+    get distributionType() {
+        return this._rawTransition.distributionType;
+    }
+    set distributionType(value) {
+        this._rawTransition.distributionType = 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/TokenConfigUpdateTransition.d.ts

@@ -0,0 +1,15 @@
+import { TokenConfigUpdateTransitionNAPI } from '../../../../../binaries/bindingsTypes.js';
+import { TokenBaseTransitionWASM } from '../TokenBaseTransition.js';
+import { TokenConfigurationChangeItemWASM } from '../../TokenConfiguration/TokenConfigurationChangeItem.js';
+export declare class TokenConfigUpdateTransitionWASM {
+    /** @private **/
+    _rawTransition: TokenConfigUpdateTransitionNAPI;
+    constructor(base: TokenBaseTransitionWASM, updateTokenConfigurationItem: TokenConfigurationChangeItemWASM, publicNote?: string);
+    get base(): TokenBaseTransitionWASM;
+    set base(value: TokenBaseTransitionWASM);
+    get publicNote(): string | undefined;
+    set publicNote(value: string | undefined);
+    get updateTokenConfigurationItem(): TokenConfigurationChangeItemWASM;
+    set updateTokenConfigurationItem(value: TokenConfigurationChangeItemWASM);
+    static createFromRawInstance(rawInstance: TokenConfigUpdateTransitionNAPI): TokenConfigUpdateTransitionWASM;
+}

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

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