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

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

@@ -0,0 +1,23 @@
+import type { ChangeControlRulesNAPI } from '../../../../binaries/bindingsTypes.js';
+import { AuthorizedActionTakersWASM } from './AuthorizedActionTakers.js';
+import { ActionGoalLike, IdentifierLike } from '../../types.js';
+import { GroupWASM } from './Group.js';
+import { ActionTakerWASM } from './ActionTaker.js';
+export declare class ChangeControlRulesWASM {
+    _rawChangeControlRules: ChangeControlRulesNAPI;
+    constructor(authorizedToMakeChanges: AuthorizedActionTakersWASM, adminActionTakers: AuthorizedActionTakersWASM, changingAuthorizedActionTakersToNoOneAllowed: boolean, changingAdminActionTakersToNoOneAllowed: boolean, selfChangingAdminActionTakersAllowed: boolean);
+    get authorizedToMakeChange(): AuthorizedActionTakersWASM;
+    set authorizedToMakeChange(value: AuthorizedActionTakersWASM);
+    get adminActionTakers(): AuthorizedActionTakersWASM;
+    set adminActionTakers(value: AuthorizedActionTakersWASM);
+    get changingAuthorizedActionTakersToNoOneAllowed(): boolean;
+    set changingAuthorizedActionTakersToNoOneAllowed(value: boolean);
+    get changingAdminActionTakersToNoOneAllowed(): boolean;
+    set changingAdminActionTakersToNoOneAllowed(value: boolean);
+    get selfChangingAdminActionTakersAllowed(): boolean;
+    set selfChangingAdminActionTakersAllowed(value: boolean);
+    canChangeAdminActionTakers(adminActionTakers: AuthorizedActionTakersWASM, contractOwnerId: IdentifierLike, groups: {
+        [key: number]: GroupWASM;
+    }, actionTaker: ActionTakerWASM, goal: ActionGoalLike, mainGroup?: number): boolean;
+    static createFromRawInstance(rawInstance: ChangeControlRulesNAPI): ChangeControlRulesWASM;
+}

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

