pshenmic-dpp 2.0.0-dev.2 → 2.0.0-dev.20

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

@@ -78,7 +78,7 @@ export class IdentityCreditTransferWASM {
         return IdentityCreditTransferWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditTransferNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityCreditTransferWASM.prototype);
         instance._rawIdentityCreditTransfer = rawInstance;
         return instance;
     }

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

@@ -107,7 +107,7 @@ export class IdentityCreditWithdrawalTransitionWASM {
         return IdentityCreditWithdrawalTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreditWithdrawalTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityCreditWithdrawalTransitionWASM.prototype);
         instance._rawIdentityCreditWithdrawalTransition = rawInstance;
         return instance;
     }

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

@@ -68,7 +68,7 @@ export class IdentityTopUpTransitionWASM {
         return IdentityTopUpTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityTopUpTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityTopUpTransitionWASM.prototype);
         instance._rawIdentityTopUpTransition = rawInstance;
         return instance;
     }

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

@@ -101,7 +101,7 @@ export class IdentityUpdateTransitionWASM {
         return IdentityUpdateTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityUpdateTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(IdentityUpdateTransitionWASM.prototype);
         instance._rawIdentityUpdateTransition = rawInstance;
         return instance;
     }

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

@@ -36,7 +36,7 @@ export class InstantLockWASM {
         this._rawInstantLock.blsSignature = sig;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(InstantLockWASM.prototype);
         instance._rawInstantLock = rawInstance;
         return instance;
     }

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

