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

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

@@ -0,0 +1,17 @@
+import { IdentifierLike } from '../types.js';
+import type { IdentifierNAPI } from '../../../binaries/bindingsTypes.js';
+export declare class IdentifierWASM {
+    /** @private **/
+    _rawIdentifier: IdentifierNAPI;
+    constructor(rawId: IdentifierLike | IdentifierWASM);
+    base58(): string;
+    base64(): string;
+    hex(): string;
+    bytes(): Uint8Array;
+    static fromBase58(id: string): IdentifierWASM;
+    static fromBase64(id: string): IdentifierWASM;
+    static fromHex(id: string): IdentifierWASM;
+    static fromBytes(id: Uint8Array): IdentifierWASM;
+    static createFromRawInstance(rawInstance: IdentifierNAPI): IdentifierWASM;
+    getRawInstance(): IdentifierNAPI;
+}

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

@@ -0,0 +1,50 @@
+import { dppProvider } from '../provider.js';
+export class IdentifierWASM {
+    /** @private **/
+    _rawIdentifier;
+    constructor(rawId) {
+        const dpp = dppProvider.dpp;
+        if (rawId instanceof IdentifierWASM) {
+            return rawId;
+        }
+        else if (rawId instanceof Uint8Array || typeof rawId === 'string') {
+            const id = new dpp.DynamicValue(rawId);
+            this._rawIdentifier = new dpp.IdentifierNAPI(id);
+        }
+        else {
+            throw new Error('Invalid raw ID');
+        }
+    }
+    base58() {
+        return this._rawIdentifier.base58();
+    }
+    base64() {
+        return this._rawIdentifier.base64();
+    }
+    hex() {
+        return this._rawIdentifier.hex();
+    }
+    bytes() {
+        return this._rawIdentifier.bytes();
+    }
+    static fromBase58(id) {
+        return this.createFromRawInstance(dppProvider.dpp.IdentifierNAPI.fromBase58(id));
+    }
+    static fromBase64(id) {
+        return this.createFromRawInstance(dppProvider.dpp.IdentifierNAPI.fromBase64(id));
+    }
+    static fromHex(id) {
+        return this.createFromRawInstance(dppProvider.dpp.IdentifierNAPI.fromHex(id));
+    }
+    static fromBytes(id) {
+        return this.createFromRawInstance(dppProvider.dpp.IdentifierNAPI.fromBytes(id));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentifierWASM.prototype);
+        instance._rawIdentifier = rawInstance;
+        return instance;
+    }
+    getRawInstance() {
+        return this._rawIdentifier;
+    }
+}

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

@@ -0,0 +1,26 @@
+import { IdentifierWASM } from './Identifier.js';
+import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
+import { IdentifierLike, PlatformVersionLike } from '../types.js';
+import type { IdentityNAPI } from '../../../binaries/bindingsTypes.js';
+export declare class IdentityWASM {
+    /** @private **/
+    _rawIdentity: IdentityNAPI;
+    constructor(rawId: IdentifierLike, platformVersion?: PlatformVersionLike);
+    set id(rawId: IdentifierLike);
+    get id(): IdentifierWASM;
+    set balance(balance: bigint);
+    get balance(): bigint;
+    set revision(revision: bigint);
+    get revision(): bigint;
+    addPublicKey(publicKey: IdentityPublicKeyWASM): void;
+    getPublicKeyById(keyId: number): IdentityPublicKeyWASM | undefined;
+    getPublicKeys(): IdentityPublicKeyWASM[];
+    static fromHex(hex: string): IdentityWASM;
+    static fromBase64(base64: string): IdentityWASM;
+    static fromBytes(bytes: Uint8Array): IdentityWASM;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    static createFromRawInstance(rawInstance: IdentityNAPI): IdentityWASM;
+    getRawInstance(): IdentityNAPI;
+}

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

