pshenmic-dpp 2.0.0-dev.9 → 2.0.0

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

@@ -0,0 +1,76 @@
+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);
+    }
+    static computeMinimumFee(numActions, numKeys, platformVersion) {
+        return BigInt(dppProvider.dpp.IdentityCreateFromShieldedPoolTransitionNAPI.computeMinimumFee(numActions, numKeys, platformVersion));
+    }
+    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,31 @@
+import type { PlatformVersionNAPI, 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);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): ShieldFromAssetLockTransitionWASM;
+    static createFromRawInstance(rawInstance: ShieldFromAssetLockTransitionNAPI): ShieldFromAssetLockTransitionWASM;
+}

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

@@ -0,0 +1,80 @@
+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;
+    }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.ShieldFromAssetLockTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
+    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,33 @@
+import type { PlatformVersionNAPI, 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[]);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): ShieldTransitionWASM;
+    static createFromRawInstance(rawInstance: ShieldTransitionNAPI): ShieldTransitionWASM;
+}

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

@@ -0,0 +1,81 @@
+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);
+    }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.ShieldTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
+    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;
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { PlatformVersionNAPI, ShieldedTransferTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class ShieldedTransferTransitionWASM {
+    /** @private **/
+    _rawShieldedTransferTransition: ShieldedTransferTransitionNAPI;
+    constructor(actions: SerializedActionWASM[], valueBalance: bigint, anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array);
+    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);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): ShieldedTransferTransitionWASM;
+    static createFromRawInstance(rawInstance: ShieldedTransferTransitionNAPI): ShieldedTransferTransitionWASM;
+}

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

