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

package/dist/src/dpp/structs/TokenConfiguration/TokenConfigurationChangeItem.js

@@ -0,0 +1,140 @@
+import { TokenConfigurationConventionWASM } from './TokenConfigurationConvention.js';
+import { AuthorizedActionTakersWASM } from './AuthorizedActionTakers.js';
+import { TokenPerpetualDistributionWASM } from './TokenPerpetualDistribution.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { TokenTradeModeWASM } from './TokenTradeMode.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+export class TokenConfigurationChangeItemWASM {
+    /** @private **/
+    _rawTokenConfigurationChangeItem;
+    constructor(rawInstance) {
+        this._rawTokenConfigurationChangeItem = rawInstance;
+    }
+    getItemName() {
+        return this._rawTokenConfigurationChangeItem.getItemName();
+    }
+    getItem() {
+        const item = this._rawTokenConfigurationChangeItem.getItem();
+        if (item instanceof dppProvider.dpp.TokenConfigurationConventionNAPI) {
+            return TokenConfigurationConventionWASM.createFromRawInstance(item);
+        }
+        else if (item instanceof dppProvider.dpp.AuthorizedActionTakersNAPI) {
+            return AuthorizedActionTakersWASM.createFromRawInstance(item);
+        }
+        else if (item instanceof dppProvider.dpp.TokenPerpetualDistributionNAPI) {
+            return TokenPerpetualDistributionWASM.createFromRawInstance(item);
+        }
+        else if (item instanceof dppProvider.dpp.TokenTradeModeNAPI) {
+            return TokenTradeModeWASM.createFromRawInstance(item);
+        }
+        else if (item instanceof dppProvider.dpp.IdentifierNAPI) {
+            return IdentifierWASM.createFromRawInstance(item);
+        }
+        else if (typeof item === 'string' && this._rawTokenConfigurationChangeItem.getItemName() === 'MaxSupply') {
+            return BigInt(item);
+        }
+        else {
+            return item;
+        }
+    }
+    static ConventionsItem(convention) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.ConventionsItem(convention._rawTokenConfigurationConvention));
+    }
+    static ConventionsAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.ConventionsAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static ConventionsControlGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.ConventionsControlGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static FreezeItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.FreezeItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static FreezeAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.FreezeAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static DestroyFrozenFundsItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.DestroyFrozenFundsItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static DestroyFrozenFundsAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.DestroyFrozenFundsAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static EmergencyActionItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.EmergencyActionItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static EmergencyActionAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.EmergencyActionAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static MainControlGroupItem(groupContractPosition) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MainControlGroupItem(groupContractPosition));
+    }
+    static ManualBurningItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.ManualBurningItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static ManualBurningAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.ManualBurningAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static ManualMintingItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.ManualMintingItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static ManualMintingAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.ManualMintingAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static MarketplaceTradeModeItem(tradeMode) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MarketplaceTradeModeItem(tradeMode._rawTokenTradeMode));
+    }
+    static MarketplaceTradeModeControlGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MarketplaceTradeModeControlGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static MarketplaceTradeModeAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MarketplaceTradeModeAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static MaxSupplyItem(supply) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MaxSupplyItem(supply?.toString()));
+    }
+    static MaxSupplyControlGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MaxSupplyControlGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static MaxSupplyAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MaxSupplyAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static MintingAllowChoosingDestinationItem(flag) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MintingAllowChoosingDestinationItem(flag));
+    }
+    static MintingAllowChoosingDestinationControlGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MintingAllowChoosingDestinationControlGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static MintingAllowChoosingDestinationAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.MintingAllowChoosingDestinationAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static NewTokensDestinationIdentityItem(identityId) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.NewTokensDestinationIdentityItem(identityId != null ? prepareIdentifierValue(identityId) : undefined));
+    }
+    static NewTokensDestinationIdentityControlGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.NewTokensDestinationIdentityControlGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static NewTokensDestinationIdentityAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.NewTokensDestinationIdentityAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static noChangeItem() {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.noChangeItem());
+    }
+    static PerpetualDistributionConfigurationItem(distribution) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.PerpetualDistributionConfigurationItem(distribution?._rawTokenPerpetualDistribution));
+    }
+    static PerpetualDistributionControlGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.PerpetualDistributionControlGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static PerpetualDistributionAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.PerpetualDistributionAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static UnfreezeItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.UnfreezeItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static UnfreezeAdminGroupItem(actionTaker) {
+        return new TokenConfigurationChangeItemWASM(dppProvider.dpp.TokenConfigurationChangeItemNAPI.UnfreezeAdminGroupItem(actionTaker._rawAuthorizedActionTakers));
+    }
+    static createFromRawInstance(rawInstance) {
+        return new TokenConfigurationChangeItemWASM(rawInstance);
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenConfigurationConvention.d.ts

@@ -0,0 +1,19 @@
+import type { TokenConfigurationConventionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { ISO639_CODES } from '../../types.js';
+import { TokenConfigurationLocalizationWASM } from './TokenConfigurationLocalization.js';
+export declare class TokenConfigurationConventionWASM {
+    /** @private **/
+    _rawTokenConfigurationConvention: TokenConfigurationConventionNAPI;
+    constructor(localization: {
+        [key in ISO639_CODES]?: TokenConfigurationLocalizationWASM;
+    }, decimals: number);
+    get decimals(): number;
+    set decimals(value: number);
+    get localizations(): {
+        [key in ISO639_CODES]?: TokenConfigurationLocalizationWASM;
+    };
+    set localizations(localization: {
+        [key in ISO639_CODES]?: TokenConfigurationLocalizationWASM;
+    });
+    static createFromRawInstance(rawInstance: TokenConfigurationConventionNAPI): TokenConfigurationConventionWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenConfigurationConvention.js

@@ -0,0 +1,47 @@
+import { TokenConfigurationLocalizationWASM } from './TokenConfigurationLocalization.js';
+import { dppProvider } from '../../provider.js';
+export class TokenConfigurationConventionWASM {
+    /** @private **/
+    _rawTokenConfigurationConvention;
+    constructor(localization, decimals) {
+        const keys = Object.keys(localization);
+        const normalLocalization = [];
+        for (const key of keys) {
+            if (localization[key] == null) {
+                throw new Error(`Localization cannot be undefined (${key})`);
+            }
+            normalLocalization.push([key, localization[key]._rawTokenConfigurationLocalization]);
+        }
+        this._rawTokenConfigurationConvention = new dppProvider.dpp.TokenConfigurationConventionNAPI(normalLocalization, decimals);
+    }
+    get decimals() {
+        return this._rawTokenConfigurationConvention.decimals;
+    }
+    set decimals(value) {
+        this._rawTokenConfigurationConvention.decimals = value;
+    }
+    get localizations() {
+        const out = {};
+        const localizations = this._rawTokenConfigurationConvention.localizations;
+        for (const [langCode, localization] of localizations) {
+            out[langCode] = TokenConfigurationLocalizationWASM.createFromRawInstance(localization);
+        }
+        return out;
+    }
+    set localizations(localization) {
+        const keys = Object.keys(localization);
+        const normalLocalization = [];
+        for (const key of keys) {
+            if (localization[key] == null) {
+                throw new Error(`Localization cannot be undefined (${key})`);
+            }
+            normalLocalization.push([key, localization[key]._rawTokenConfigurationLocalization]);
+        }
+        this._rawTokenConfigurationConvention.localizations = normalLocalization;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TokenConfigurationConventionWASM.prototype);
+        instance._rawTokenConfigurationConvention = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenConfigurationLocalization.d.ts

@@ -0,0 +1,15 @@
+import type { TokenConfigurationLocalizationNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TokenConfigurationLocalizationJson } from '../../types.js';
+export declare class TokenConfigurationLocalizationWASM {
+    /** @private **/
+    _rawTokenConfigurationLocalization: TokenConfigurationLocalizationNAPI;
+    constructor(shouldCapitalize: boolean, singularForm: string, pluralForm: string);
+    get shouldCapitalize(): boolean;
+    set shouldCapitalize(shouldCapitalize: boolean);
+    get pluralForm(): string;
+    set pluralForm(pluralForm: string);
+    get singularForm(): string;
+    set singularForm(singularForm: string);
+    toJSON(): TokenConfigurationLocalizationJson;
+    static createFromRawInstance(rawInstance: TokenConfigurationLocalizationNAPI): TokenConfigurationLocalizationWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenConfigurationLocalization.js

@@ -0,0 +1,34 @@
+import { dppProvider } from '../../provider.js';
+export class TokenConfigurationLocalizationWASM {
+    /** @private **/
+    _rawTokenConfigurationLocalization;
+    constructor(shouldCapitalize, singularForm, pluralForm) {
+        this._rawTokenConfigurationLocalization = new dppProvider.dpp.TokenConfigurationLocalizationNAPI(shouldCapitalize, singularForm, pluralForm);
+    }
+    get shouldCapitalize() {
+        return this._rawTokenConfigurationLocalization.shouldCapitalize;
+    }
+    set shouldCapitalize(shouldCapitalize) {
+        this._rawTokenConfigurationLocalization.shouldCapitalize = shouldCapitalize;
+    }
+    get pluralForm() {
+        return this._rawTokenConfigurationLocalization.pluralForm;
+    }
+    set pluralForm(pluralForm) {
+        this._rawTokenConfigurationLocalization.pluralForm = pluralForm;
+    }
+    get singularForm() {
+        return this._rawTokenConfigurationLocalization.singularForm;
+    }
+    set singularForm(singularForm) {
+        this._rawTokenConfigurationLocalization.singularForm = singularForm;
+    }
+    toJSON() {
+        return this._rawTokenConfigurationLocalization.toJSON();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TokenConfigurationLocalizationWASM.prototype);
+        instance._rawTokenConfigurationLocalization = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenDistributionRecipient.d.ts

@@ -0,0 +1,14 @@
+import type { TokenDistributionRecipientNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class TokenDistributionRecipientWASM {
+    /** @private **/
+    _rawTokenDistributionRecipient: TokenDistributionRecipientNAPI;
+    private constructor();
+    getType(): string;
+    getValue(): IdentifierWASM | undefined;
+    static ContractOwner(): TokenDistributionRecipientWASM;
+    static Identity(id: IdentifierLike): TokenDistributionRecipientWASM;
+    static EvonodesByParticipation(): TokenDistributionRecipientWASM;
+    static createFromRawInstance(rawInstance: TokenDistributionRecipientNAPI): TokenDistributionRecipientWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenDistributionRecipient.js

@@ -0,0 +1,31 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class TokenDistributionRecipientWASM {
+    /** @private **/
+    _rawTokenDistributionRecipient;
+    constructor(rawInstance) {
+        this._rawTokenDistributionRecipient = rawInstance;
+    }
+    getType() {
+        return this._rawTokenDistributionRecipient.getType();
+    }
+    getValue() {
+        const value = this._rawTokenDistributionRecipient.getValue();
+        if (value !== undefined) {
+            return IdentifierWASM.createFromRawInstance(value);
+        }
+    }
+    static ContractOwner() {
+        return new TokenDistributionRecipientWASM(dppProvider.dpp.TokenDistributionRecipientNAPI.ContractOwner());
+    }
+    static Identity(id) {
+        return new TokenDistributionRecipientWASM(dppProvider.dpp.TokenDistributionRecipientNAPI.Identity(prepareIdentifierValue(id)));
+    }
+    static EvonodesByParticipation() {
+        return new TokenDistributionRecipientWASM(dppProvider.dpp.TokenDistributionRecipientNAPI.EvonodesByParticipation());
+    }
+    static createFromRawInstance(rawInstance) {
+        return new TokenDistributionRecipientWASM(rawInstance);
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenDistributionRules.d.ts

@@ -0,0 +1,28 @@
+import type { TokenDistributionRulesNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TokenPerpetualDistributionWASM } from './TokenPerpetualDistribution.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+import { TokenPreProgrammedDistributionWASM } from './TokenPreProgrammedDistribution.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class TokenDistributionRulesWASM {
+    /** @private **/
+    _rawTokenDistributionRules: TokenDistributionRulesNAPI;
+    constructor(perpetualDistributionRules: ChangeControlRulesWASM, newTokensDestinationIdentityRules: ChangeControlRulesWASM, mintingAllowChoosingDestination: boolean, mintingAllowChoosingDestinationRules: ChangeControlRulesWASM, changeDirectPurchasePricingRules: ChangeControlRulesWASM, perpetualDistribution?: TokenPerpetualDistributionWASM, preProgrammedDistribution?: TokenPreProgrammedDistributionWASM, newTokensDestinationIdentity?: IdentifierLike);
+    get perpetualDistribution(): TokenPerpetualDistributionWASM | undefined;
+    set perpetualDistribution(perpetualDistribution: TokenPerpetualDistributionWASM);
+    get perpetualDistributionRules(): ChangeControlRulesWASM;
+    set perpetualDistributionRules(rules: ChangeControlRulesWASM);
+    get preProgrammedDistribution(): TokenPreProgrammedDistributionWASM | undefined;
+    set preProgrammedDistribution(preProgrammedDistribution: TokenPreProgrammedDistributionWASM);
+    get newTokenDestinationIdentity(): IdentifierWASM | undefined;
+    set newTokenDestinationIdentity(destinationIdentity: IdentifierLike | undefined);
+    get newTokenDestinationIdentityRules(): ChangeControlRulesWASM;
+    set newTokenDestinationIdentityRules(rules: ChangeControlRulesWASM);
+    get mintingAllowChoosingDestination(): boolean;
+    set mintingAllowChoosingDestination(mintingAllowChoosingDestination: boolean);
+    get mintingAllowChoosingDestinationRules(): ChangeControlRulesWASM;
+    set mintingAllowChoosingDestinationRules(mintingAllowChoosingDestinationRules: ChangeControlRulesWASM);
+    get changeDirectPurchasePricingRules(): ChangeControlRulesWASM;
+    set changeDirectPurchasePricingRules(changeDirectPurchasePricingRules: ChangeControlRulesWASM);
+    static createFromRawInstance(rawInstance: TokenDistributionRulesNAPI): TokenDistributionRulesWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenDistributionRules.js

@@ -0,0 +1,75 @@
+import { TokenPerpetualDistributionWASM } from './TokenPerpetualDistribution.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+import { TokenPreProgrammedDistributionWASM } from './TokenPreProgrammedDistribution.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class TokenDistributionRulesWASM {
+    /** @private **/
+    _rawTokenDistributionRules;
+    constructor(perpetualDistributionRules, newTokensDestinationIdentityRules, mintingAllowChoosingDestination, mintingAllowChoosingDestinationRules, changeDirectPurchasePricingRules, perpetualDistribution, preProgrammedDistribution, newTokensDestinationIdentity) {
+        this._rawTokenDistributionRules = new dppProvider.dpp.TokenDistributionRulesNAPI(perpetualDistribution?._rawTokenPerpetualDistribution, perpetualDistributionRules._rawChangeControlRules, preProgrammedDistribution?._rawTokenPreProgrammedDistribution, newTokensDestinationIdentity != null ? prepareIdentifierValue(newTokensDestinationIdentity) : undefined, newTokensDestinationIdentityRules._rawChangeControlRules, mintingAllowChoosingDestination, mintingAllowChoosingDestinationRules?._rawChangeControlRules, changeDirectPurchasePricingRules?._rawChangeControlRules);
+    }
+    get perpetualDistribution() {
+        const dist = this._rawTokenDistributionRules.perpetualDistribution;
+        if (dist != null) {
+            return TokenPerpetualDistributionWASM.createFromRawInstance(dist);
+        }
+    }
+    set perpetualDistribution(perpetualDistribution) {
+        this._rawTokenDistributionRules.perpetualDistribution = perpetualDistribution._rawTokenPerpetualDistribution;
+    }
+    get perpetualDistributionRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenDistributionRules.perpetualDistributionRules);
+    }
+    set perpetualDistributionRules(rules) {
+        this._rawTokenDistributionRules.perpetualDistributionRules = rules._rawChangeControlRules;
+    }
+    get preProgrammedDistribution() {
+        const dist = this._rawTokenDistributionRules.preProgrammedDistribution;
+        if (dist != null) {
+            return TokenPreProgrammedDistributionWASM.createFromRawInstance(dist);
+        }
+    }
+    set preProgrammedDistribution(preProgrammedDistribution) {
+        this._rawTokenDistributionRules.preProgrammedDistribution = preProgrammedDistribution._rawTokenPreProgrammedDistribution;
+    }
+    get newTokenDestinationIdentity() {
+        const destination = this._rawTokenDistributionRules.newTokenDestinationIdentity;
+        if (destination != null) {
+            return IdentifierWASM.createFromRawInstance(destination);
+        }
+    }
+    set newTokenDestinationIdentity(destinationIdentity) {
+        this._rawTokenDistributionRules.newTokenDestinationIdentity = destinationIdentity != null ? prepareIdentifierValue(destinationIdentity) : undefined;
+    }
+    get newTokenDestinationIdentityRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenDistributionRules.newTokenDestinationIdentityRules);
+    }
+    set newTokenDestinationIdentityRules(rules) {
+        this._rawTokenDistributionRules.newTokenDestinationIdentityRules = rules._rawChangeControlRules;
+    }
+    get mintingAllowChoosingDestination() {
+        return this._rawTokenDistributionRules.mintingAllowChoosingDestination;
+    }
+    set mintingAllowChoosingDestination(mintingAllowChoosingDestination) {
+        this._rawTokenDistributionRules.mintingAllowChoosingDestination = mintingAllowChoosingDestination;
+    }
+    get mintingAllowChoosingDestinationRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenDistributionRules.mintingAllowChoosingDestinationRules);
+    }
+    set mintingAllowChoosingDestinationRules(mintingAllowChoosingDestinationRules) {
+        this._rawTokenDistributionRules.mintingAllowChoosingDestinationRules = mintingAllowChoosingDestinationRules._rawChangeControlRules;
+    }
+    get changeDirectPurchasePricingRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenDistributionRules.changeDirectPurchasePricingRules);
+    }
+    set changeDirectPurchasePricingRules(changeDirectPurchasePricingRules) {
+        this._rawTokenDistributionRules.changeDirectPurchasePricingRules = changeDirectPurchasePricingRules._rawChangeControlRules;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TokenDistributionRulesWASM.prototype);
+        instance._rawTokenDistributionRules = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenKeepsHistoryRules.d.ts

@@ -0,0 +1,19 @@
+import type { TokenKeepsHistoryRulesNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class TokenKeepsHistoryRulesWASM {
+    /** @private **/
+    _rawTokenKeepsHistoryRules: TokenKeepsHistoryRulesNAPI;
+    constructor(keepsTransferHistory: boolean, keepsFreezingHistory: boolean, keepsMintingHistory: boolean, keepsBurningHistory: boolean, keepsDirectPricingHistory: boolean, keepsDirectPurchaseHistory: boolean);
+    get keepsTransferHistory(): boolean;
+    set keepsTransferHistory(keepsTransferHistory: boolean);
+    get keepsFreezingHistory(): boolean;
+    set keepsFreezingHistory(keepsFreezingHistory: boolean);
+    get keepsMintingHistory(): boolean;
+    set keepsMintingHistory(keepsMintingHistory: boolean);
+    get keepsBurningHistory(): boolean;
+    set keepsBurningHistory(keepsBurningHistory: boolean);
+    get keepsDirectPricingHistory(): boolean;
+    set keepsDirectPricingHistory(keepsDirectPricingHistory: boolean);
+    get keepsDirectPurchaseHistory(): boolean;
+    set keepsDirectPurchaseHistory(keepsDirectPurchaseHistory: boolean);
+    static createFromRawInstance(rawInstance: TokenKeepsHistoryRulesNAPI): TokenKeepsHistoryRulesWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenKeepsHistoryRules.js

@@ -0,0 +1,49 @@
+import { dppProvider } from '../../provider.js';
+export class TokenKeepsHistoryRulesWASM {
+    /** @private **/
+    _rawTokenKeepsHistoryRules;
+    constructor(keepsTransferHistory, keepsFreezingHistory, keepsMintingHistory, keepsBurningHistory, keepsDirectPricingHistory, keepsDirectPurchaseHistory) {
+        this._rawTokenKeepsHistoryRules = new dppProvider.dpp.TokenKeepsHistoryRulesNAPI(keepsTransferHistory, keepsFreezingHistory, keepsMintingHistory, keepsBurningHistory, keepsDirectPricingHistory, keepsDirectPurchaseHistory);
+    }
+    get keepsTransferHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsTransferHistory;
+    }
+    set keepsTransferHistory(keepsTransferHistory) {
+        this._rawTokenKeepsHistoryRules.keepsTransferHistory = keepsTransferHistory;
+    }
+    get keepsFreezingHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsFreezingHistory;
+    }
+    set keepsFreezingHistory(keepsFreezingHistory) {
+        this._rawTokenKeepsHistoryRules.keepsFreezingHistory = keepsFreezingHistory;
+    }
+    get keepsMintingHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsMintingHistory;
+    }
+    set keepsMintingHistory(keepsMintingHistory) {
+        this._rawTokenKeepsHistoryRules.keepsMintingHistory = keepsMintingHistory;
+    }
+    get keepsBurningHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsBurningHistory;
+    }
+    set keepsBurningHistory(keepsBurningHistory) {
+        this._rawTokenKeepsHistoryRules.keepsBurningHistory = keepsBurningHistory;
+    }
+    get keepsDirectPricingHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsDirectPricingHistory;
+    }
+    set keepsDirectPricingHistory(keepsDirectPricingHistory) {
+        this._rawTokenKeepsHistoryRules.keepsDirectPricingHistory = keepsDirectPricingHistory;
+    }
+    get keepsDirectPurchaseHistory() {
+        return this._rawTokenKeepsHistoryRules.keepsDirectPurchaseHistory;
+    }
+    set keepsDirectPurchaseHistory(keepsDirectPurchaseHistory) {
+        this._rawTokenKeepsHistoryRules.keepsDirectPurchaseHistory = keepsDirectPurchaseHistory;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TokenKeepsHistoryRulesWASM.prototype);
+        instance._rawTokenKeepsHistoryRules = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenMarketplaceRules.d.ts

@@ -0,0 +1,13 @@
+import type { TokenMarketplaceRulesNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TokenTradeModeWASM } from './TokenTradeMode.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+export declare class TokenMarketplaceRulesWASM {
+    /** @private **/
+    _rawTokenMarketplaceRules: TokenMarketplaceRulesNAPI;
+    constructor(tradeMode: TokenTradeModeWASM, tradeModeChangeRules: ChangeControlRulesWASM);
+    get tradeMode(): TokenTradeModeWASM;
+    set tradeMode(value: TokenTradeModeWASM);
+    get tradeModeChangeRules(): ChangeControlRulesWASM;
+    set tradeModeChangeRules(value: ChangeControlRulesWASM);
+    static createFromRawInstance(rawInstance: TokenMarketplaceRulesNAPI): TokenMarketplaceRulesWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenMarketplaceRules.js

@@ -0,0 +1,27 @@
+import { TokenTradeModeWASM } from './TokenTradeMode.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+import { dppProvider } from '../../provider.js';
+export class TokenMarketplaceRulesWASM {
+    /** @private **/
+    _rawTokenMarketplaceRules;
+    constructor(tradeMode, tradeModeChangeRules) {
+        this._rawTokenMarketplaceRules = new dppProvider.dpp.TokenMarketplaceRulesNAPI(tradeMode._rawTokenTradeMode, tradeModeChangeRules._rawChangeControlRules);
+    }
+    get tradeMode() {
+        return TokenTradeModeWASM.createFromRawInstance(this._rawTokenMarketplaceRules.tradeMode);
+    }
+    set tradeMode(value) {
+        this._rawTokenMarketplaceRules.tradeMode = value._rawTokenTradeMode;
+    }
+    get tradeModeChangeRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenMarketplaceRules.tradeModeChangeRules);
+    }
+    set tradeModeChangeRules(value) {
+        this._rawTokenMarketplaceRules.tradeModeChangeRules = value._rawChangeControlRules;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TokenMarketplaceRulesWASM.prototype);
+        instance._rawTokenMarketplaceRules = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenPerpetualDistribution.d.ts

@@ -0,0 +1,13 @@
+import type { TokenPerpetualDistributionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { RewardDistributionTypeWASM } from './RewardDistributionType.js';
+import { TokenDistributionRecipientWASM } from './TokenDistributionRecipient.js';
+export declare class TokenPerpetualDistributionWASM {
+    /** @private **/
+    _rawTokenPerpetualDistribution: TokenPerpetualDistributionNAPI;
+    constructor(rewardDistributionType: RewardDistributionTypeWASM, recipient: TokenDistributionRecipientWASM);
+    get distributionType(): RewardDistributionTypeWASM;
+    set distributionType(value: RewardDistributionTypeWASM);
+    get distributionRecipient(): TokenDistributionRecipientWASM;
+    set distributionRecipient(value: TokenDistributionRecipientWASM);
+    static createFromRawInstance(rawInstance: TokenPerpetualDistributionNAPI): TokenPerpetualDistributionWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenPerpetualDistribution.js

@@ -0,0 +1,27 @@
+import { RewardDistributionTypeWASM } from './RewardDistributionType.js';
+import { TokenDistributionRecipientWASM } from './TokenDistributionRecipient.js';
+import { dppProvider } from '../../provider.js';
+export class TokenPerpetualDistributionWASM {
+    /** @private **/
+    _rawTokenPerpetualDistribution;
+    constructor(rewardDistributionType, recipient) {
+        this._rawTokenPerpetualDistribution = new dppProvider.dpp.TokenPerpetualDistributionNAPI(rewardDistributionType._rawRewardDistributionType, recipient._rawTokenDistributionRecipient);
+    }
+    get distributionType() {
+        return RewardDistributionTypeWASM.createFromRawInstance(this._rawTokenPerpetualDistribution.distributionType);
+    }
+    set distributionType(value) {
+        this._rawTokenPerpetualDistribution.distributionType = value._rawRewardDistributionType;
+    }
+    get distributionRecipient() {
+        return TokenDistributionRecipientWASM.createFromRawInstance(this._rawTokenPerpetualDistribution.distributionRecipient);
+    }
+    set distributionRecipient(value) {
+        this._rawTokenPerpetualDistribution.distributionRecipient = value._rawTokenDistributionRecipient;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TokenPerpetualDistributionWASM.prototype);
+        instance._rawTokenPerpetualDistribution = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenPreProgrammedDistribution.d.ts

@@ -0,0 +1,21 @@
+import type { TokenPreProgrammedDistributionNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class TokenPreProgrammedDistributionWASM {
+    /** @private **/
+    _rawTokenPreProgrammedDistribution: TokenPreProgrammedDistributionNAPI;
+    constructor(distributions: {
+        [timestamp: string]: {
+            [identifier: string]: bigint;
+        };
+    });
+    get distributions(): {
+        [timestamp: string]: {
+            [identifier: string]: bigint;
+        };
+    };
+    set distributions(distributions: {
+        [timestamp: string]: {
+            [identifier: string]: bigint;
+        };
+    });
+    static createFromRawInstance(rawInstance: TokenPreProgrammedDistributionNAPI): TokenPreProgrammedDistributionWASM;
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenPreProgrammedDistribution.js

@@ -0,0 +1,42 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+function objectToDistributionArray(distributions) {
+    const timestamps = Object.keys(distributions);
+    const normalDistribution = [];
+    for (const timestamp of timestamps) {
+        const ids = Object.keys(distributions[timestamp]);
+        const identifiersWithAmount = [];
+        for (const identifier of ids) {
+            identifiersWithAmount.push([prepareIdentifierValue(identifier), distributions[timestamp][identifier].toString()]);
+        }
+        normalDistribution.push([timestamp, identifiersWithAmount]);
+    }
+    return normalDistribution;
+}
+export class TokenPreProgrammedDistributionWASM {
+    /** @private **/
+    _rawTokenPreProgrammedDistribution;
+    constructor(distributions) {
+        this._rawTokenPreProgrammedDistribution = new dppProvider.dpp.TokenPreProgrammedDistributionNAPI(objectToDistributionArray(distributions));
+    }
+    get distributions() {
+        const distributions = this._rawTokenPreProgrammedDistribution.distributions;
+        const out = {};
+        for (const [timestamp, identifiers] of distributions) {
+            const ids = {};
+            for (const [id, amount] of identifiers) {
+                ids[id.base58()] = BigInt(amount);
+            }
+            out[timestamp] = ids;
+        }
+        return out;
+    }
+    set distributions(distributions) {
+        this._rawTokenPreProgrammedDistribution.distributions = objectToDistributionArray(distributions);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TokenPreProgrammedDistributionWASM.prototype);
+        instance._rawTokenPreProgrammedDistribution = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/TokenConfiguration/TokenTradeMode.d.ts

@@ -0,0 +1,9 @@
+import type { TokenTradeModeNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class TokenTradeModeWASM {
+    /** @private **/
+    _rawTokenTradeMode: TokenTradeModeNAPI;
+    private constructor();
+    getValue(): string;
+    static NotTradeable(): TokenTradeModeWASM;
+    static createFromRawInstance(rawInstance: TokenTradeModeNAPI): TokenTradeModeWASM;
+}