@@ -0,0 +1,73 @@
+import { IdentifierWASM } from './Identifier.js';
+import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
+import { dppProvider } from '../provider.js';
+import { prepareIdentifierValue, valueToDynamicValue } from '../utils.js';
+export class IdentityWASM {
+    /** @private **/
+    _rawIdentity;
+    constructor(rawId, platformVersion) {
+        const dpp = dppProvider.dpp;
+        this._rawIdentity = new dpp.IdentityNAPI(prepareIdentifierValue(rawId), valueToDynamicValue(platformVersion));
+    }
+    set id(rawId) {
+        this._rawIdentity.id = prepareIdentifierValue(rawId);
+    }
+    get id() {
+        return IdentifierWASM.createFromRawInstance(this._rawIdentity.id);
+    }
+    set balance(balance) {
+        this._rawIdentity.balance = balance.toString();
+    }
+    get balance() {
+        return BigInt(this._rawIdentity.balance);
+    }
+    set revision(revision) {
+        this._rawIdentity.revision = revision.toString();
+    }
+    get revision() {
+        return BigInt(this._rawIdentity.revision);
+    }
+    addPublicKey(publicKey) {
+        this._rawIdentity.addPublicKey(publicKey._rawIdentityPublicKey);
+    }
+    getPublicKeyById(keyId) {
+        const rawKeyInstance = this._rawIdentity.getPublicKeyById(keyId);
+        if (rawKeyInstance != null) {
+            return IdentityPublicKeyWASM.createFromRawInstance(rawKeyInstance);
+        }
+        return undefined;
+    }
+    getPublicKeys() {
+        const rawKeysArr = this._rawIdentity.getPublicKeys();
+        return rawKeysArr.map((key) => IdentityPublicKeyWASM.createFromRawInstance(key));
+    }
+    static fromHex(hex) {
+        const rawInstance = dppProvider.dpp.IdentityNAPI.fromHex(hex);
+        return this.createFromRawInstance(rawInstance);
+    }
+    static fromBase64(base64) {
+        const rawInstance = dppProvider.dpp.IdentityNAPI.fromBase64(base64);
+        return this.createFromRawInstance(rawInstance);
+    }
+    static fromBytes(bytes) {
+        const rawInstance = dppProvider.dpp.IdentityNAPI.fromBytes(bytes);
+        return this.createFromRawInstance(rawInstance);
+    }
+    bytes() {
+        return this._rawIdentity.bytes();
+    }
+    hex() {
+        return this._rawIdentity.hex();
+    }
+    base64() {
+        return this._rawIdentity.base64();
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityWASM.prototype);
+        instance._rawIdentity = rawInstance;
+        return instance;
+    }
+    getRawInstance() {
+        return this._rawIdentity;
+    }
+}

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

@@ -0,0 +1,44 @@
+import { KeyTypeLike, NetworkLike, PurposeLike, SecurityLevelLike } from '../types.js';
+import type { IdentityPublicKeyNAPI } from '../../../binaries/bindingsTypes.js';
+import { KeyType, Purpose, SecurityLevel } from '../enums.js';
+import { ContractBoundsWASM } from './ContractBounds.js';
+import { PrivateKeyWASM } from './PrivateKey.js';
+export declare class IdentityPublicKeyWASM {
+    /** @private **/
+    _rawIdentityPublicKey: IdentityPublicKeyNAPI;
+    constructor(id: number, purpose: PurposeLike, securityLevel: SecurityLevelLike, keyType: KeyTypeLike, readOnly: boolean, binaryData: string, disabledAt?: bigint | number, contractBounds?: ContractBoundsWASM);
+    get keyId(): number;
+    set keyId(keyId: number);
+    get purpose(): string;
+    set purpose(purpose: PurposeLike);
+    get purposeNumber(): Purpose;
+    set purposeNumber(purpose: Purpose);
+    get securityLevel(): string;
+    set securityLevel(securityLevel: SecurityLevelLike);
+    get securityLevelNumber(): SecurityLevel;
+    set securityLevelNumber(securityLevel: SecurityLevel);
+    get keyType(): string;
+    set keyType(keyType: KeyTypeLike);
+    get keyTypeNumber(): KeyType;
+    set keyTypeNumber(keyType: KeyType);
+    get readOnly(): boolean;
+    set readOnly(readOnly: boolean);
+    get data(): string;
+    set data(binaryData: string);
+    get disabledAt(): bigint | undefined;
+    set disabledAt(disabledAt: bigint | number);
+    get contractBounds(): ContractBoundsWASM | undefined;
+    set contractBounds(contractBounds: ContractBoundsWASM | undefined | null);
+    getContractBounds(): ContractBoundsWASM | undefined;
+    removeDisabledAt(): void;
+    getPublicKeyHash(): string;
+    isMaster(): boolean;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    validatePrivateKey(privateKey: string | Uint8Array | PrivateKeyWASM, network: NetworkLike): boolean;
+    static fromBytes(bytes: Uint8Array): IdentityPublicKeyWASM;
+    static fromHex(hex: string): IdentityPublicKeyWASM;
+    static fromBase64(base64: string): IdentityPublicKeyWASM;
+    static createFromRawInstance(rawInstance: IdentityPublicKeyNAPI): IdentityPublicKeyWASM;
+}

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

