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

package/dist/src/dpp/structs/Orchard/ShieldedBuilder.js

@@ -0,0 +1,45 @@
+import { dppProvider } from '../../provider.js';
+import { preparePlatformAddressValue, valueToDynamicValue } from '../../utils.js';
+import { ShieldedWithdrawalResultWASM } from './ShieldedWithdrawalResult.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+import { IdentityCreateFromShieldedPoolResultWASM } from './IdentityCreateFromShieldedPoolResult.js';
+/**
+ * Builds and proves shielded (Orchard) state transitions. Construction builds
+ * the Halo 2 proving key (~seconds), so create one instance and reuse it.
+ *
+ * Deposits (`shield`, `shieldFromAssetLock`) don't need pool notes. Spends
+ * (`shieldedWithdrawal`, `unshield`, `shieldedTransfer`) need a `SpendableNote`
+ * witnessed against an on-chain anchor — rebuild the tree from the full pool
+ * note set (getShieldedEncryptedNotes) with `CommitmentTreeWASM`.
+ */
+export class ShieldedBuilderWASM {
+    /** @private **/
+    _rawShieldedBuilder;
+    constructor() {
+        this._rawShieldedBuilder = new dppProvider.dpp.ShieldedBuilderNAPI();
+    }
+    /** Asset lock -> pool (deposit). */
+    shieldFromAssetLock(recipient, shieldAmount, assetLockProof, privateKey, memo, dummyOutputs, senderOvk, surplusOutput, platformVersion) {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedBuilder.shieldFromAssetLock(recipient._rawOrchardAddress, shieldAmount.toString(), assetLockProof._rawAssetLockProof, privateKey._rawPrivateKey, memo._rawShieldedMemo, dummyOutputs, senderOvk, surplusOutput != null ? preparePlatformAddressValue(surplusOutput) : undefined, platformVersion));
+    }
+    /** Transparent platform addresses -> pool (deposit). One private key per input. */
+    shield(recipient, shieldAmount, inputs, privateKeys, feeStrategy, userFeeIncrease, memo, senderOvk, platformVersion) {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedBuilder.shield(recipient._rawOrchardAddress, shieldAmount.toString(), inputs.map(i => i._rawInputAddress), privateKeys.map(k => k._rawPrivateKey), feeStrategy.map(s => s._rawAddressFundsFeeStrategyStep), userFeeIncrease, memo._rawShieldedMemo, senderOvk, platformVersion));
+    }
+    /** Pool -> core L1 (spend). */
+    shieldedWithdrawal(spends, withdrawalAmount, outputScript, coreFeePerByte, pooling, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.shieldedWithdrawal(spends.map(s => s._rawSpendableNote), withdrawalAmount.toString(), outputScript._rawCoreScript, coreFeePerByte, valueToDynamicValue(pooling), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    }
+    /** Pool -> platform identity balance (spend). */
+    unshield(spends, outputAddress, unshieldAmount, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.unshield(spends.map(s => s._rawSpendableNote), preparePlatformAddressValue(outputAddress), unshieldAmount.toString(), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    }
+    /** Pool -> pool (spend). */
+    shieldedTransfer(spends, recipient, transferAmount, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return ShieldedWithdrawalResultWASM.createFromRawInstance(this._rawShieldedBuilder.shieldedTransfer(spends.map(s => s._rawSpendableNote), recipient._rawOrchardAddress, transferAmount.toString(), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    }
+    /** Pool -> new identity (spend). One private key per public key, same order. */
+    identityCreateFromShieldedPool(publicKeys, privateKeys, denomination, sendToAddressOnCreationFailure, spends, changeAddress, seed, coinType, account, anchor, memo, platformVersion) {
+        return IdentityCreateFromShieldedPoolResultWASM.createFromRawInstance(this._rawShieldedBuilder.identityCreateFromShieldedPool(publicKeys.map(k => k._rawKeyInCreation), privateKeys.map(k => k._rawPrivateKey), denomination.toString(), preparePlatformAddressValue(sendToAddressOnCreationFailure), spends.map(s => s._rawSpendableNote), changeAddress._rawOrchardAddress, seed, coinType, account, anchor, memo._rawShieldedMemo, platformVersion));
+    }
+}

package/dist/src/dpp/structs/Orchard/ShieldedMemo.d.ts

@@ -0,0 +1,11 @@
+import type { ShieldedMemoNAPI } from '../../../../binaries/bindingsTypes.js';
+export declare class ShieldedMemoWASM {
+    /** @private **/
+    _rawShieldedMemo: ShieldedMemoNAPI;
+    toString(): string;
+    toBytes(): Uint8Array;
+    static empty(): ShieldedMemoWASM;
+    static fromString(value: string): ShieldedMemoWASM;
+    static other(kind: number, payload: Uint8Array): ShieldedMemoWASM;
+    static createFromRawInstance(rawInstance: ShieldedMemoNAPI): ShieldedMemoWASM;
+}

package/dist/src/dpp/structs/Orchard/ShieldedMemo.js

@@ -0,0 +1,25 @@
+import { dppProvider } from '../../provider.js';
+export class ShieldedMemoWASM {
+    /** @private **/
+    _rawShieldedMemo;
+    toString() {
+        return this._rawShieldedMemo.toString();
+    }
+    toBytes() {
+        return this._rawShieldedMemo.toBytes();
+    }
+    static empty() {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.empty());
+    }
+    static fromString(value) {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.fromString(value));
+    }
+    static other(kind, payload) {
+        return ShieldedMemoWASM.createFromRawInstance(dppProvider.dpp.ShieldedMemoNAPI.other(kind, payload));
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedMemoWASM.prototype);
+        instance._rawShieldedMemo = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Orchard/ShieldedWithdrawalResult.d.ts

@@ -0,0 +1,11 @@
+import type { ShieldedWithdrawalResultNAPI } from '../../../../binaries/bindingsTypes.js';
+import { StateTransitionWASM } from '../StateTransition.js';
+/** Result of a proving shielded spend (withdrawal / unshield / transfer). */
+export declare class ShieldedWithdrawalResultWASM {
+    /** @private **/
+    _rawShieldedWithdrawalResult: ShieldedWithdrawalResultNAPI;
+    get stateTransition(): StateTransitionWASM;
+    /** The fixed shielded fee (credits) consensus charges for the spend. */
+    get fee(): bigint;
+    static createFromRawInstance(rawInstance: ShieldedWithdrawalResultNAPI): ShieldedWithdrawalResultWASM;
+}

package/dist/src/dpp/structs/Orchard/ShieldedWithdrawalResult.js

@@ -0,0 +1,18 @@
+import { StateTransitionWASM } from '../StateTransition.js';
+/** Result of a proving shielded spend (withdrawal / unshield / transfer). */
+export class ShieldedWithdrawalResultWASM {
+    /** @private **/
+    _rawShieldedWithdrawalResult;
+    get stateTransition() {
+        return StateTransitionWASM.createFromRawInstance(this._rawShieldedWithdrawalResult.stateTransition);
+    }
+    /** The fixed shielded fee (credits) consensus charges for the spend. */
+    get fee() {
+        return BigInt(this._rawShieldedWithdrawalResult.fee);
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(ShieldedWithdrawalResultWASM.prototype);
+        instance._rawShieldedWithdrawalResult = rawInstance;
+        return instance;
+    }
+}

package/dist/src/dpp/structs/Orchard/SpendableNote.d.ts

@@ -0,0 +1,13 @@
+import type { SpendableNoteNAPI } from '../../../../binaries/bindingsTypes.js';
+import { NoteWASM } from './Note.js';
+import { MerklePathWASM } from './MerklePath.js';
+export declare class SpendableNoteWASM {
+    /** @private **/
+    _rawSpendableNote: SpendableNoteNAPI;
+    constructor(note: NoteWASM, merklePath: MerklePathWASM);
+    get note(): NoteWASM;
+    set note(value: NoteWASM);
+    get merklePath(): MerklePathWASM;
+    set merklePath(value: MerklePathWASM);
+    static createFromRawInstance(rawInstance: SpendableNoteNAPI): SpendableNoteWASM;
+}

package/dist/src/dpp/structs/Orchard/SpendableNote.js

@@ -0,0 +1,27 @@
+import { dppProvider } from '../../provider.js';
+import { NoteWASM } from './Note.js';
+import { MerklePathWASM } from './MerklePath.js';
+export class SpendableNoteWASM {
+    /** @private **/
+    _rawSpendableNote;
+    constructor(note, merklePath) {
+        this._rawSpendableNote = new dppProvider.dpp.SpendableNoteNAPI(note._rawNote, merklePath._rawMerklePath);
+    }
+    get note() {
+        return NoteWASM.createFromRawInstance(this._rawSpendableNote.note);
+    }
+    set note(value) {
+        this._rawSpendableNote.note = value._rawNote;
+    }
+    get merklePath() {
+        return MerklePathWASM.createFromRawInstance(this._rawSpendableNote.merklePath);
+    }
+    set merklePath(value) {
+        this._rawSpendableNote.merklePath = value._rawMerklePath;
+    }
+    static createFromRawInstance(rawInstance) {
+        const instance = Object.create(SpendableNoteWASM.prototype);
+        instance._rawSpendableNote = 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;
+}