@@ -0,0 +1,54 @@
+import { SerializedActionWASM } from './SerializedAction.js';
+import { dppProvider } from '../../provider.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class ShieldedTransferTransitionWASM {
+    /** @private **/
+    _rawShieldedTransferTransition;
+    constructor(actions, valueBalance, anchor, proof, bindingsSignature) {
+        this._rawShieldedTransferTransition = new dppProvider.dpp.ShieldedTransferTransitionNAPI(actions.map(a => a._rawSerializedAction), valueBalance.toString(), anchor, proof, bindingsSignature);
+    }
+    get actions() {
+        return this._rawShieldedTransferTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawShieldedTransferTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get valueBalance() {
+        return BigInt(this._rawShieldedTransferTransition.valueBalance);
+    }
+    set valueBalance(value) {
+        this._rawShieldedTransferTransition.valueBalance = value.toString();
+    }
+    get anchor() {
+        return this._rawShieldedTransferTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawShieldedTransferTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawShieldedTransferTransition.proof;
+    }
+    set proof(value) {
+        this._rawShieldedTransferTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawShieldedTransferTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawShieldedTransferTransition.bindingsSignature = value;
+    }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.ShieldedTransferTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedTransferTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return ShieldedTransferTransitionWASM.createFromRawInstance(dppProvider.dpp.ShieldedTransferTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedTransferTransitionWASM.prototype);
+        instance._rawShieldedTransferTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,30 @@
+import type { PlatformVersionNAPI, ShieldedWithdrawalTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { CoreScriptWASM } from '../CoreScript.js';
+import { PoolingLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class ShieldedWithdrawalTransitionWASM {
+    /** @private **/
+    _rawShieldedWithdrawalTransition: ShieldedWithdrawalTransitionNAPI;
+    constructor(actions: SerializedActionWASM[], unshieldingAmount: bigint, anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array, coreFeePerByte: number, pooling: PoolingLike, outputScript: CoreScriptWASM);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get unshieldingAmount(): bigint;
+    set unshieldingAmount(value: bigint);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    get coreFeePerByte(): number;
+    set coreFeePerByte(value: number);
+    get pooling(): string;
+    set pooling(value: PoolingLike);
+    get outputScript(): CoreScriptWASM;
+    set outputScript(value: CoreScriptWASM);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): ShieldedWithdrawalTransitionWASM;
+    static createFromRawInstance(rawInstance: ShieldedWithdrawalTransitionNAPI): ShieldedWithdrawalTransitionWASM;
+}

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

@@ -0,0 +1,74 @@
+import { SerializedActionWASM } from './SerializedAction.js';
+import { CoreScriptWASM } from '../CoreScript.js';
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class ShieldedWithdrawalTransitionWASM {
+    /** @private **/
+    _rawShieldedWithdrawalTransition;
+    constructor(actions, unshieldingAmount, anchor, proof, bindingsSignature, coreFeePerByte, pooling, outputScript) {
+        this._rawShieldedWithdrawalTransition = new dppProvider.dpp.ShieldedWithdrawalTransitionNAPI(actions.map(a => a._rawSerializedAction), unshieldingAmount.toString(), anchor, proof, bindingsSignature, coreFeePerByte, valueToDynamicValue(pooling), outputScript._rawCoreScript);
+    }
+    get actions() {
+        return this._rawShieldedWithdrawalTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawShieldedWithdrawalTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get unshieldingAmount() {
+        return BigInt(this._rawShieldedWithdrawalTransition.unshieldingAmount);
+    }
+    set unshieldingAmount(value) {
+        this._rawShieldedWithdrawalTransition.unshieldingAmount = value.toString();
+    }
+    get anchor() {
+        return this._rawShieldedWithdrawalTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawShieldedWithdrawalTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawShieldedWithdrawalTransition.proof;
+    }
+    set proof(value) {
+        this._rawShieldedWithdrawalTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawShieldedWithdrawalTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawShieldedWithdrawalTransition.bindingsSignature = value;
+    }
+    get coreFeePerByte() {
+        return this._rawShieldedWithdrawalTransition.coreFeePerByte;
+    }
+    set coreFeePerByte(value) {
+        this._rawShieldedWithdrawalTransition.coreFeePerByte = value;
+    }
+    get pooling() {
+        return this._rawShieldedWithdrawalTransition.pooling;
+    }
+    set pooling(value) {
+        this._rawShieldedWithdrawalTransition.pooling = valueToDynamicValue(value);
+    }
+    get outputScript() {
+        return CoreScriptWASM.createFromRawInstance(this._rawShieldedWithdrawalTransition.outputScript);
+    }
+    set outputScript(value) {
+        this._rawShieldedWithdrawalTransition.outputScript = value._rawCoreScript;
+    }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.ShieldedWithdrawalTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedWithdrawalTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return ShieldedWithdrawalTransitionWASM.createFromRawInstance(dppProvider.dpp.ShieldedWithdrawalTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedWithdrawalTransitionWASM.prototype);
+        instance._rawShieldedWithdrawalTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { PlatformVersionNAPI, UnshieldTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import { SerializedActionWASM } from './SerializedAction.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { PlatformAddressLike } from '../../types.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export declare class UnshieldTransitionWASM {
+    /** @private **/
+    _rawUnshieldTransition: UnshieldTransitionNAPI;
+    constructor(outputAddress: PlatformAddressLike, actions: SerializedActionWASM[], unshieldingAmount: bigint, anchor: Uint8Array, proof: Uint8Array, bindingsSignature: Uint8Array);
+    get outputAddress(): PlatformAddressWASM;
+    set outputAddress(value: PlatformAddressLike);
+    get actions(): SerializedActionWASM[];
+    set actions(value: SerializedActionWASM[]);
+    get unshieldingAmount(): bigint;
+    set unshieldingAmount(value: bigint);
+    get anchor(): Uint8Array;
+    set anchor(value: Uint8Array);
+    get proof(): Uint8Array;
+    set proof(value: Uint8Array);
+    get bindingsSignature(): Uint8Array;
+    set bindingsSignature(value: Uint8Array);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
+    toStateTransition(): StateTransitionWASM;
+    static fromStateTransition(st: StateTransitionWASM): UnshieldTransitionWASM;
+    static createFromRawInstance(rawInstance: UnshieldTransitionNAPI): UnshieldTransitionWASM;
+}

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

@@ -0,0 +1,62 @@
+import { SerializedActionWASM } from './SerializedAction.js';
+import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue } from '../../utils.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+export class UnshieldTransitionWASM {
+    /** @private **/
+    _rawUnshieldTransition;
+    constructor(outputAddress, actions, unshieldingAmount, anchor, proof, bindingsSignature) {
+        this._rawUnshieldTransition = new dppProvider.dpp.UnshieldTransitionNAPI(preparePlatformAddressValue(outputAddress), actions.map(a => a._rawSerializedAction), unshieldingAmount.toString(), anchor, proof, bindingsSignature);
+    }
+    get outputAddress() {
+        return PlatformAddressWASM.createFromRawInstance(this._rawUnshieldTransition.outputAddress);
+    }
+    set outputAddress(value) {
+        this._rawUnshieldTransition.outputAddress = preparePlatformAddressValue(value);
+    }
+    get actions() {
+        return this._rawUnshieldTransition.actions.map(SerializedActionWASM.createFromRawInstance);
+    }
+    set actions(value) {
+        this._rawUnshieldTransition.actions = value.map(a => a._rawSerializedAction);
+    }
+    get unshieldingAmount() {
+        return BigInt(this._rawUnshieldTransition.unshieldingAmount);
+    }
+    set unshieldingAmount(value) {
+        this._rawUnshieldTransition.unshieldingAmount = value.toString();
+    }
+    get anchor() {
+        return this._rawUnshieldTransition.anchor;
+    }
+    set anchor(value) {
+        this._rawUnshieldTransition.anchor = value;
+    }
+    get proof() {
+        return this._rawUnshieldTransition.proof;
+    }
+    set proof(value) {
+        this._rawUnshieldTransition.proof = value;
+    }
+    get bindingsSignature() {
+        return this._rawUnshieldTransition.bindingsSignature;
+    }
+    set bindingsSignature(value) {
+        this._rawUnshieldTransition.bindingsSignature = value;
+    }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.UnshieldTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
+    toStateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawUnshieldTransition.toStateTransition());
+    }
+    static fromStateTransition(st) {
+        return UnshieldTransitionWASM.createFromRawInstance(dppProvider.dpp.UnshieldTransitionNAPI.fromStateTransition(st._rawStateTransition));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(UnshieldTransitionWASM.prototype);
+        instance._rawUnshieldTransition = rawInstance;
+        return instance;
+    }
+}

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

@@ -1,4 +1,4 @@
-import type { StateTransitionNAPI } from '../../../binaries/bindingsTypes.js';
+import type { StateTransitionNAPI, PlatformVersionNAPI } from '../../../binaries/bindingsTypes.js';
 import { PrivateKeyWASM } from './PrivateKey.js';
 import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
 import { IdentifierLike, KeyTypeLike, PurposeLike } from '../types.js';
@@ -29,6 +29,7 @@ export declare class StateTransitionWASM {
     setIdentityContractNonce(nonce: bigint): void;
     setIdentityNonce(nonce: bigint): void;
     getSignableBytes(): Uint8Array;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;