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

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

@@ -0,0 +1,19 @@
+import { 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 { 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(this.prototype);
+        instance._rawGroup = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { 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 { 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(this.prototype);
+        instance._rawTokenConfiguration = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,47 @@
+import { 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;
+}

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 { 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(this.prototype);
+        instance._rawTokenConfigurationConvention = rawInstance;
+        return instance;
+    }
+}