@@ -0,0 +1,52 @@
+import { dppProvider } from '../../provider.js';
+import { AuthorizedActionTakersWASM } from './AuthorizedActionTakers.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+export class ChangeControlRulesWASM {
+    _rawChangeControlRules;
+    constructor(authorizedToMakeChanges, adminActionTakers, changingAuthorizedActionTakersToNoOneAllowed, changingAdminActionTakersToNoOneAllowed, selfChangingAdminActionTakersAllowed) {
+        this._rawChangeControlRules = new dppProvider.dpp.ChangeControlRulesNAPI(authorizedToMakeChanges._rawAuthorizedActionTakers, adminActionTakers._rawAuthorizedActionTakers, changingAuthorizedActionTakersToNoOneAllowed, changingAdminActionTakersToNoOneAllowed, selfChangingAdminActionTakersAllowed);
+    }
+    get authorizedToMakeChange() {
+        return AuthorizedActionTakersWASM.createFromRawInstance(this._rawChangeControlRules.authorizedToMakeChange);
+    }
+    set authorizedToMakeChange(value) {
+        this._rawChangeControlRules.authorizedToMakeChange = value._rawAuthorizedActionTakers;
+    }
+    get adminActionTakers() {
+        return AuthorizedActionTakersWASM.createFromRawInstance(this._rawChangeControlRules.adminActionTakers);
+    }
+    set adminActionTakers(value) {
+        this._rawChangeControlRules.adminActionTakers = value._rawAuthorizedActionTakers;
+    }
+    get changingAuthorizedActionTakersToNoOneAllowed() {
+        return this._rawChangeControlRules.changingAuthorizedActionTakersToNoOneAllowed;
+    }
+    set changingAuthorizedActionTakersToNoOneAllowed(value) {
+        this._rawChangeControlRules.changingAuthorizedActionTakersToNoOneAllowed = value;
+    }
+    get changingAdminActionTakersToNoOneAllowed() {
+        return this._rawChangeControlRules.changingAdminActionTakersToNoOneAllowed;
+    }
+    set changingAdminActionTakersToNoOneAllowed(value) {
+        this._rawChangeControlRules.changingAdminActionTakersToNoOneAllowed = value;
+    }
+    get selfChangingAdminActionTakersAllowed() {
+        return this._rawChangeControlRules.selfChangingAdminActionTakersAllowed;
+    }
+    set selfChangingAdminActionTakersAllowed(value) {
+        this._rawChangeControlRules.selfChangingAdminActionTakersAllowed = value;
+    }
+    canChangeAdminActionTakers(adminActionTakers, contractOwnerId, groups, actionTaker, goal, mainGroup) {
+        const keys = Object.keys(groups);
+        const normalGroups = [];
+        for (const key of keys) {
+            normalGroups.push([Number(key), groups[Number(key)]._rawGroup]);
+        }
+        return this._rawChangeControlRules.canChangeAdminActionTakers(adminActionTakers._rawAuthorizedActionTakers, prepareIdentifierValue(contractOwnerId), mainGroup, normalGroups, actionTaker._rawActionTaker, valueToDynamicValue(goal));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ChangeControlRulesWASM.prototype);
+        instance._rawChangeControlRules = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { DistributionFunctionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { DistributionExponential, DistributionFixedAmount, DistributionInvertedLogarithmic, DistributionLinear, DistributionLogarithmic, DistributionPolynomial, DistributionRandom, DistributionStepDecreasingAmount, DistributionStepwise } from '../../types.js';
+export declare class DistributionFunctionWASM {
+    /** @private **/
+    _rawDistributionFunction: DistributionFunctionNAPI;
+    private constructor();
+    static FixedAmountDistribution(amount: bigint): DistributionFunctionWASM;
+    getFunctionName(): string;
+    getFunctionValue(): DistributionFixedAmount | DistributionRandom | DistributionStepDecreasingAmount | DistributionLinear | DistributionPolynomial | DistributionExponential | DistributionLogarithmic | DistributionInvertedLogarithmic | DistributionStepwise;
+    static Random(min: bigint, max: bigint): DistributionFunctionWASM;
+    static StepDecreasingAmount(stepCount: number, decreasePerIntervalNumerator: number, decreasePerIntervalDenominator: number, distributionStartAmount: bigint, trailingDistributionIntervalAmount: bigint, startDecreasingOffset?: bigint, maxIntervalCount?: number, minValue?: bigint): DistributionFunctionWASM;
+    static Stepwise(steps: DistributionStepwise): DistributionFunctionWASM;
+    static Linear(a: number, d: bigint, startingAmount: bigint, startStep?: bigint, minValue?: bigint, maxValue?: bigint): DistributionFunctionWASM;
+    static Polynomial(a: number, d: bigint, m: number, n: bigint, o: number, b: bigint, startMoment?: bigint, minValue?: bigint, maxValue?: bigint): DistributionFunctionWASM;
+    static Exponential(a: bigint, d: bigint, m: number, n: bigint, o: number, b: bigint, startMoment?: bigint, minValue?: bigint, maxValue?: bigint): DistributionFunctionWASM;
+    static Logarithmic(a: number, d: bigint, m: bigint, n: bigint, o: number, b: bigint, startMoment?: bigint, minValue?: bigint, maxValue?: bigint): DistributionFunctionWASM;
+    static InvertedLogarithmic(a: number, d: bigint, m: bigint, n: bigint, o: number, b: bigint, startMoment?: bigint, minValue?: bigint, maxValue?: bigint): DistributionFunctionWASM;
+    static createFromRawInstance(rawInstance: DistributionFunctionNAPI): DistributionFunctionWASM;
+}

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

@@ -0,0 +1,57 @@
+import { dppProvider } from '../../provider.js';
+export class DistributionFunctionWASM {
+    /** @private **/
+    _rawDistributionFunction;
+    constructor(rawInstance) {
+        this._rawDistributionFunction = rawInstance;
+    }
+    static FixedAmountDistribution(amount) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.FixedAmountDistribution(amount.toString()));
+    }
+    getFunctionName() {
+        return this._rawDistributionFunction.getFunctionName();
+    }
+    getFunctionValue() {
+        const value = this._rawDistributionFunction.getFunctionValue();
+        if (Array.isArray(value)) {
+            // StepWise
+            return value.map(step => ({
+                step: BigInt(step.step),
+                amount: BigInt(step.amount)
+            }));
+        }
+        else {
+            return value;
+        }
+    }
+    static Random(min, max) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.Random(min.toString(), max.toString()));
+    }
+    static StepDecreasingAmount(stepCount, decreasePerIntervalNumerator, decreasePerIntervalDenominator, distributionStartAmount, trailingDistributionIntervalAmount, startDecreasingOffset, maxIntervalCount, minValue) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.StepDecreasingAmount(stepCount, decreasePerIntervalNumerator, decreasePerIntervalDenominator, startDecreasingOffset?.toString(), maxIntervalCount, distributionStartAmount?.toString(), trailingDistributionIntervalAmount?.toString(), minValue?.toString()));
+    }
+    static Stepwise(steps) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.Stepwise(steps.map((step) => ({
+            step: step.step.toString(),
+            amount: step.amount.toString()
+        }))));
+    }
+    static Linear(a, d, startingAmount, startStep, minValue, maxValue) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.Linear(a, d.toString(), startStep?.toString(), startingAmount.toString(), minValue?.toString(), maxValue?.toString()));
+    }
+    static Polynomial(a, d, m, n, o, b, startMoment, minValue, maxValue) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.Polynomial(a, d.toString(), m, n.toString(), o, startMoment?.toString(), b.toString(), minValue?.toString(), maxValue?.toString()));
+    }
+    static Exponential(a, d, m, n, o, b, startMoment, minValue, maxValue) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.Exponential(a.toString(), d.toString(), m, n.toString(), o, startMoment?.toString(), b.toString(), minValue?.toString(), maxValue?.toString()));
+    }
+    static Logarithmic(a, d, m, n, o, b, startMoment, minValue, maxValue) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.Logarithmic(a, d.toString(), m.toString(), n.toString(), o, startMoment?.toString(), b.toString(), minValue?.toString(), maxValue?.toString()));
+    }
+    static InvertedLogarithmic(a, d, m, n, o, b, startMoment, minValue, maxValue) {
+        return new DistributionFunctionWASM(dppProvider.dpp.DistributionFunctionNAPI.InvertedLogarithmic(a, d.toString(), m.toString(), n.toString(), o, startMoment?.toString(), b.toString(), minValue?.toString(), maxValue?.toString()));
+    }
+    static createFromRawInstance(rawInstance) {
+        return new DistributionFunctionWASM(rawInstance);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { GroupNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+export declare class GroupWASM {
+    /** @private **/
+    _rawGroup: GroupNAPI;
+    constructor(members: {
+        [key: string]: number;
+    }, requiredPower: number);
+    get members(): {
+        [key: string]: number;
+    };
+    set members(members: {
+        [key: string]: number;
+    });
+    get requiredPower(): number;
+    set requiredPower(value: number);
+    setMemberRequiredPower(member: IdentifierLike, power: number): void;
+    static createFromRawInstance(rawInstance: GroupNAPI): GroupWASM;
+}

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

@@ -0,0 +1,44 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+export class GroupWASM {
+    /** @private **/
+    _rawGroup;
+    constructor(members, requiredPower) {
+        const keys = Object.keys(members);
+        const normalMembers = [];
+        for (const key of keys) {
+            normalMembers.push([valueToDynamicValue(key), members[key]]);
+        }
+        this._rawGroup = new dppProvider.dpp.GroupNAPI(normalMembers, requiredPower);
+    }
+    get members() {
+        const rawMembers = this._rawGroup.members;
+        const out = {};
+        for (const [id, power] of rawMembers) {
+            out[id.base58()] = power;
+        }
+        return out;
+    }
+    set members(members) {
+        const keys = Object.keys(members);
+        const normalMembers = [];
+        for (const key of keys) {
+            normalMembers.push([valueToDynamicValue(key), members[key]]);
+        }
+        this._rawGroup.members = normalMembers;
+    }
+    get requiredPower() {
+        return this._rawGroup.requiredPower;
+    }
+    set requiredPower(value) {
+        this._rawGroup.requiredPower = value;
+    }
+    setMemberRequiredPower(member, power) {
+        this._rawGroup.setMemberRequiredPower(prepareIdentifierValue(member), power);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(GroupWASM.prototype);
+        instance._rawGroup = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { RewardDistributionTypeNAPI } from '../../../../binaries/bindingsTypes.js';
+import { DistributionFunctionWASM } from './DistributionFunction.js';
+import { RewardDistribution } from '../../types.js';
+export declare class RewardDistributionTypeWASM {
+    /** @private **/
+    _rawRewardDistributionType: RewardDistributionTypeNAPI;
+    private constructor();
+    getDistribution(): RewardDistribution;
+    static BlockBasedDistribution(interval: bigint, distributionFunction: DistributionFunctionWASM): RewardDistributionTypeWASM;
+    static TimeBasedDistribution(interval: bigint, distributionFunction: DistributionFunctionWASM): RewardDistributionTypeWASM;
+    static EpochBasedDistribution(interval: number, distributionFunction: DistributionFunctionWASM): RewardDistributionTypeWASM;
+    static createFromRawInstance(rawInstance: RewardDistributionTypeNAPI): RewardDistributionTypeWASM;
+}

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

@@ -0,0 +1,40 @@
+import { DistributionFunctionWASM } from './DistributionFunction.js';
+import { dppProvider } from '../../provider.js';
+export class RewardDistributionTypeWASM {
+    /** @private **/
+    _rawRewardDistributionType;
+    constructor(rawInstance) {
+        this._rawRewardDistributionType = rawInstance;
+    }
+    getDistribution() {
+        const dist = this._rawRewardDistributionType.getDistribution();
+        const interval = typeof dist.interval === 'number' ? dist.interval : BigInt(dist.interval);
+        let distributionType;
+        if (dist instanceof dppProvider.dpp.BlockBasedDistributionNAPI) {
+            distributionType = 'BlockBasedDistribution';
+        }
+        else if (dist instanceof dppProvider.dpp.TimeBasedDistributionNAPI) {
+            distributionType = 'TimeBasedDistribution';
+        }
+        else {
+            distributionType = 'EpochBasedDistribution';
+        }
+        return {
+            interval,
+            function: DistributionFunctionWASM.createFromRawInstance(dist.function),
+            distributionType
+        };
+    }
+    static BlockBasedDistribution(interval, distributionFunction) {
+        return new RewardDistributionTypeWASM(dppProvider.dpp.RewardDistributionTypeNAPI.BlockBasedDistribution(interval.toString(), distributionFunction._rawDistributionFunction));
+    }
+    static TimeBasedDistribution(interval, distributionFunction) {
+        return new RewardDistributionTypeWASM(dppProvider.dpp.RewardDistributionTypeNAPI.TimeBasedDistribution(interval.toString(), distributionFunction._rawDistributionFunction));
+    }
+    static EpochBasedDistribution(interval, distributionFunction) {
+        return new RewardDistributionTypeWASM(dppProvider.dpp.RewardDistributionTypeNAPI.EpochBasedDistribution(interval, distributionFunction._rawDistributionFunction));
+    }
+    static createFromRawInstance(rawInstance) {
+        return new RewardDistributionTypeWASM(rawInstance);
+    }
+}

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

@@ -0,0 +1,54 @@
+import type { TokenConfigurationNAPI } from '../../../../binaries/bindingsTypes.js';
+import { TokenConfigurationConventionWASM } from './TokenConfigurationConvention.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+import { TokenKeepsHistoryRulesWASM } from './TokenKeepsHistoryRules.js';
+import { TokenDistributionRulesWASM } from './TokenDistributionRules.js';
+import { TokenMarketplaceRulesWASM } from './TokenMarketplaceRules.js';
+import { AuthorizedActionTakersWASM } from './AuthorizedActionTakers.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class TokenConfigurationWASM {
+    /** @private **/
+    _rawTokenConfiguration: TokenConfigurationNAPI;
+    constructor(conventions: TokenConfigurationConventionWASM, conventionsChangeRules: ChangeControlRulesWASM, baseSupply: bigint, keepsHistory: TokenKeepsHistoryRulesWASM, startAsPaused: boolean, allowTransferToFrozenBalance: boolean, maxSupplyChangeRules: ChangeControlRulesWASM, distributionRules: TokenDistributionRulesWASM, marketplaceRules: TokenMarketplaceRulesWASM, manualMintingRules: ChangeControlRulesWASM, manualBurningRules: ChangeControlRulesWASM, freezeRules: ChangeControlRulesWASM, unfreezeRules: ChangeControlRulesWASM, destroyFrozenFundsRules: ChangeControlRulesWASM, emergencyActionRules: ChangeControlRulesWASM, mainControlGroupCanBeModified: AuthorizedActionTakersWASM, maxSupply?: bigint, mainControlGroup?: number, description?: string);
+    get conventions(): TokenConfigurationConventionWASM;
+    set conventions(value: TokenConfigurationConventionWASM);
+    get conventionsChangeRules(): ChangeControlRulesWASM;
+    set conventionsChangeRules(value: ChangeControlRulesWASM);
+    get baseSupply(): bigint;
+    set baseSupply(value: bigint);
+    get keepsHistory(): TokenKeepsHistoryRulesWASM;
+    set keepsHistory(value: TokenKeepsHistoryRulesWASM);
+    get startAsPaused(): boolean;
+    set startAsPaused(value: boolean);
+    get isAllowedTransferToFrozenBalance(): boolean;
+    set isAllowedTransferToFrozenBalance(value: boolean);
+    get maxSupply(): bigint | undefined;
+    set maxSupply(value: bigint | undefined);
+    get maxSupplyChangeRules(): ChangeControlRulesWASM;
+    set maxSupplyChangeRules(value: ChangeControlRulesWASM);
+    get distributionRules(): TokenDistributionRulesWASM;
+    set distributionRules(value: TokenDistributionRulesWASM);
+    get marketplaceRules(): TokenMarketplaceRulesWASM;
+    set marketplaceRules(value: TokenMarketplaceRulesWASM);
+    get manualMintingRules(): ChangeControlRulesWASM;
+    set manualMintingRules(value: ChangeControlRulesWASM);
+    get manualBurningRules(): ChangeControlRulesWASM;
+    set manualBurningRules(value: ChangeControlRulesWASM);
+    get freezeRules(): ChangeControlRulesWASM;
+    set freezeRules(value: ChangeControlRulesWASM);
+    get unfreezeRules(): ChangeControlRulesWASM;
+    set unfreezeRules(value: ChangeControlRulesWASM);
+    get destroyFrozenFundsRules(): ChangeControlRulesWASM;
+    set destroyFrozenFundsRules(value: ChangeControlRulesWASM);
+    get emergencyActionRules(): ChangeControlRulesWASM;
+    set emergencyActionRules(value: ChangeControlRulesWASM);
+    get mainControlGroup(): number | undefined;
+    set mainControlGroup(value: number | undefined);
+    get mainControlGroupCanBeModified(): AuthorizedActionTakersWASM;
+    set mainControlGroupCanBeModified(value: AuthorizedActionTakersWASM);
+    get description(): string | undefined;
+    set description(value: string | undefined);
+    static calculateTokenId(contractId: IdentifierLike, tokenPosition: number): IdentifierWASM;
+    static createFromRawInstance(rawInstance: TokenConfigurationNAPI): TokenConfigurationWASM;
+}

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

@@ -0,0 +1,139 @@
+import { TokenConfigurationConventionWASM } from './TokenConfigurationConvention.js';
+import { ChangeControlRulesWASM } from './ChangeControlRules.js';
+import { TokenKeepsHistoryRulesWASM } from './TokenKeepsHistoryRules.js';
+import { TokenDistributionRulesWASM } from './TokenDistributionRules.js';
+import { TokenMarketplaceRulesWASM } from './TokenMarketplaceRules.js';
+import { AuthorizedActionTakersWASM } from './AuthorizedActionTakers.js';
+import { dppProvider } from '../../provider.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { prepareIdentifierValue } from '../../utils.js';
+export class TokenConfigurationWASM {
+    /** @private **/
+    _rawTokenConfiguration;
+    constructor(conventions, conventionsChangeRules, baseSupply, keepsHistory, startAsPaused, allowTransferToFrozenBalance, maxSupplyChangeRules, distributionRules, marketplaceRules, manualMintingRules, manualBurningRules, freezeRules, unfreezeRules, destroyFrozenFundsRules, emergencyActionRules, mainControlGroupCanBeModified, maxSupply, mainControlGroup, description) {
+        this._rawTokenConfiguration = new dppProvider.dpp.TokenConfigurationNAPI(conventions._rawTokenConfigurationConvention, conventionsChangeRules._rawChangeControlRules, baseSupply.toString(), maxSupply?.toString(), keepsHistory._rawTokenKeepsHistoryRules, startAsPaused, allowTransferToFrozenBalance, maxSupplyChangeRules._rawChangeControlRules, distributionRules._rawTokenDistributionRules, marketplaceRules._rawTokenMarketplaceRules, manualMintingRules._rawChangeControlRules, manualBurningRules._rawChangeControlRules, freezeRules._rawChangeControlRules, unfreezeRules._rawChangeControlRules, destroyFrozenFundsRules._rawChangeControlRules, emergencyActionRules._rawChangeControlRules, mainControlGroup, mainControlGroupCanBeModified?._rawAuthorizedActionTakers, description);
+    }
+    get conventions() {
+        return TokenConfigurationConventionWASM.createFromRawInstance(this._rawTokenConfiguration.conventions);
+    }
+    set conventions(value) {
+        this._rawTokenConfiguration.conventions = value._rawTokenConfigurationConvention;
+    }
+    get conventionsChangeRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenConfiguration.conventionsChangeRules);
+    }
+    set conventionsChangeRules(value) {
+        this._rawTokenConfiguration.conventionsChangeRules = value._rawChangeControlRules;
+    }
+    get baseSupply() {
+        return BigInt(this._rawTokenConfiguration.baseSupply);
+    }
+    set baseSupply(value) {
+        this._rawTokenConfiguration.baseSupply = value.toString();
+    }
+    get keepsHistory() {
+        return TokenKeepsHistoryRulesWASM.createFromRawInstance(this._rawTokenConfiguration.keepsHistory);
+    }
+    set keepsHistory(value) {
+        this._rawTokenConfiguration.keepsHistory = value._rawTokenKeepsHistoryRules;
+    }
+    get startAsPaused() {
+        return this._rawTokenConfiguration.startAsPaused;
+    }
+    set startAsPaused(value) {
+        this._rawTokenConfiguration.startAsPaused = value;
+    }
+    get isAllowedTransferToFrozenBalance() {
+        return this._rawTokenConfiguration.isAllowedTransferToFrozenBalance;
+    }
+    set isAllowedTransferToFrozenBalance(value) {
+        this._rawTokenConfiguration.isAllowedTransferToFrozenBalance = value;
+    }
+    get maxSupply() {
+        const supply = this._rawTokenConfiguration.maxSupply;
+        return supply != null ? BigInt(supply) : undefined;
+    }
+    set maxSupply(value) {
+        this._rawTokenConfiguration.maxSupply = value?.toString();
+    }
+    get maxSupplyChangeRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenConfiguration.maxSupplyChangeRules);
+    }
+    set maxSupplyChangeRules(value) {
+        this._rawTokenConfiguration.maxSupplyChangeRules = value._rawChangeControlRules;
+    }
+    get distributionRules() {
+        return TokenDistributionRulesWASM.createFromRawInstance(this._rawTokenConfiguration.distributionRules);
+    }
+    set distributionRules(value) {
+        this._rawTokenConfiguration.distributionRules = value._rawTokenDistributionRules;
+    }
+    get marketplaceRules() {
+        return TokenMarketplaceRulesWASM.createFromRawInstance(this._rawTokenConfiguration.marketplaceRules);
+    }
+    set marketplaceRules(value) {
+        this._rawTokenConfiguration.marketplaceRules = value._rawTokenMarketplaceRules;
+    }
+    get manualMintingRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenConfiguration.manualMintingRules);
+    }
+    set manualMintingRules(value) {
+        this._rawTokenConfiguration.manualMintingRules = value._rawChangeControlRules;
+    }
+    get manualBurningRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenConfiguration.manualBurningRules);
+    }
+    set manualBurningRules(value) {
+        this._rawTokenConfiguration.manualBurningRules = value._rawChangeControlRules;
+    }
+    get freezeRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenConfiguration.freezeRules);
+    }
+    set freezeRules(value) {
+        this._rawTokenConfiguration.freezeRules = value._rawChangeControlRules;
+    }
+    get unfreezeRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenConfiguration.unfreezeRules);
+    }
+    set unfreezeRules(value) {
+        this._rawTokenConfiguration.unfreezeRules = value._rawChangeControlRules;
+    }
+    get destroyFrozenFundsRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenConfiguration.destroyFrozenFundsRules);
+    }
+    set destroyFrozenFundsRules(value) {
+        this._rawTokenConfiguration.destroyFrozenFundsRules = value._rawChangeControlRules;
+    }
+    get emergencyActionRules() {
+        return ChangeControlRulesWASM.createFromRawInstance(this._rawTokenConfiguration.emergencyActionRules);
+    }
+    set emergencyActionRules(value) {
+        this._rawTokenConfiguration.emergencyActionRules = value._rawChangeControlRules;
+    }
+    get mainControlGroup() {
+        return this._rawTokenConfiguration.mainControlGroup ?? undefined;
+    }
+    set mainControlGroup(value) {
+        this._rawTokenConfiguration.mainControlGroup = value;
+    }
+    get mainControlGroupCanBeModified() {
+        return AuthorizedActionTakersWASM.createFromRawInstance(this._rawTokenConfiguration.mainControlGroupCanBeModified);
+    }
+    set mainControlGroupCanBeModified(value) {
+        this._rawTokenConfiguration.mainControlGroupCanBeModified = value._rawAuthorizedActionTakers;
+    }
+    get description() {
+        return this._rawTokenConfiguration.description ?? undefined;
+    }
+    set description(value) {
+        this._rawTokenConfiguration.description = value;
+    }
+    static calculateTokenId(contractId, tokenPosition) {
+        return IdentifierWASM.createFromRawInstance(dppProvider.dpp.TokenConfigurationNAPI.calculateTokenId(prepareIdentifierValue(contractId), tokenPosition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(TokenConfigurationWASM.prototype);
+        instance._rawTokenConfiguration = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,47 @@
+import type { TokenConfigurationChangeItemNAPI } from '../../../../binaries/bindingsTypes.js';
+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 { IdentifierLike } from '../../types.js';
+export declare class TokenConfigurationChangeItemWASM {
+    /** @private **/
+    _rawTokenConfigurationChangeItem: TokenConfigurationChangeItemNAPI;
+    private constructor();
+    getItemName(): string;
+    getItem(): string | TokenConfigurationConventionWASM | AuthorizedActionTakersWASM | bigint | TokenPerpetualDistributionWASM | IdentifierWASM | boolean | TokenTradeModeWASM | number | undefined | null;
+    static ConventionsItem(convention: TokenConfigurationConventionWASM): TokenConfigurationChangeItemWASM;
+    static ConventionsAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static ConventionsControlGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static FreezeItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static FreezeAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static DestroyFrozenFundsItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static DestroyFrozenFundsAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static EmergencyActionItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static EmergencyActionAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static MainControlGroupItem(groupContractPosition?: number): TokenConfigurationChangeItemWASM;
+    static ManualBurningItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static ManualBurningAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static ManualMintingItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static ManualMintingAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static MarketplaceTradeModeItem(tradeMode: TokenTradeModeWASM): TokenConfigurationChangeItemWASM;
+    static MarketplaceTradeModeControlGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static MarketplaceTradeModeAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static MaxSupplyItem(supply?: bigint): TokenConfigurationChangeItemWASM;
+    static MaxSupplyControlGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static MaxSupplyAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static MintingAllowChoosingDestinationItem(flag: boolean): TokenConfigurationChangeItemWASM;
+    static MintingAllowChoosingDestinationControlGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static MintingAllowChoosingDestinationAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static NewTokensDestinationIdentityItem(identityId?: IdentifierLike): TokenConfigurationChangeItemWASM;
+    static NewTokensDestinationIdentityControlGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static NewTokensDestinationIdentityAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static noChangeItem(): TokenConfigurationChangeItemWASM;
+    static PerpetualDistributionConfigurationItem(distribution?: TokenPerpetualDistributionWASM): TokenConfigurationChangeItemWASM;
+    static PerpetualDistributionControlGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static PerpetualDistributionAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static UnfreezeItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static UnfreezeAdminGroupItem(actionTaker: AuthorizedActionTakersWASM): TokenConfigurationChangeItemWASM;
+    static createFromRawInstance(rawInstance: TokenConfigurationChangeItemNAPI): TokenConfigurationChangeItemWASM;
+}