@@ -0,0 +1,131 @@
+import { dppProvider } from '../provider.js';
+import { ContractBoundsWASM } from './ContractBounds.js';
+import { PrivateKeyWASM } from './PrivateKey.js';
+import { valueToDynamicValue } from '../utils.js';
+export class IdentityPublicKeyWASM {
+    /** @private **/
+    _rawIdentityPublicKey;
+    constructor(id, purpose, securityLevel, keyType, readOnly, binaryData, disabledAt, contractBounds) {
+        const dpp = dppProvider.dpp;
+        if (purpose == null || securityLevel == null || keyType == null) {
+            throw new Error('purpose, securityLevel, keyType must be specified');
+        }
+        this._rawIdentityPublicKey = new dpp.IdentityPublicKeyNAPI(id, new dpp.DynamicValue(purpose), new dpp.DynamicValue(securityLevel), new dpp.DynamicValue(keyType), readOnly, binaryData, disabledAt?.toString(), contractBounds?._rawContractBounds);
+    }
+    get keyId() {
+        return this._rawIdentityPublicKey.keyId;
+    }
+    set keyId(keyId) {
+        this._rawIdentityPublicKey.keyId = keyId;
+    }
+    get purpose() {
+        return this._rawIdentityPublicKey.purpose;
+    }
+    set purpose(purpose) {
+        const dpp = dppProvider.dpp;
+        this._rawIdentityPublicKey.purpose = new dpp.DynamicValue(purpose);
+    }
+    get purposeNumber() {
+        return this._rawIdentityPublicKey.purposeNumber;
+    }
+    set purposeNumber(purpose) {
+        this._rawIdentityPublicKey.purposeNumber = purpose;
+    }
+    get securityLevel() {
+        return this._rawIdentityPublicKey.securityLevel;
+    }
+    set securityLevel(securityLevel) {
+        const dpp = dppProvider.dpp;
+        this._rawIdentityPublicKey.securityLevel = new dpp.DynamicValue(securityLevel);
+    }
+    get securityLevelNumber() {
+        return this._rawIdentityPublicKey.securityLevelNumber;
+    }
+    set securityLevelNumber(securityLevel) {
+        this._rawIdentityPublicKey.securityLevelNumber = securityLevel;
+    }
+    get keyType() {
+        return this._rawIdentityPublicKey.keyType;
+    }
+    set keyType(keyType) {
+        const dpp = dppProvider.dpp;
+        this._rawIdentityPublicKey.keyType = new dpp.DynamicValue(keyType);
+    }
+    get keyTypeNumber() {
+        return this._rawIdentityPublicKey.keyTypeNumber;
+    }
+    set keyTypeNumber(keyType) {
+        this._rawIdentityPublicKey.keyTypeNumber = keyType;
+    }
+    get readOnly() {
+        return this._rawIdentityPublicKey.readOnly;
+    }
+    set readOnly(readOnly) {
+        this._rawIdentityPublicKey.readOnly = readOnly;
+    }
+    get data() {
+        return this._rawIdentityPublicKey.data;
+    }
+    set data(binaryData) {
+        this._rawIdentityPublicKey.data = binaryData;
+    }
+    get disabledAt() {
+        const timestamp = this._rawIdentityPublicKey.disabledAt;
+        return (timestamp != null) ? BigInt(timestamp) : undefined;
+    }
+    set disabledAt(disabledAt) {
+        this._rawIdentityPublicKey.disabledAt = disabledAt.toString();
+    }
+    get contractBounds() {
+        if (this._rawIdentityPublicKey.contractBounds != null) {
+            return ContractBoundsWASM.createFromRawInstance(this._rawIdentityPublicKey.contractBounds);
+        }
+    }
+    set contractBounds(contractBounds) {
+        this._rawIdentityPublicKey.contractBounds = contractBounds?._rawContractBounds;
+    }
+    getContractBounds() {
+        if (this._rawIdentityPublicKey.contractBounds != null) {
+            return ContractBoundsWASM.createFromRawInstance(this._rawIdentityPublicKey.contractBounds);
+        }
+    }
+    removeDisabledAt() {
+        this._rawIdentityPublicKey.removeDisabledAt();
+    }
+    getPublicKeyHash() {
+        return this._rawIdentityPublicKey.getPublicKeyHash();
+    }
+    isMaster() {
+        return this._rawIdentityPublicKey.isMaster();
+    }
+    bytes() {
+        return this._rawIdentityPublicKey.bytes();
+    }
+    hex() {
+        return this._rawIdentityPublicKey.hex();
+    }
+    base64() {
+        return this._rawIdentityPublicKey.base64();
+    }
+    validatePrivateKey(privateKey, network) {
+        const normalPrivateKey = privateKey instanceof PrivateKeyWASM ? privateKey._rawPrivateKey : valueToDynamicValue(privateKey);
+        return this._rawIdentityPublicKey.validatePrivateKey(normalPrivateKey, valueToDynamicValue(network));
+    }
+    static fromBytes(bytes) {
+        const rawInstance = dppProvider.dpp.IdentityPublicKeyNAPI.fromBytes(bytes);
+        return this.createFromRawInstance(rawInstance);
+    }
+    static fromHex(hex) {
+        const rawInstance = dppProvider.dpp.IdentityPublicKeyNAPI.fromHex(hex);
+        return this.createFromRawInstance(rawInstance);
+    }
+    static fromBase64(base64) {
+        const rawInstance = dppProvider.dpp.IdentityPublicKeyNAPI.fromBase64(base64);
+        return this.createFromRawInstance(rawInstance);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityPublicKeyWASM.prototype);
+        instance._rawIdentityPublicKey = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { IdentityPublicKeyInCreationNAPI } from '../../../binaries/bindingsTypes.js';
+import { KeyTypeLike, NetworkLike, PurposeLike, SecurityLevelLike } from '../types.js';
+import { ContractBoundsWASM } from './ContractBounds.js';
+import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
+import { PrivateKeyWASM } from './PrivateKey.js';
+export declare class IdentityPublicKeyInCreationWASM {
+    /** @private **/
+    _rawKeyInCreation: IdentityPublicKeyInCreationNAPI;
+    constructor(id: number, purpose: PurposeLike, securityLevel: SecurityLevelLike, keyType: KeyTypeLike, readOnly: boolean, binaryData: Uint8Array, signature?: Uint8Array, contractBounds?: ContractBoundsWASM);
+    toIdentityPublicKey(): IdentityPublicKeyWASM;
+    validatePrivateKey(privateKey: string | Uint8Array | PrivateKeyWASM, network: NetworkLike): boolean;
+    getHash(): Uint8Array;
+    getContractBounds(): ContractBoundsWASM | undefined;
+    get contractBounds(): ContractBoundsWASM | undefined;
+    set contractBounds(value: ContractBoundsWASM);
+    get keyId(): number;
+    set keyId(value: number);
+    get purpose(): string;
+    set purpose(value: PurposeLike);
+    get securityLevel(): string;
+    set securityLevel(value: SecurityLevelLike);
+    get keyType(): string;
+    set keyType(value: KeyTypeLike);
+    get readOnly(): boolean;
+    set readOnly(value: boolean);
+    get data(): Uint8Array;
+    set data(value: Uint8Array);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    static createFromRawInstance(rawInstance: IdentityPublicKeyInCreationNAPI): IdentityPublicKeyInCreationWASM;
+}

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

@@ -0,0 +1,82 @@
+import { ContractBoundsWASM } from './ContractBounds.js';
+import { dppProvider } from '../provider.js';
+import { valueToDynamicValue } from '../utils.js';
+import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
+import { PrivateKeyWASM } from './PrivateKey.js';
+export class IdentityPublicKeyInCreationWASM {
+    /** @private **/
+    _rawKeyInCreation;
+    constructor(id, purpose, securityLevel, keyType, readOnly, binaryData, signature, contractBounds) {
+        this._rawKeyInCreation = new dppProvider.dpp.IdentityPublicKeyInCreationNAPI(id, valueToDynamicValue(purpose), valueToDynamicValue(securityLevel), valueToDynamicValue(keyType), readOnly, binaryData, signature, contractBounds?._rawContractBounds);
+    }
+    toIdentityPublicKey() {
+        return IdentityPublicKeyWASM.createFromRawInstance(this._rawKeyInCreation.toIdentityPublicKey());
+    }
+    validatePrivateKey(privateKey, network) {
+        const normalPrivateKey = privateKey instanceof PrivateKeyWASM ? privateKey._rawPrivateKey : valueToDynamicValue(privateKey);
+        return this._rawKeyInCreation.validatePrivateKey(normalPrivateKey, valueToDynamicValue(network));
+    }
+    getHash() {
+        return this._rawKeyInCreation.getHash();
+    }
+    getContractBounds() {
+        if (this._rawKeyInCreation.contractBounds != null) {
+            return ContractBoundsWASM.createFromRawInstance(this._rawKeyInCreation.contractBounds);
+        }
+    }
+    get contractBounds() {
+        if (this._rawKeyInCreation.contractBounds != null) {
+            return ContractBoundsWASM.createFromRawInstance(this._rawKeyInCreation.contractBounds);
+        }
+    }
+    set contractBounds(value) {
+        this._rawKeyInCreation.contractBounds = value._rawContractBounds;
+    }
+    get keyId() {
+        return this._rawKeyInCreation.keyId;
+    }
+    set keyId(value) {
+        this._rawKeyInCreation.keyId = value;
+    }
+    get purpose() {
+        return this._rawKeyInCreation.purpose;
+    }
+    set purpose(value) {
+        this._rawKeyInCreation.purpose = valueToDynamicValue(value);
+    }
+    get securityLevel() {
+        return this._rawKeyInCreation.securityLevel;
+    }
+    set securityLevel(value) {
+        this._rawKeyInCreation.securityLevel = valueToDynamicValue(value);
+    }
+    get keyType() {
+        return this._rawKeyInCreation.keyType;
+    }
+    set keyType(value) {
+        this._rawKeyInCreation.keyType = valueToDynamicValue(value);
+    }
+    get readOnly() {
+        return this._rawKeyInCreation.readOnly;
+    }
+    set readOnly(value) {
+        this._rawKeyInCreation.readOnly = value;
+    }
+    get data() {
+        return this._rawKeyInCreation.data;
+    }
+    set data(value) {
+        this._rawKeyInCreation.data = value;
+    }
+    get signature() {
+        return this._rawKeyInCreation.signature;
+    }
+    set signature(value) {
+        this._rawKeyInCreation.signature = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityPublicKeyInCreationWASM.prototype);
+        instance._rawKeyInCreation = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreateTransition.d.ts

@@ -0,0 +1,29 @@
+import type { IdentityCreateTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { PlatformVersionLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class IdentityCreateTransitionWASM {
+    /** @private **/
+    _rawIdentityCreateTransition: IdentityCreateTransitionNAPI;
+    constructor(publicKeys: IdentityPublicKeyInCreationWASM[], assetLockProof: AssetLockProofWASM, signature?: Uint8Array, userFeeIncrease?: number);
+    get publicKeys(): IdentityPublicKeyInCreationWASM[];
+    set publicKeys(publicKeys: IdentityPublicKeyInCreationWASM[]);
+    get userFeeIncrease(): number;
+    set userFeeIncrease(value: number);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    get assetLock(): AssetLockProofWASM;
+    set assetLock(value: AssetLockProofWASM);
+    getSignableBytes(): Uint8Array;
+    getIdentifier(): IdentifierWASM;
+    bytes(): Uint8Array;
+    toStateTransition(): StateTransitionWASM;
+    static default(platformVersion: PlatformVersionLike): IdentityCreateTransitionWASM;
+    static fromHex(hex: string): IdentityCreateTransitionWASM;
+    static fromBase64(base64: string): IdentityCreateTransitionWASM;
+    static fromBytes(bytes: Uint8Array): IdentityCreateTransitionWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): IdentityCreateTransitionWASM;
+    static createFromRawInstance(rawInstance: IdentityCreateTransitionNAPI): IdentityCreateTransitionWASM;
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreateTransition.js

@@ -0,0 +1,69 @@
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class IdentityCreateTransitionWASM {
+    /** @private **/
+    _rawIdentityCreateTransition;
+    constructor(publicKeys, assetLockProof, signature, userFeeIncrease) {
+        this._rawIdentityCreateTransition = new dppProvider.dpp.IdentityCreateTransitionNAPI(publicKeys.map(publicKey => publicKey._rawKeyInCreation), assetLockProof._rawAssetLockProof, signature, userFeeIncrease);
+    }
+    get publicKeys() {
+        return this._rawIdentityCreateTransition.publicKeys.map(IdentityPublicKeyInCreationWASM.createFromRawInstance);
+    }
+    set publicKeys(publicKeys) {
+        this._rawIdentityCreateTransition.publicKeys = publicKeys.map(publicKey => publicKey._rawKeyInCreation);
+    }
+    get userFeeIncrease() {
+        return this._rawIdentityCreateTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(value) {
+        this._rawIdentityCreateTransition.userFeeIncrease = value;
+    }
+    get signature() {
+        return this._rawIdentityCreateTransition.signature;
+    }
+    set signature(value) {
+        this._rawIdentityCreateTransition.signature = value;
+    }
+    get assetLock() {
+        return AssetLockProofWASM.createFromRawInstance(this._rawIdentityCreateTransition.assetLock);
+    }
+    set assetLock(value) {
+        this._rawIdentityCreateTransition.assetLock = value._rawAssetLockProof;
+    }
+    getSignableBytes() {
+        return this._rawIdentityCreateTransition.getSignableBytes();
+    }
+    getIdentifier() {
+        return IdentifierWASM.createFromRawInstance(this._rawIdentityCreateTransition.getIdentifier());
+    }
+    bytes() {
+        return this._rawIdentityCreateTransition.bytes();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawIdentityCreateTransition.toStateTransition());
+    }
+    static default(platformVersion) {
+        return IdentityCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreateTransitionNAPI.default(valueToDynamicValue(platformVersion)));
+    }
+    static fromHex(hex) {
+        return IdentityCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreateTransitionNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return IdentityCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreateTransitionNAPI.fromBase64(base64));
+    }
+    static fromBytes(bytes) {
+        return IdentityCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreateTransitionNAPI.fromBytes(bytes));
+    }
+    static fromStateTransition(stateTransition) {
+        return IdentityCreateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreateTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityCreateTransitionWASM.prototype);
+        instance._rawIdentityCreateTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreditTransfer.d.ts

@@ -0,0 +1,33 @@
+import type { IdentityCreditTransferNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentifierLike } from '../../types.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class IdentityCreditTransferWASM {
+    /** @private **/
+    _rawIdentityCreditTransfer: IdentityCreditTransferNAPI;
+    constructor(sender: IdentifierLike, amount: bigint, recipient: IdentifierLike, nonce: bigint, userFeeIncrease?: number);
+    get recipientId(): IdentifierWASM;
+    set recipientId(value: IdentifierLike);
+    get senderId(): IdentifierWASM;
+    set senderId(value: IdentifierLike);
+    get amount(): bigint;
+    set amount(value: bigint);
+    get nonce(): bigint;
+    set nonce(value: bigint);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    get signaturePublicKeyId(): number;
+    set signaturePublicKeyId(value: number);
+    get userFeeIncrease(): number;
+    set userFeeIncrease(value: number);
+    getSignableBytes(): Uint8Array;
+    bytes(): Uint8Array;
+    hex(): string;
+    base64(): string;
+    toStateTransition(): StateTransitionWASM;
+    static fromBytes(bytes: Uint8Array): IdentityCreditTransferWASM;
+    static fromHex(hex: string): IdentityCreditTransferWASM;
+    static fromBase64(base64: string): IdentityCreditTransferWASM;
+    static fromStateTransition(stateTransition: StateTransitionWASM): IdentityCreditTransferWASM;
+    static createFromRawInstance(rawInstance: IdentityCreditTransferNAPI): IdentityCreditTransferWASM;
+}

package/dist/src/dpp/structs/IdentityTransitions/IdentityCreditTransfer.js

@@ -0,0 +1,85 @@
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue } from '../../utils.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class IdentityCreditTransferWASM {
+    /** @private **/
+    _rawIdentityCreditTransfer;
+    constructor(sender, amount, recipient, nonce, userFeeIncrease) {
+        this._rawIdentityCreditTransfer = new dppProvider.dpp.IdentityCreditTransferNAPI(prepareIdentifierValue(sender), amount.toString(), prepareIdentifierValue(recipient), nonce.toString(), userFeeIncrease);
+    }
+    get recipientId() {
+        return IdentifierWASM.createFromRawInstance(this._rawIdentityCreditTransfer.recipientId);
+    }
+    set recipientId(value) {
+        this._rawIdentityCreditTransfer.recipientId = prepareIdentifierValue(value);
+    }
+    get senderId() {
+        return IdentifierWASM.createFromRawInstance(this._rawIdentityCreditTransfer.senderId);
+    }
+    set senderId(value) {
+        this._rawIdentityCreditTransfer.recipientId = prepareIdentifierValue(value);
+    }
+    get amount() {
+        return BigInt(this._rawIdentityCreditTransfer.amount);
+    }
+    set amount(value) {
+        this._rawIdentityCreditTransfer.amount = value.toString();
+    }
+    get nonce() {
+        return BigInt(this._rawIdentityCreditTransfer.nonce);
+    }
+    set nonce(value) {
+        this._rawIdentityCreditTransfer.nonce = value.toString();
+    }
+    get signature() {
+        return this._rawIdentityCreditTransfer.signature;
+    }
+    set signature(value) {
+        this._rawIdentityCreditTransfer.signature = value;
+    }
+    get signaturePublicKeyId() {
+        return this._rawIdentityCreditTransfer.signaturePublicKeyId;
+    }
+    set signaturePublicKeyId(value) {
+        this._rawIdentityCreditTransfer.signaturePublicKeyId = value;
+    }
+    get userFeeIncrease() {
+        return this._rawIdentityCreditTransfer.userFeeIncrease;
+    }
+    set userFeeIncrease(value) {
+        this._rawIdentityCreditTransfer.userFeeIncrease = value;
+    }
+    getSignableBytes() {
+        return this._rawIdentityCreditTransfer.getSignableBytes();
+    }
+    bytes() {
+        return this._rawIdentityCreditTransfer.bytes();
+    }
+    hex() {
+        return this._rawIdentityCreditTransfer.hex();
+    }
+    base64() {
+        return this._rawIdentityCreditTransfer.base64();
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawIdentityCreditTransfer.toStateTransition());
+    }
+    static fromBytes(bytes) {
+        return IdentityCreditTransferWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditTransferNAPI.fromBytes(bytes));
+    }
+    static fromHex(hex) {
+        return IdentityCreditTransferWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditTransferNAPI.fromHex(hex));
+    }
+    static fromBase64(base64) {
+        return IdentityCreditTransferWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditTransferNAPI.fromBase64(base64));
+    }
+    static fromStateTransition(stateTransition) {
+        return IdentityCreditTransferWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditTransferNAPI.fromStateTransition(stateTransition._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityCreditTransferWASM.prototype);
+        instance._rawIdentityCreditTransfer = rawInstance;
+        return instance;
+    }
+}