@@ -20,8 +20,6 @@ export declare class MasternodeVoteTransitionWASM {
     set signaturePublicKeyId(keyId: number);
     get signature(): Uint8Array;
     set signature(value: Uint8Array);
-    get userFeeIncrease(): number;
-    set userFeeIncrease(value: number);
     get assetLock(): AssetLockProofWASM | undefined;
     get modifiedDataIds(): IdentifierWASM[];
     getSignableBytes(): Uint8Array;

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

@@ -46,12 +46,6 @@ export class MasternodeVoteTransitionWASM {
     set signature(value) {
         this._rawMasternodeVoteTransition.signature = value;
     }
-    get userFeeIncrease() {
-        return this._rawMasternodeVoteTransition.userFeeIncrease;
-    }
-    set userFeeIncrease(value) {
-        this._rawMasternodeVoteTransition.userFeeIncrease = value;
-    }
     get assetLock() {
         const lock = this._rawMasternodeVoteTransition.assetLock;
         if (lock != null) {
@@ -89,7 +83,7 @@ export class MasternodeVoteTransitionWASM {
         return MasternodeVoteTransitionWASM.createFromRawInstance(dppProvider.dpp.MasternodeVoteTransitionNAPI.fromStateTransition(stateTransition._rawStateTransition));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(MasternodeVoteTransitionWASM.prototype);
         instance._rawMasternodeVoteTransition = rawInstance;
         return instance;
     }

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

@@ -20,7 +20,7 @@ export class VoteWASM {
         this._rawVote.resourceVoteChoice = resourceVoteChoice._rawResourceVoteChoice;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(VoteWASM.prototype);
         instance._rawVote = rawInstance;
         return instance;
     }

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

@@ -11,7 +11,7 @@ export declare class VotePollWASM {
     set documentTypeName(value: string);
     get indexName(): string;
     set indexName(value: string);
-    get indexValues(): any;
+    get indexValues(): string[];
     set indexValues(values: string[]);
     toString(): string;
     static createFromRawInstance(rawInstance: VotePollNAPI): VotePollWASM;

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

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

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

@@ -62,7 +62,7 @@ export class PartialIdentityWASM {
         this._rawPartialIdentity.notFoundPublicKeys = keys;
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(PartialIdentityWASM.prototype);
         instance._rawPartialIdentity = rawInstance;
         return instance;
     }

package/dist/src/dpp/structs/{Address → PlatformAddress}/AddressWitness.d.ts

@@ -4,8 +4,8 @@ export declare class AddressWitnessWASM {
     /** @private **/
     _rawWitness: AddressWitnessNAPI;
     private constructor();
-    P2PKH(signature: Uint8Array): AddressWitnessWASM;
-    P2SH(signatures: Uint8Array[], redeemScript: Uint8Array): AddressWitnessWASM;
+    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/{Address → PlatformAddress}/AddressWitness.js

@@ -5,10 +5,10 @@ export class AddressWitnessWASM {
     constructor(witness) {
         this._rawWitness = witness;
     }
-    P2PKH(signature) {
+    static P2PKH(signature) {
         return AddressWitnessWASM.createFromRawInstance(dppProvider.dpp.AddressWitnessNAPI.P2PKH(signature));
     }
-    P2SH(signatures, redeemScript) {
+    static P2SH(signatures, redeemScript) {
         return AddressWitnessWASM.createFromRawInstance(dppProvider.dpp.AddressWitnessNAPI.P2SH(signatures, redeemScript));
     }
     getType() {

package/dist/src/dpp/structs/{Address → PlatformAddress}/PlatformAddress.d.ts

@@ -1,14 +1,16 @@
 import type { PlatformAddressNAPI } from '../../../../binaries/bindingsTypes.js';
-import { NetworkLike } from '../../types.js';
+import { NetworkLike, PlatformAddressLike } from '../../types.js';
 export declare class PlatformAddressWASM {
     /** @private **/
     _rawPlatformAddress: PlatformAddressNAPI;
-    constructor(address: Uint8Array);
+    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/{Address → PlatformAddress}/PlatformAddress.js

@@ -1,10 +1,10 @@
 import { dppProvider } from '../../provider.js';
-import { valueToDynamicValue } from '../../utils.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
 export class PlatformAddressWASM {
     /** @private **/
     _rawPlatformAddress;
     constructor(address) {
-        this._rawPlatformAddress = new dppProvider.dpp.PlatformAddressNAPI(address);
+        this._rawPlatformAddress = new dppProvider.dpp.PlatformAddressNAPI(preparePlatformAddressValue(address));
     }
     bytes() {
         return this._rawPlatformAddress.bytes();
@@ -24,8 +24,14 @@ export class PlatformAddressWASM {
     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(this.prototype);
+        const instance = Object.create(PlatformAddressWASM.prototype);
         instance._rawPlatformAddress = rawInstance;
         return instance;
     }

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

@@ -41,7 +41,7 @@ export class PrivateKeyWASM {
         return PrivateKeyWASM.createFromRawInstance(dppProvider.dpp.PrivateKeyNAPI.fromHex(hex, valueToDynamicValue(network)));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(PrivateKeyWASM.prototype);
         instance._rawPrivateKey = rawInstance;
         return instance;
     }

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

@@ -30,7 +30,7 @@ export class PublicKeyWASM {
         return PublicKeyWASM.createFromRawInstance(dppProvider.dpp.PublicKeyNAPI.fromBytes(bytes));
     }
     static createFromRawInstance(rawInstance) {
-        const instance = Object.create(this.prototype);
+        const instance = Object.create(PublicKeyWASM.prototype);
         instance._rawPublicKey = rawInstance;
         return instance;
     }

package/dist/src/dpp/structs/ShieldedTransitions/IdentityCreateFromShieldedPoolTransition.d.ts

@@ -0,0 +1,31 @@
+import type { IdentityCreateFromShieldedPoolTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { IdentifierLike, PlatformAddressLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class IdentityCreateFromShieldedPoolTransitionWASM {
+    /** @private **/
+    _rawIdentityCreateFromShieldedPoolTransition: IdentityCreateFromShieldedPoolTransitionNAPI;
+    constructor(publicKeys: IdentityPublicKeyInCreationWASM[], denomination: bigint, actions: SerializedActionWASM[], anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array, sendToAddressOnCreationFailure: PlatformAddressLike, identityId: IdentifierLike);
+    get publicKeys(): IdentityPublicKeyInCreationWASM[];
+    set publicKeys(value: IdentityPublicKeyInCreationWASM[]);
+    get denomination(): bigint;
+    set denomination(value: bigint);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    get sendToAddressOnCreationFailure(): PlatformAddressWASM;
+    set sendToAddressOnCreationFailure(value: PlatformAddressLike);
+    get identityId(): IdentifierWASM;
+    set identityId(value: IdentifierLike);
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): IdentityCreateFromShieldedPoolTransitionWASM;
+    static createFromRawInstance(rawInstance: IdentityCreateFromShieldedPoolTransitionNAPI): IdentityCreateFromShieldedPoolTransitionWASM;
+}

package/dist/src/dpp/structs/ShieldedTransitions/IdentityCreateFromShieldedPoolTransition.js

@@ -0,0 +1,73 @@
+import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { IdentifierWASM } from '../Identifier.js';
+import { dppProvider } from '../../provider.js';
+import { prepareIdentifierValue, preparePlatformAddressValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class IdentityCreateFromShieldedPoolTransitionWASM {
+    /** @private **/
+    _rawIdentityCreateFromShieldedPoolTransition;
+    constructor(publicKeys, denomination, actions, anchor, proof, bindingsSignature, sendToAddressOnCreationFailure, identityId) {
+        this._rawIdentityCreateFromShieldedPoolTransition = new dppProvider.dpp.IdentityCreateFromShieldedPoolTransitionNAPI(publicKeys.map(k => k._rawKeyInCreation), denomination.toString(), actions.map(a => a._rawSerializedAction), anchor, proof, bindingsSignature, preparePlatformAddressValue(sendToAddressOnCreationFailure), prepareIdentifierValue(identityId));
+    }
+    get publicKeys() {
+        return this._rawIdentityCreateFromShieldedPoolTransition.publicKeys.map(IdentityPublicKeyInCreationWASM.createFromRawInstance);
+    }
+    set publicKeys(value) {
+        this._rawIdentityCreateFromShieldedPoolTransition.publicKeys = value.map(k => k._rawKeyInCreation);
+    }
+    get denomination() {
+        return BigInt(this._rawIdentityCreateFromShieldedPoolTransition.denomination);
+    }
+    set denomination(value) {
+        this._rawIdentityCreateFromShieldedPoolTransition.denomination = value.toString();
+    }
+    get actions() {
+        return this._rawIdentityCreateFromShieldedPoolTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawIdentityCreateFromShieldedPoolTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get anchor() {
+        return this._rawIdentityCreateFromShieldedPoolTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawIdentityCreateFromShieldedPoolTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawIdentityCreateFromShieldedPoolTransition.proof;
+    }
+    set proof(value) {
+        this._rawIdentityCreateFromShieldedPoolTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawIdentityCreateFromShieldedPoolTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawIdentityCreateFromShieldedPoolTransition.bindingsSignature = value;
+    }
+    get sendToAddressOnCreationFailure() {
+        return PlatformAddressWASM.createFromRawInstance(this._rawIdentityCreateFromShieldedPoolTransition.sendToAddressOnCreationFailure);
+    }
+    set sendToAddressOnCreationFailure(value) {
+        this._rawIdentityCreateFromShieldedPoolTransition.sendToAddressOnCreationFailure = preparePlatformAddressValue(value);
+    }
+    get identityId() {
+        return IdentifierWASM.createFromRawInstance(this._rawIdentityCreateFromShieldedPoolTransition.identityId);
+    }
+    set identityId(value) {
+        this._rawIdentityCreateFromShieldedPoolTransition.identityId = prepareIdentifierValue(value);
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawIdentityCreateFromShieldedPoolTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return IdentityCreateFromShieldedPoolTransitionWASM.createFromRawInstance(dppProvider.dpp.IdentityCreateFromShieldedPoolTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(IdentityCreateFromShieldedPoolTransitionWASM.prototype);
+        instance._rawIdentityCreateFromShieldedPoolTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/ShieldedTransitions/SerializedAction.d.ts

@@ -0,0 +1,19 @@
+import type { SerializedActionNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class SerializedActionWASM {
+    /** @private **/
+    _rawSerializedAction: SerializedActionNAPI;
+    constructor(nullifier: Uint8Array, rk: Uint8Array, cmx: Uint8Array, encryptedNote: Uint8Array, cvNet: Uint8Array, spendAuthSig: Uint8Array);
+    get nullifier(): Uint8Array;
+    set nullifier(value: Uint8Array);
+    get rk(): Uint8Array;
+    set rk(value: Uint8Array);
+    get cmx(): Uint8Array;
+    set cmx(value: Uint8Array);
+    get encryptedNote(): Uint8Array;
+    set encryptedNote(value: Uint8Array);
+    get cvNet(): Uint8Array;
+    set cvNet(value: Uint8Array);
+    get spendAuthSig(): Uint8Array;
+    set spendAuthSig(value: Uint8Array);
+    static createFromRawInstance(rawInstance: SerializedActionNAPI): SerializedActionWASM;
+}

package/dist/src/dpp/structs/ShieldedTransitions/SerializedAction.js

@@ -0,0 +1,49 @@
+import { dppProvider } from '../../provider.js';
+export class SerializedActionWASM {
+    /** @private **/
+    _rawSerializedAction;
+    constructor(nullifier, rk, cmx, encryptedNote, cvNet, spendAuthSig) {
+        this._rawSerializedAction = new dppProvider.dpp.SerializedActionNAPI(nullifier, rk, cmx, encryptedNote, cvNet, spendAuthSig);
+    }
+    get nullifier() {
+        return this._rawSerializedAction.nullifier;
+    }
+    set nullifier(value) {
+        this._rawSerializedAction.nullifier = value;
+    }
+    get rk() {
+        return this._rawSerializedAction.rk;
+    }
+    set rk(value) {
+        this._rawSerializedAction.rk = value;
+    }
+    get cmx() {
+        return this._rawSerializedAction.cmx;
+    }
+    set cmx(value) {
+        this._rawSerializedAction.cmx = value;
+    }
+    get encryptedNote() {
+        return this._rawSerializedAction.encrypted_note;
+    }
+    set encryptedNote(value) {
+        this._rawSerializedAction.encrypted_note = value;
+    }
+    get cvNet() {
+        return this._rawSerializedAction.cvNet;
+    }
+    set cvNet(value) {
+        this._rawSerializedAction.cvNet = value;
+    }
+    get spendAuthSig() {
+        return this._rawSerializedAction.spendAuthSig;
+    }
+    set spendAuthSig(value) {
+        this._rawSerializedAction.spendAuthSig = value;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(SerializedActionWASM.prototype);
+        instance._rawSerializedAction = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/ShieldedTransitions/ShieldFromAssetLockTransition.d.ts

@@ -0,0 +1,30 @@
+import type { ShieldFromAssetLockTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { PlatformAddressLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class ShieldFromAssetLockTransitionWASM {
+    /** @private **/
+    _rawShieldFromAssetLockTransition: ShieldFromAssetLockTransitionNAPI;
+    constructor(assetLockProof: AssetLockProofWASM, actions: SerializedActionWASM[], valueBalance: bigint, anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array, surplusOutput?: PlatformAddressLike);
+    get assetLockProof(): AssetLockProofWASM;
+    set assetLockProof(value: AssetLockProofWASM);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get valueBalance(): bigint;
+    set valueBalance(value: bigint);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    get surplusOutput(): PlatformAddressWASM | undefined;
+    set surplusOutput(value: PlatformAddressLike | undefined);
+    get signature(): Uint8Array;
+    set signature(value: Uint8Array);
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): ShieldFromAssetLockTransitionWASM;
+    static createFromRawInstance(rawInstance: ShieldFromAssetLockTransitionNAPI): ShieldFromAssetLockTransitionWASM;
+}

package/dist/src/dpp/structs/ShieldedTransitions/ShieldFromAssetLockTransition.js

@@ -0,0 +1,77 @@
+import { SerializedActionWASM } from './SerializedAction.js';
+import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class ShieldFromAssetLockTransitionWASM {
+    /** @private **/
+    _rawShieldFromAssetLockTransition;
+    constructor(assetLockProof, actions, valueBalance, anchor, proof, bindingsSignature, surplusOutput) {
+        this._rawShieldFromAssetLockTransition = new dppProvider.dpp.ShieldFromAssetLockTransitionNAPI(assetLockProof._rawAssetLockProof, actions.map(a => a._rawSerializedAction), valueBalance.toString(), anchor, proof, bindingsSignature, surplusOutput != null ? preparePlatformAddressValue(surplusOutput) : undefined);
+    }
+    get assetLockProof() {
+        return AssetLockProofWASM.createFromRawInstance(this._rawShieldFromAssetLockTransition.assetLockProof);
+    }
+    set assetLockProof(value) {
+        this._rawShieldFromAssetLockTransition.assetLockProof = value._rawAssetLockProof;
+    }
+    get actions() {
+        return this._rawShieldFromAssetLockTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawShieldFromAssetLockTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get valueBalance() {
+        return BigInt(this._rawShieldFromAssetLockTransition.valueBalance);
+    }
+    set valueBalance(value) {
+        this._rawShieldFromAssetLockTransition.valueBalance = value.toString();
+    }
+    get anchor() {
+        return this._rawShieldFromAssetLockTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawShieldFromAssetLockTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawShieldFromAssetLockTransition.proof;
+    }
+    set proof(value) {
+        this._rawShieldFromAssetLockTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawShieldFromAssetLockTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawShieldFromAssetLockTransition.bindingsSignature = value;
+    }
+    get surplusOutput() {
+        const output = this._rawShieldFromAssetLockTransition.surplusOutput;
+        if (output != null) {
+            return PlatformAddressWASM.createFromRawInstance(output);
+        }
+    }
+    set surplusOutput(value) {
+        this._rawShieldFromAssetLockTransition.surplusOutput = value != null
+            ? preparePlatformAddressValue(value)
+            : undefined;
+    }
+    get signature() {
+        return this._rawShieldFromAssetLockTransition.signature;
+    }
+    set signature(value) {
+        this._rawShieldFromAssetLockTransition.signature = value;
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldFromAssetLockTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return ShieldFromAssetLockTransitionWASM.createFromRawInstance(dppProvider.dpp.ShieldFromAssetLockTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldFromAssetLockTransitionWASM.prototype);
+        instance._rawShieldFromAssetLockTransition = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/ShieldedTransitions/ShieldTransition.d.ts

@@ -0,0 +1,32 @@
+import type { ShieldTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { InputAddressWASM } from '../AddressTransitions/entities/InputAddress.js';
+import { AddressFundsFeeStrategyStepWASM } from '../AddressTransitions/entities/AddressFundsFeeStrategyStep.js';
+import { AddressWitnessWASM } from '../PlatformAddress/AddressWitness.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class ShieldTransitionWASM {
+    /** @private **/
+    _rawShieldTransition: ShieldTransitionNAPI;
+    constructor(inputs: InputAddressWASM[], actions: SerializedActionWASM[], amount: bigint, anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array, feeStrategy: AddressFundsFeeStrategyStepWASM[], userFeeIncrease: number, inputWitnesses: AddressWitnessWASM[]);
+    get inputs(): InputAddressWASM[];
+    set inputs(value: InputAddressWASM[]);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get amount(): bigint;
+    set amount(value: bigint);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    get feeStrategy(): AddressFundsFeeStrategyStepWASM[];
+    set feeStrategy(value: AddressFundsFeeStrategyStepWASM[]);
+    get userFeeIncrease(): number;
+    set userFeeIncrease(value: number);
+    get inputWitnesses(): AddressWitnessWASM[];
+    set inputWitnesses(value: AddressWitnessWASM[]);
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): ShieldTransitionWASM;
+    static createFromRawInstance(rawInstance: ShieldTransitionNAPI): ShieldTransitionWASM;
+}

package/dist/src/dpp/structs/ShieldedTransitions/ShieldTransition.js

@@ -0,0 +1,78 @@
+import { InputAddressWASM } from '../AddressTransitions/entities/InputAddress.js';
+import { AddressFundsFeeStrategyStepWASM } from '../AddressTransitions/entities/AddressFundsFeeStrategyStep.js';
+import { AddressWitnessWASM } from '../PlatformAddress/AddressWitness.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { dppProvider } from '../../provider.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class ShieldTransitionWASM {
+    /** @private **/
+    _rawShieldTransition;
+    constructor(inputs, actions, amount, anchor, proof, bindingsSignature, feeStrategy, userFeeIncrease, inputWitnesses) {
+        this._rawShieldTransition = new dppProvider.dpp.ShieldTransitionNAPI(inputs.map(i => i._rawInputAddress), actions.map(a => a._rawSerializedAction), amount.toString(), anchor, proof, bindingsSignature, feeStrategy.map(s => s._rawAddressFundsFeeStrategyStep), userFeeIncrease, inputWitnesses.map(w => w._rawWitness));
+    }
+    get inputs() {
+        return this._rawShieldTransition.inputs.map(InputAddressWASM.createFromRawInstance);
+    }
+    set inputs(value) {
+        this._rawShieldTransition.inputs = value.map(i => i._rawInputAddress);
+    }
+    get actions() {
+        return this._rawShieldTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawShieldTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get amount() {
+        return BigInt(this._rawShieldTransition.amount);
+    }
+    set amount(value) {
+        this._rawShieldTransition.amount = value.toString();
+    }
+    get anchor() {
+        return this._rawShieldTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawShieldTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawShieldTransition.proof;
+    }
+    set proof(value) {
+        this._rawShieldTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawShieldTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawShieldTransition.bindingsSignature = value;
+    }
+    get feeStrategy() {
+        return this._rawShieldTransition.feeStrategy.map(AddressFundsFeeStrategyStepWASM.createFromRawInstance);
+    }
+    set feeStrategy(value) {
+        this._rawShieldTransition.feeStrategy = value.map(s => s._rawAddressFundsFeeStrategyStep);
+    }
+    get userFeeIncrease() {
+        return this._rawShieldTransition.userFeeIncrease;
+    }
+    set userFeeIncrease(value) {
+        this._rawShieldTransition.userFeeIncrease = value;
+    }
+    get inputWitnesses() {
+        return this._rawShieldTransition.inputWitnesses.map(AddressWitnessWASM.createFromRawInstance);
+    }
+    set inputWitnesses(value) {
+        this._rawShieldTransition.inputWitnesses = value.map(w => w._rawWitness);
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return ShieldTransitionWASM.createFromRawInstance(dppProvider.dpp.ShieldTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldTransitionWASM.prototype);
+        instance._rawShieldTransition = rawInstance;
+        return instance;
+    }
+}