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

package/dist/src/dpp/structs/MasternodeVote/Vote.js

@@ -0,0 +1,27 @@
+import { dppProvider } from '../../provider.js';
+import { VotePollWASM } from './VotePoll.js';
+import { ResourceVoteChoiceWASM } from './ResourceVoteChoice.js';
+export class VoteWASM {
+    /** @private **/
+    _rawVote;
+    constructor(votePoll, resourceVoteChoice) {
+        this._rawVote = new dppProvider.dpp.VoteNAPI(votePoll._rawVotePollWASM, resourceVoteChoice._rawResourceVoteChoice);
+    }
+    get votePoll() {
+        return VotePollWASM.createFromRawInstance(this._rawVote.votePoll);
+    }
+    set votePoll(votePoll) {
+        this._rawVote.votePoll = votePoll._rawVotePollWASM;
+    }
+    get resourceVoteChoice() {
+        return ResourceVoteChoiceWASM.createFromRawInstance(this._rawVote.resourceVoteChoice);
+    }
+    set resourceVoteChoice(resourceVoteChoice) {
+        this._rawVote.resourceVoteChoice = resourceVoteChoice._rawResourceVoteChoice;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(VoteWASM.prototype);
+        instance._rawVote = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/MasternodeVote/VotePoll.d.ts

@@ -0,0 +1,18 @@
+import type { VotePollNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class VotePollWASM {
+    /** @private **/
+    _rawVotePollWASM: VotePollNAPI;
+    constructor(contractId: IdentifierLike, documentTypeName: string, indexName: string, indexValues: string[]);
+    get contractId(): IdentifierWASM;
+    set contractId(value: IdentifierLike);
+    get documentTypeName(): string;
+    set documentTypeName(value: string);
+    get indexName(): string;
+    set indexName(value: string);
+    get indexValues(): string[];
+    set indexValues(values: string[]);
+    toString(): string;
+    static createFromRawInstance(rawInstance: VotePollNAPI): VotePollWASM;
+}

package/dist/src/dpp/structs/MasternodeVote/VotePoll.js

@@ -0,0 +1,42 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class VotePollWASM {
+    /** @private **/
+    _rawVotePollWASM;
+    constructor(contractId, documentTypeName, indexName, indexValues) {
+        this._rawVotePollWASM = new dppProvider.dpp.VotePollNAPI(prepareIdentifierValue(contractId), documentTypeName, indexName, valueToDynamicValue(indexValues));
+    }
+    get contractId() {
+        return IdentifierWASM.createFromRawInstance(this._rawVotePollWASM.contractId);
+    }
+    set contractId(value) {
+        this._rawVotePollWASM.contractId = prepareIdentifierValue(value);
+    }
+    get documentTypeName() {
+        return this._rawVotePollWASM.documentTypeName;
+    }
+    set documentTypeName(value) {
+        this._rawVotePollWASM.documentTypeName = value;
+    }
+    get indexName() {
+        return this._rawVotePollWASM.indexName;
+    }
+    set indexName(value) {
+        this._rawVotePollWASM.indexName = value;
+    }
+    get indexValues() {
+        return this._rawVotePollWASM.indexValues;
+    }
+    set indexValues(values) {
+        this._rawVotePollWASM.indexValues = valueToDynamicValue(values);
+    }
+    toString() {
+        return this._rawVotePollWASM.toString();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(VotePollWASM.prototype);
+        instance._rawVotePollWASM = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { PartialIdentityNAPI } from '../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../types.js';
+import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
+import { IdentifierWASM } from './Identifier.js';
+export declare class PartialIdentityWASM {
+    /** @private **/
+    _rawPartialIdentity: PartialIdentityNAPI;
+    constructor(id: IdentifierLike, loadedPublicKeys: {
+        [key: number]: IdentityPublicKeyWASM;
+    }, balance?: bigint, revision?: bigint, notFoundPublicKeys?: number[]);
+    get id(): IdentifierWASM;
+    set id(id: IdentifierLike);
+    get loadedPublicKeys(): {
+        [key: number]: IdentityPublicKeyWASM;
+    };
+    set loadedPublicKeys(loadedPublicKeys: {
+        [key: number]: IdentityPublicKeyWASM;
+    });
+    get balance(): bigint | undefined;
+    set balance(balance: bigint | undefined | null);
+    get revision(): bigint | undefined;
+    set revision(revision: bigint | undefined | null);
+    get notFoundPublicKeys(): number[];
+    set notFoundPublicKeys(keys: number[]);
+    static createFromRawInstance(rawInstance: PartialIdentityNAPI): PartialIdentityWASM;
+}

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

@@ -0,0 +1,69 @@
+import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
+import { dppProvider } from '../provider.js';
+import { prepareIdentifierValue } from '../utils.js';
+import { IdentifierWASM } from './Identifier.js';
+export class PartialIdentityWASM {
+    /** @private **/
+    _rawPartialIdentity;
+    constructor(id, loadedPublicKeys, balance, revision, notFoundPublicKeys) {
+        const publicKeysIds = Object.keys(loadedPublicKeys);
+        const normalKeys = [];
+        for (const publicKeyId of publicKeysIds) {
+            normalKeys.push([
+                Number(publicKeyId),
+                loadedPublicKeys[Number(publicKeyId)]._rawIdentityPublicKey
+            ]);
+        }
+        this._rawPartialIdentity = new dppProvider.dpp.PartialIdentityNAPI(prepareIdentifierValue(id), normalKeys, balance?.toString(), revision?.toString(), notFoundPublicKeys);
+    }
+    get id() {
+        return IdentifierWASM.createFromRawInstance(this._rawPartialIdentity.id);
+    }
+    set id(id) {
+        this._rawPartialIdentity.id = prepareIdentifierValue(id);
+    }
+    get loadedPublicKeys() {
+        const keys = this._rawPartialIdentity.loadedPublicKeys;
+        const out = {};
+        for (const key of keys) {
+            out[key[0]] = IdentityPublicKeyWASM.createFromRawInstance(key[1]);
+        }
+        return out;
+    }
+    set loadedPublicKeys(loadedPublicKeys) {
+        const publicKeysIds = Object.keys(loadedPublicKeys);
+        const normalKeys = [];
+        for (const publicKeyId of publicKeysIds) {
+            normalKeys.push([
+                Number(publicKeyId),
+                loadedPublicKeys[Number(publicKeyId)]._rawIdentityPublicKey
+            ]);
+        }
+        this._rawPartialIdentity.loadedPublicKeys = normalKeys;
+    }
+    get balance() {
+        const balance = this._rawPartialIdentity.balance;
+        return balance != null ? BigInt(balance) : undefined;
+    }
+    set balance(balance) {
+        this._rawPartialIdentity.balance = balance?.toString();
+    }
+    get revision() {
+        const revision = this._rawPartialIdentity.revision;
+        return revision != null ? BigInt(revision) : undefined;
+    }
+    set revision(revision) {
+        this._rawPartialIdentity.revision = revision?.toString();
+    }
+    get notFoundPublicKeys() {
+        return this._rawPartialIdentity.notFoundPublicKeys;
+    }
+    set notFoundPublicKeys(keys) {
+        this._rawPartialIdentity.notFoundPublicKeys = keys;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(PartialIdentityWASM.prototype);
+        instance._rawPartialIdentity = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/PlatformAddress/AddressWitness.d.ts

@@ -0,0 +1,12 @@
+import type { AddressWitnessNAPI } from '../../../../binaries/bindingsTypes.js';
+import { AddressWitnessP2PKH, AddressWitnessP2SH } from '../../types.js';
+export declare class AddressWitnessWASM {
+    /** @private **/
+    _rawWitness: AddressWitnessNAPI;
+    private constructor();
+    static P2PKH(signature: Uint8Array): AddressWitnessWASM;
+    static P2SH(signatures: Uint8Array[], redeemScript: Uint8Array): AddressWitnessWASM;
+    getType(): string;
+    getValue(): AddressWitnessP2PKH | AddressWitnessP2SH;
+    static createFromRawInstance(rawInstance: AddressWitnessNAPI): AddressWitnessWASM;
+}

package/dist/src/dpp/structs/PlatformAddress/AddressWitness.js

@@ -0,0 +1,23 @@
+import { dppProvider } from '../../provider.js';
+export class AddressWitnessWASM {
+    /** @private **/
+    _rawWitness;
+    constructor(witness) {
+        this._rawWitness = witness;
+    }
+    static P2PKH(signature) {
+        return AddressWitnessWASM.createFromRawInstance(dppProvider.dpp.AddressWitnessNAPI.P2PKH(signature));
+    }
+    static P2SH(signatures, redeemScript) {
+        return AddressWitnessWASM.createFromRawInstance(dppProvider.dpp.AddressWitnessNAPI.P2SH(signatures, redeemScript));
+    }
+    getType() {
+        return this._rawWitness.getType();
+    }
+    getValue() {
+        return this._rawWitness.getValue();
+    }
+    static createFromRawInstance(rawInstance) {
+        return new AddressWitnessWASM(rawInstance);
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { PlatformAddressNAPI } from '../../../../binaries/bindingsTypes.js';
+import { NetworkLike, PlatformAddressLike } from '../../types.js';
+export declare class PlatformAddressWASM {
+    /** @private **/
+    _rawPlatformAddress: PlatformAddressNAPI;
+    constructor(address: PlatformAddressLike);
+    bytes(): Uint8Array;
+    toAddress(network: NetworkLike): string;
+    toBech32m(network: NetworkLike): string;
+    isP2PKH(): boolean;
+    isP2SH(): boolean;
+    hash(): Uint8Array;
+    static fromBech32m(bech32m: string): PlatformAddressWASM;
+    static fromBytes(bytes: Uint8Array): PlatformAddressWASM;
+    static createFromRawInstance(rawInstance: PlatformAddressNAPI): PlatformAddressWASM;
+}

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

@@ -0,0 +1,38 @@
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
+export class PlatformAddressWASM {
+    /** @private **/
+    _rawPlatformAddress;
+    constructor(address) {
+        this._rawPlatformAddress = new dppProvider.dpp.PlatformAddressNAPI(preparePlatformAddressValue(address));
+    }
+    bytes() {
+        return this._rawPlatformAddress.bytes();
+    }
+    toAddress(network) {
+        return this._rawPlatformAddress.toAddress(valueToDynamicValue(network));
+    }
+    toBech32m(network) {
+        return this._rawPlatformAddress.toBech32m(valueToDynamicValue(network));
+    }
+    isP2PKH() {
+        return this._rawPlatformAddress.isP2PKH();
+    }
+    isP2SH() {
+        return this._rawPlatformAddress.isP2SH();
+    }
+    hash() {
+        return this._rawPlatformAddress.hash();
+    }
+    static fromBech32m(bech32m) {
+        return PlatformAddressWASM.createFromRawInstance(dppProvider.dpp.PlatformAddressNAPI.fromBech32m(bech32m));
+    }
+    static fromBytes(bytes) {
+        return PlatformAddressWASM.createFromRawInstance(dppProvider.dpp.PlatformAddressNAPI.fromBytes(bytes));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(PlatformAddressWASM.prototype);
+        instance._rawPlatformAddress = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { PrivateKeyNAPI } from '../../../binaries/bindingsTypes.js';
+import { NetworkLike } from '../types.js';
+import { PublicKeyWASM } from './PublicKey.js';
+export declare class PrivateKeyWASM {
+    /** @private **/
+    _rawPrivateKey: PrivateKeyNAPI;
+    constructor(key: string | Uint8Array, network: NetworkLike);
+    getPublicKey(): PublicKeyWASM;
+    getNetwork(): string;
+    WIF(): string;
+    bytes(): Uint8Array;
+    hex(): string;
+    getPublicKeyHash(): string;
+    sign(data: Uint8Array): Uint8Array;
+    signHash(dataHash: Uint8Array): Uint8Array;
+    static fromWIF(wif: string): PrivateKeyWASM;
+    static fromBytes(bytes: Uint8Array, network: NetworkLike): PrivateKeyWASM;
+    static fromHex(hex: string, network: NetworkLike): PrivateKeyWASM;
+    static createFromRawInstance(rawInstance: PrivateKeyNAPI): PrivateKeyWASM;
+}

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

@@ -0,0 +1,48 @@
+import { dppProvider } from '../provider.js';
+import { valueToDynamicValue } from '../utils.js';
+import { PublicKeyWASM } from './PublicKey.js';
+export class PrivateKeyWASM {
+    /** @private **/
+    _rawPrivateKey;
+    constructor(key, network) {
+        this._rawPrivateKey = new dppProvider.dpp.PrivateKeyNAPI(valueToDynamicValue(key), valueToDynamicValue(network));
+    }
+    getPublicKey() {
+        return PublicKeyWASM.createFromRawInstance(this._rawPrivateKey.getPublicKey());
+    }
+    getNetwork() {
+        return this._rawPrivateKey.getNetwork();
+    }
+    WIF() {
+        return this._rawPrivateKey.WIF();
+    }
+    bytes() {
+        return this._rawPrivateKey.bytes();
+    }
+    hex() {
+        return this._rawPrivateKey.hex();
+    }
+    getPublicKeyHash() {
+        return this._rawPrivateKey.getPublicKeyHash();
+    }
+    sign(data) {
+        return this._rawPrivateKey.sign(data);
+    }
+    signHash(dataHash) {
+        return this._rawPrivateKey.signHash(dataHash);
+    }
+    static fromWIF(wif) {
+        return PrivateKeyWASM.createFromRawInstance(dppProvider.dpp.PrivateKeyNAPI.fromWIF(wif));
+    }
+    static fromBytes(bytes, network) {
+        return PrivateKeyWASM.createFromRawInstance(dppProvider.dpp.PrivateKeyNAPI.fromBytes(bytes, valueToDynamicValue(network)));
+    }
+    static fromHex(hex, network) {
+        return PrivateKeyWASM.createFromRawInstance(dppProvider.dpp.PrivateKeyNAPI.fromHex(hex, valueToDynamicValue(network)));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(PrivateKeyWASM.prototype);
+        instance._rawPrivateKey = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { PublicKeyNAPI } from '../../../binaries/bindingsTypes.js';
+export declare class PublicKeyWASM {
+    /** @private **/
+    _rawPublicKey: PublicKeyNAPI;
+    constructor(compressed: boolean, bytes: Uint8Array);
+    get compressed(): boolean;
+    set compressed(value: boolean);
+    get inner(): Uint8Array;
+    set inner(value: Uint8Array);
+    getPublicKeyHash(): string;
+    hash160(): Uint8Array;
+    bytes(): Uint8Array;
+    static fromBytes(bytes: Uint8Array): PublicKeyWASM;
+    static createFromRawInstance(rawInstance: PublicKeyNAPI): PublicKeyWASM;
+}

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

@@ -0,0 +1,37 @@
+import { dppProvider } from '../provider.js';
+export class PublicKeyWASM {
+    /** @private **/
+    _rawPublicKey;
+    constructor(compressed, bytes) {
+        this._rawPublicKey = new dppProvider.dpp.PublicKeyNAPI(compressed, bytes);
+    }
+    get compressed() {
+        return this._rawPublicKey.compressed;
+    }
+    set compressed(value) {
+        this._rawPublicKey.compressed = value;
+    }
+    get inner() {
+        return this._rawPublicKey.inner;
+    }
+    set inner(value) {
+        this._rawPublicKey.inner = value;
+    }
+    getPublicKeyHash() {
+        return this._rawPublicKey.getPublicKeyHash();
+    }
+    hash160() {
+        return this._rawPublicKey.hash160();
+    }
+    bytes() {
+        return this._rawPublicKey.bytes();
+    }
+    static fromBytes(bytes) {
+        return PublicKeyWASM.createFromRawInstance(dppProvider.dpp.PublicKeyNAPI.fromBytes(bytes));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(PublicKeyWASM.prototype);
+        instance._rawPublicKey = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,39 @@
+import type { StateTransitionNAPI } from '../../../binaries/bindingsTypes.js';
+import { PrivateKeyWASM } from './PrivateKey.js';
+import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
+import { IdentifierLike, KeyTypeLike, PurposeLike } from '../types.js';
+import { IdentifierWASM } from './Identifier.js';
+export declare class StateTransitionWASM {
+    /** @private **/
+    _rawStateTransition: StateTransitionNAPI;
+    private constructor();
+    get signature(): Uint8Array | undefined;
+    set signature(signature: Uint8Array);
+    get signaturePublicKeyId(): number | undefined;
+    set signaturePublicKeyId(keyId: number);
+    get userFeeIncrease(): number;
+    set userFeeIncrease(userFeeIncrease: number);
+    sign(privateKey: PrivateKeyWASM | string | Uint8Array, publicKey: IdentityPublicKeyWASM): Uint8Array;
+    signByPrivateKey(privateKey: PrivateKeyWASM | string | Uint8Array, keyId?: number, keyType?: KeyTypeLike): Uint8Array;
+    verifyPublicKey(publicKey: IdentityPublicKeyWASM, allowSigningWithAnySecurityLevel?: boolean, allowSigningWithAnyPurpose?: boolean): void;
+    hash(skipSignature: boolean): string;
+    getActionName(): string;
+    getActionType(): string;
+    getActionTypeNumber(): number;
+    getOwnerId(): IdentifierWASM | undefined;
+    getPurposeRequirement(): string[] | undefined;
+    getKeyLevelRequirement(purpose: PurposeLike): string[] | undefined;
+    getIdentityContractNonce(): bigint | undefined;
+    getIdentityNonce(): bigint | undefined;
+    setOwnerId(ownerId: IdentifierLike): void;
+    setIdentityContractNonce(nonce: bigint): void;
+    setIdentityNonce(nonce: bigint): void;
+    getSignableBytes(): Uint8Array;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    static fromBytes(bytes: Uint8Array): StateTransitionWASM;
+    static fromHex(hex: string): StateTransitionWASM;
+    static fromBase64(base64: string): StateTransitionWASM;
+    static createFromRawInstance(instance: StateTransitionNAPI): StateTransitionWASM;
+}

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

@@ -0,0 +1,103 @@
+import { dppProvider } from '../provider.js';
+import { PrivateKeyWASM } from './PrivateKey.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../utils.js';
+import { IdentifierWASM } from './Identifier.js';
+export class StateTransitionWASM {
+    /** @private **/
+    _rawStateTransition;
+    constructor(_rawStateTransition) {
+        this._rawStateTransition = _rawStateTransition;
+    }
+    get signature() {
+        return this._rawStateTransition.signature ?? undefined;
+    }
+    set signature(signature) {
+        this._rawStateTransition.signature = signature;
+    }
+    get signaturePublicKeyId() {
+        return this._rawStateTransition.signaturePublicKeyId ?? undefined;
+    }
+    set signaturePublicKeyId(keyId) {
+        this._rawStateTransition.signaturePublicKeyId = keyId;
+    }
+    get userFeeIncrease() {
+        return this._rawStateTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(userFeeIncrease) {
+        this._rawStateTransition.userFeeIncrease = userFeeIncrease;
+    }
+    sign(privateKey, publicKey) {
+        const normalPrivateKey = privateKey instanceof PrivateKeyWASM ? privateKey._rawPrivateKey : valueToDynamicValue(privateKey);
+        return this._rawStateTransition.sign(normalPrivateKey, publicKey._rawIdentityPublicKey);
+    }
+    signByPrivateKey(privateKey, keyId, keyType) {
+        const normalPrivateKey = privateKey instanceof PrivateKeyWASM ? privateKey._rawPrivateKey : valueToDynamicValue(privateKey);
+        return this._rawStateTransition.signByPrivateKey(normalPrivateKey, keyId, keyType ? valueToDynamicValue(keyType) : undefined);
+    }
+    verifyPublicKey(publicKey, allowSigningWithAnySecurityLevel, allowSigningWithAnyPurpose) {
+        this._rawStateTransition.verifyPublicKey(publicKey._rawIdentityPublicKey, allowSigningWithAnySecurityLevel, allowSigningWithAnyPurpose);
+    }
+    hash(skipSignature) {
+        return this._rawStateTransition.hash(skipSignature);
+    }
+    getActionName() {
+        return this._rawStateTransition.getActionName();
+    }
+    getActionType() {
+        return this._rawStateTransition.getActionType();
+    }
+    getActionTypeNumber() {
+        return this._rawStateTransition.getActionTypeNumber();
+    }
+    getOwnerId() {
+        const id = this._rawStateTransition.getOwnerId();
+        return (id != null) ? IdentifierWASM.createFromRawInstance(id) : undefined;
+    }
+    getPurposeRequirement() {
+        return this._rawStateTransition.getPurposeRequirement() ?? undefined;
+    }
+    getKeyLevelRequirement(purpose) {
+        return this._rawStateTransition.getKeyLevelRequirement(valueToDynamicValue(purpose)) ?? undefined;
+    }
+    getIdentityContractNonce() {
+        const nonce = this._rawStateTransition.getIdentityContractNonce();
+        return nonce != null ? BigInt(nonce) : undefined;
+    }
+    getIdentityNonce() {
+        const nonce = this._rawStateTransition.getIdentityNonce();
+        return nonce != null ? BigInt(nonce) : undefined;
+    }
+    setOwnerId(ownerId) {
+        this._rawStateTransition.setOwnerId(prepareIdentifierValue(ownerId));
+    }
+    setIdentityContractNonce(nonce) {
+        this._rawStateTransition.setIdentityContractNonce(nonce.toString());
+    }
+    setIdentityNonce(nonce) {
+        this._rawStateTransition.setIdentityNonce(nonce.toString());
+    }
+    getSignableBytes() {
+        return this._rawStateTransition.getSignableBytes();
+    }
+    bytes() {
+        return this._rawStateTransition.bytes();
+    }
+    hex() {
+        return this._rawStateTransition.hex();
+    }
+    base64() {
+        return this._rawStateTransition.base64();
+    }
+    static fromBytes(bytes) {
+        return new StateTransitionWASM(dppProvider.dpp.StateTransitionNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return new StateTransitionWASM(dppProvider.dpp.StateTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return new StateTransitionWASM(dppProvider.dpp.StateTransitionNAPI.fromBase64(base64));
+    }
+    static createFromRawInstance(instance) {
+        return new StateTransitionWASM(instance);
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { ActionTakerNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class ActionTakerWASM {
+    /** @private **/
+    _rawActionTaker: ActionTakerNAPI;
+    constructor(value: IdentifierLike | IdentifierLike[]);
+    getType(): string;
+    get value(): IdentifierWASM | IdentifierWASM[];
+    set value(value: IdentifierLike | IdentifierLike[]);
+    static createFromRawInstance(rawInstance: ActionTakerNAPI): ActionTakerWASM;
+}

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

@@ -0,0 +1,44 @@
+import { prepareIdentifierValue } from '../../utils.js';
+import { dppProvider } from '../../provider.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class ActionTakerWASM {
+    /** @private **/
+    _rawActionTaker;
+    constructor(value) {
+        let normalValue;
+        if (Array.isArray(value)) {
+            normalValue = value.map(id => prepareIdentifierValue(id));
+        }
+        else {
+            normalValue = prepareIdentifierValue(value);
+        }
+        this._rawActionTaker = new dppProvider.dpp.ActionTakerNAPI(normalValue);
+    }
+    getType() {
+        return this._rawActionTaker.getType();
+    }
+    get value() {
+        const v = this._rawActionTaker.value;
+        if (Array.isArray(v)) {
+            return v.map(IdentifierWASM.createFromRawInstance);
+        }
+        else {
+            return IdentifierWASM.createFromRawInstance(v);
+        }
+    }
+    set value(value) {
+        let normalValue;
+        if (Array.isArray(value)) {
+            normalValue = value.map(id => prepareIdentifierValue(id));
+        }
+        else {
+            normalValue = prepareIdentifierValue(value);
+        }
+        this._rawActionTaker.value = normalValue;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ActionTakerWASM.prototype);
+        instance._rawActionTaker = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { AuthorizedActionTakersNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+export declare class AuthorizedActionTakersWASM {
+    /** @private **/
+    _rawAuthorizedActionTakers: AuthorizedActionTakersNAPI;
+    private constructor();
+    getTakerType(): string;
+    getValue(): undefined | IdentifierWASM | number;
+    static NoOne(): AuthorizedActionTakersWASM;
+    static ContractOwner(): AuthorizedActionTakersWASM;
+    static Identity(id: IdentifierLike): AuthorizedActionTakersWASM;
+    static MainGroup(): AuthorizedActionTakersWASM;
+    static Group(groupContractPosition: number): AuthorizedActionTakersWASM;
+    static createFromRawInstance(rawInstance: AuthorizedActionTakersNAPI): AuthorizedActionTakersWASM;
+}

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

@@ -0,0 +1,43 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+export class AuthorizedActionTakersWASM {
+    /** @private **/
+    _rawAuthorizedActionTakers;
+    constructor(authorizedActionTakers) {
+        this._rawAuthorizedActionTakers = authorizedActionTakers;
+    }
+    getTakerType() {
+        return this._rawAuthorizedActionTakers.getTakerType();
+    }
+    getValue() {
+        const value = this._rawAuthorizedActionTakers.getValue();
+        if (value === undefined) {
+            return undefined;
+        }
+        else if (typeof value === 'number') {
+            return Number(value);
+        }
+        else {
+            return IdentifierWASM.createFromRawInstance(value);
+        }
+    }
+    static NoOne() {
+        return new AuthorizedActionTakersWASM(dppProvider.dpp.AuthorizedActionTakersNAPI.NoOne());
+    }
+    static ContractOwner() {
+        return new AuthorizedActionTakersWASM(dppProvider.dpp.AuthorizedActionTakersNAPI.ContractOwner());
+    }
+    static Identity(id) {
+        return new AuthorizedActionTakersWASM(dppProvider.dpp.AuthorizedActionTakersNAPI.Identity(prepareIdentifierValue(id)));
+    }
+    static MainGroup() {
+        return new AuthorizedActionTakersWASM(dppProvider.dpp.AuthorizedActionTakersNAPI.MainGroup());
+    }
+    static Group(groupContractPosition) {
+        return new AuthorizedActionTakersWASM(dppProvider.dpp.AuthorizedActionTakersNAPI.Group(groupContractPosition));
+    }
+    static createFromRawInstance(rawInstance) {
+        return new AuthorizedActionTakersWASM(rawInstance);
+    }
+}