dash-platform-sdk 1.4.0 → 1.5.0-dev.1

package/src/shielded/index.js

@@ -0,0 +1,186 @@
+import getShieldedEncryptedNotes from './getShieldedEncryptedNotes.js';
+import getShieldedAnchors from './getShieldedAnchors.js';
+import getMostRecentShieldedAnchor from './getMostRecentShieldedAnchor.js';
+import getShieldedPoolState from './getShieldedPoolState.js';
+import getShieldedNotesCount from './getShieldedNotesCount.js';
+import getShieldedNullifiers from './getShieldedNullifiers.js';
+import createStateTransition from './createStateTransition.js';
+import { CommitmentTreeWASM, ContractBoundsWASM, IdentityPublicKeyInCreationWASM, recoverNotes, SerializedActionWASM, ShieldedBuilderWASM, ShieldedMemoWASM, SpendableNoteWASM } from 'pshenmic-dpp';
+/**
+ * Shielded controller for requesting information about shielded pool
+ *
+ * @hideconstructor
+ */
+export class ShieldedController {
+    /** @ignore **/
+    grpcPool;
+    /** @ignore **/
+    shieldedBuilder;
+    constructor(grpcPool) {
+        this.grpcPool = grpcPool;
+    }
+    /**
+     * Set bindings instance of builder
+     * Needed for custom builder load, because ShieldedBuilderWASM inits very slow on old hardware
+     */
+    init(builder) {
+        this.shieldedBuilder = builder ?? new ShieldedBuilderWASM();
+        return this.shieldedBuilder;
+    }
+    /**
+     * Lazily constructs and caches a {ShieldedBuilderWASM}. Construction builds
+     * the Halo 2 proving key (~seconds), so the instance is created once and reused.
+     *
+     * @ignore
+     */
+    getShieldedBuilder() {
+        if (this.shieldedBuilder == null) {
+            return this.init();
+        }
+        return this.shieldedBuilder;
+    }
+    /**
+     * Retrieves a batch of shielded encrypted notes from the shielded pool,
+     * starting from the given note index.
+     *
+     * Returns an array of encrypted notes, each containing the nullifier,
+     * note commitment (cmx), encrypted note payload and value commitment (cvNet).
+     *
+     * @param startIndex {bigint} - index of the first note to fetch
+     * @param count {number} - amount of notes to fetch
+     *
+     * @return {Promise<ShieldedEncryptedNote[]>}
+     */
+    async getShieldedEncryptedNotes(startIndex, count) {
+        return await getShieldedEncryptedNotes(this.grpcPool, startIndex, count);
+    }
+    /**
+     * Retrieves the set of valid anchors (note commitment tree roots) currently
+     * accepted by the shielded pool.
+     *
+     * @return {Promise<Uint8Array[]>}
+     */
+    async getShieldedAnchors() {
+        return await getShieldedAnchors(this.grpcPool);
+    }
+    /**
+     * Retrieves the most recent anchor (note commitment tree root) of the shielded pool.
+     *
+     * @return {Promise<Uint8Array>}
+     */
+    async getMostRecentShieldedAnchor() {
+        return await getMostRecentShieldedAnchor(this.grpcPool);
+    }
+    /**
+     * Retrieves the total balance currently held in the shielded pool.
+     *
+     * @return {Promise<bigint>}
+     */
+    async getShieldedPoolState() {
+        return await getShieldedPoolState(this.grpcPool);
+    }
+    /**
+     * Retrieves the total count of notes (leaves) in the shielded notes
+     * commitment tree. Useful as a denominator for shielded sync progress.
+     *
+     * @return {Promise<bigint>}
+     */
+    async getShieldedNotesCount() {
+        return await getShieldedNotesCount(this.grpcPool);
+    }
+    /**
+     * Checks the spent status of the given nullifiers in the shielded pool.
+     *
+     * Returns an array of statuses, each containing the nullifier and whether
+     * it has already been spent.
+     *
+     * @param nullifiers {Uint8Array[]} - nullifiers to check
+     *
+     * @return {Promise<ShieldedNullifierStatus[]>}
+     */
+    async getShieldedNullifiers(nullifiers) {
+        return await getShieldedNullifiers(this.grpcPool, nullifiers);
+    }
+    /**
+     * Recovers the notes owned by a wallet from a set of shielded encrypted notes
+     * (as returned by {@link getShieldedEncryptedNotes}) by trial-decrypting each
+     * with the viewing key derived from the seed (ZIP-32 m/32'/coinType'/account').
+     * Only notes addressed to the wallet are returned, each with its global leaf
+     * position (`index`) in the commitment tree.
+     *
+     * @param notes {ShieldedEncryptedNote[]} - shielded encrypted notes to scan
+     * @param seed {Uint8Array} - BIP-39 seed bytes
+     * @param account {number} - ZIP-32 account index
+     *
+     * @return {RecoveredNoteWASM[]}
+     */
+    recoverNotes(notes, seed, account) {
+        // SLIP-44 coin type: 5 = Dash mainnet, 1 = testnets. Orchard derives via ZIP-32
+        const coinType = this.grpcPool.network === 'mainnet' ? 5 : 1;
+        // ShieldedEncryptedNote carries everything needed for trial-decryption; the
+        // spend-authorization fields (rk, spendAuthSig) are unused here, so zero them.
+        const actions = notes.map(note => new SerializedActionWASM(note.nullifier, new Uint8Array(32), note.cmx, note.encryptedNote, note.cvNet, new Uint8Array(64)));
+        return recoverNotes(actions, seed, coinType, account);
+    }
+    /**
+     * Rebuilds the note commitment tree from the full on-chain note set and
+     * witnesses the given recovered notes against it, producing the spendable
+     * notes and the shared anchor required by spend transitions (`shieldedTransfer`,
+     * `unshield`, `shieldedWithdrawal`, `identityCreateFromShieldedPool`).
+     *
+     * Pass the complete note set from {@link getShieldedEncryptedNotes} as `notes`
+     * (the commitment tree leaves) and the notes you want to spend from
+     * {@link recoverNotes} as `recovered`. This keeps the whole spend flow inside
+     * the SDK — no need to construct a commitment tree yourself.
+     *
+     * @param notes {ShieldedEncryptedNote[]} - full on-chain note set (the tree leaves)
+     * @param recovered {RecoveredNoteWASM[]} - the recovered notes to spend
+     *
+     * @return {{ spends: SpendableNoteWASM[], anchor: Uint8Array }}
+     */
+    buildSpendableNotes(notes, recovered) {
+        // only the leaves we intend to witness need to be marked spendable
+        const spendableIndices = new Set(recovered.map(note => note.index));
+        const tree = new CommitmentTreeWASM();
+        notes.forEach((note, index) => tree.append(note.cmx, spendableIndices.has(index)));
+        tree.checkpoint(0);
+        const anchor = tree.anchor();
+        const spends = recovered.map(recoveredNote => {
+            const merklePath = tree.witness(recoveredNote.index, 0) ?? tree.witness(recoveredNote.index, 1);
+            if (merklePath == null) {
+                throw new Error(`Failed to witness recovered note at index ${recoveredNote.index}`);
+            }
+            return new SpendableNoteWASM(recoveredNote.note, merklePath);
+        });
+        return { spends, anchor };
+    }
+    /**
+     * Helper function for building and proving shielded (Orchard) transitions.
+     * It may be used to create any of 6 shielded transition actions:
+     *
+     * 1) shield - transparent platform addresses -> pool (deposit)
+     * 2) shieldFromAssetLock - asset lock -> pool (deposit)
+     * 3) shieldedWithdrawal - pool -> core L1 (spend)
+     * 4) unshield - pool -> platform identity balance (spend)
+     * 5) shieldedTransfer - pool -> pool (spend)
+     * 6) identityCreateFromShieldedPool - pool -> new identity (spend)
+     *
+     * Spends require a {SpendableNoteWASM} witnessed against an on-chain anchor.
+     *
+     * @param type {string} Type of the shielded transition, must be one of ('shield' | 'shieldFromAssetLock' | 'shieldedWithdrawal' | 'unshield' | 'shieldedTransfer' | 'identityCreateFromShieldedPool')
+     * @param params {ShieldedTransitionParams} params
+     *
+     * @return {StateTransitionWASM}
+     */
+    createStateTransition(type, params) {
+        // @ts-expect-error a plain string memo is normalized to ShieldedMemoWASM (empty when omitted)
+        params.memo = typeof params.memo === 'string' ? ShieldedMemoWASM.fromString(params.memo) : ShieldedMemoWASM.empty();
+        if (type === 'identityCreateFromShieldedPool') {
+            const identityParams = params;
+            // @ts-expect-error builder expects IdentityPublicKeyInCreationWASM instances
+            identityParams.publicKeys = identityParams.publicKeys
+                .map(({ id, purpose, securityLevel, keyType, readOnly, data, signature, contractBounds }) => new IdentityPublicKeyInCreationWASM(id, purpose, securityLevel, keyType, readOnly, data, signature, (contractBounds != null) ? new ContractBoundsWASM(contractBounds.dataContractId, contractBounds.documentType) : undefined));
+        }
+        return createStateTransition(this.getShieldedBuilder(), type, params);
+    }
+}

package/test/unit/KeyPair.spec.js

@@ -1,3 +1,4 @@
+import { OrchardAddressWASM } from 'pshenmic-dpp';
 import { DashPlatformSDK } from '../../src/DashPlatformSDK.js';
 let sdk;
 let mnemonic;
@@ -31,4 +32,35 @@ describe('KeyPair', () => {
             expect(key.privateKey).toEqual(Uint8Array.from([89, 255, 64, 41, 202, 170, 83, 68, 135, 58, 161, 107, 130, 20, 3, 50, 69, 16, 108, 104, 32, 68, 13, 100, 225, 24, 79, 20, 193, 184, 238, 55]));
         });
     });
+    describe('shielded', () => {
+        const account = 0;
+        test('should be able to derive a shielded address from seed', () => {
+            const seed = sdk.keyPair.mnemonicToSeed(mnemonic);
+            const address = sdk.keyPair.deriveShieldedAddress(seed, 'testnet', account);
+            expect(address).toEqual(expect.any(OrchardAddressWASM));
+            expect(address.bytes()).toHaveLength(43);
+            // deterministic for the same seed/network/account
+            expect(address.bytes()).toEqual(sdk.keyPair.deriveShieldedAddress(seed, 'testnet', account).bytes());
+        });
+        test('should derive distinct shielded addresses per diversifier index', () => {
+            const seed = sdk.keyPair.mnemonicToSeed(mnemonic);
+            const first = sdk.keyPair.deriveShieldedAddress(seed, 'testnet', account, 0);
+            const second = sdk.keyPair.deriveShieldedAddress(seed, 'testnet', account, 1);
+            expect(first.bytes()).not.toEqual(second.bytes());
+        });
+        test('should derive distinct shielded addresses per network', () => {
+            const seed = sdk.keyPair.mnemonicToSeed(mnemonic);
+            const mainnet = sdk.keyPair.deriveShieldedAddress(seed, 'mainnet', account);
+            const testnet = sdk.keyPair.deriveShieldedAddress(seed, 'testnet', account);
+            expect(mainnet.bytes()).not.toEqual(testnet.bytes());
+        });
+        test('should be able to derive the outgoing viewing key from seed', () => {
+            const seed = sdk.keyPair.mnemonicToSeed(mnemonic);
+            const ovk = sdk.keyPair.deriveShieldedOutgoingViewingKey(seed, 'testnet', account);
+            expect(ovk).toBeInstanceOf(Uint8Array);
+            expect(ovk).toHaveLength(32);
+            // deterministic for the same seed/network/account
+            expect(ovk).toEqual(sdk.keyPair.deriveShieldedOutgoingViewingKey(seed, 'testnet', account));
+        });
+    });
 });

package/test/unit/Shielded.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/test/unit/Shielded.spec.js

@@ -0,0 +1,236 @@
+import { AddressFundsFeeStrategyStepWASM, AssetLockProofWASM, CommitmentTreeWASM, CoreScriptWASM, InputAddressWASM, KeyType, NoteWASM, OrchardAddressWASM, OutPointWASM, PlatformAddressWASM, PrivateKeyWASM, Purpose, SecurityLevel, SpendableNoteWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { DashPlatformSDK } from '../../src/DashPlatformSDK.js';
+let sdk;
+const COIN_TYPE = 1;
+const ACCOUNT = 0;
+function randomBytes(length) {
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+    }
+    return bytes;
+}
+// Builds a 21-byte (version + pubkey hash) platform address.
+function platformAddress(keyHash = randomBytes(20)) {
+    const bytes = new Uint8Array(21);
+    bytes[0] = 0x00;
+    bytes.set(keyHash, 1);
+    return PlatformAddressWASM.fromBytes(bytes);
+}
+// Builds a spendable note owned by `seed` and a matching anchor by inserting its
+// commitment into a fresh commitment tree and witnessing it.
+function makeSpendableNote(seed, value) {
+    const owner = OrchardAddressWASM.fromSeed(seed, COIN_TYPE, ACCOUNT);
+    const rho = randomBytes(32);
+    rho[31] &= 0x1f; // keep rho a valid Pallas base field element
+    const note = new NoteWASM(owner, value, rho, randomBytes(32));
+    const tree = new CommitmentTreeWASM();
+    tree.append(note.cmx, true);
+    tree.checkpoint(0);
+    const anchor = tree.anchor();
+    const merklePath = tree.witness(0, 0) ?? tree.witness(0, 1);
+    if (merklePath == null) {
+        throw new Error('failed to witness note');
+    }
+    return { spend: new SpendableNoteWASM(note, merklePath), anchor, owner };
+}
+describe('Shielded', () => {
+    beforeAll(() => {
+        sdk = new DashPlatformSDK({ network: 'testnet' });
+    });
+    test('getShieldedNotesCount', async () => {
+        const count = await sdk.shielded.getShieldedNotesCount();
+        expect(typeof count).toBe('bigint');
+    });
+    test('getShieldedPoolState', async () => {
+        const totalBalance = await sdk.shielded.getShieldedPoolState();
+        expect(typeof totalBalance).toBe('bigint');
+    });
+    test('getShieldedAnchors', async () => {
+        const anchors = await sdk.shielded.getShieldedAnchors();
+        expect(Array.isArray(anchors)).toBe(true);
+        for (const anchor of anchors) {
+            expect(anchor).toBeInstanceOf(Uint8Array);
+        }
+    });
+    test('getMostRecentShieldedAnchor', async () => {
+        const anchor = await sdk.shielded.getMostRecentShieldedAnchor();
+        expect(anchor).toBeInstanceOf(Uint8Array);
+    });
+    test('getShieldedEncryptedNotes', async () => {
+        const count = await sdk.shielded.getShieldedNotesCount() ?? 0n;
+        const requested = Number(count > 10n ? 10n : count);
+        const notes = await sdk.shielded.getShieldedEncryptedNotes(0n, requested);
+        expect(notes).toHaveLength(requested);
+        for (const note of notes) {
+            expect(note.nullifier).toBeInstanceOf(Uint8Array);
+            expect(note.cmx).toBeInstanceOf(Uint8Array);
+            expect(note.encryptedNote).toBeInstanceOf(Uint8Array);
+            expect(note.cvNet).toBeInstanceOf(Uint8Array);
+        }
+    });
+    test('getShieldedNullifiers', async () => {
+        const notes = await sdk.shielded.getShieldedEncryptedNotes(0n, 1);
+        const nullifiers = notes.map(note => note.nullifier);
+        const statuses = await sdk.shielded.getShieldedNullifiers(nullifiers);
+        expect(statuses).toHaveLength(nullifiers.length);
+        for (const status of statuses) {
+            expect(status.nullifier).toBeInstanceOf(Uint8Array);
+            expect(typeof status.isSpent).toBe('boolean');
+        }
+    });
+    test('recoverNotes', () => {
+        const seed = randomBytes(32);
+        const notes = [
+            { nullifier: randomBytes(32), cmx: randomBytes(32), encryptedNote: randomBytes(580), cvNet: randomBytes(32) }
+        ];
+        const recovered = sdk.shielded.recoverNotes(notes, seed, ACCOUNT);
+        // random notes are not addressed to this seed, so none are recovered
+        expect(Array.isArray(recovered)).toBe(true);
+        expect(recovered).toHaveLength(0);
+    });
+    test('buildSpendableNotes produces a spend usable by a transition', () => {
+        const seed = randomBytes(32);
+        const owner = OrchardAddressWASM.fromSeed(seed, COIN_TYPE, ACCOUNT);
+        const rho = randomBytes(32);
+        rho[31] &= 0x1f;
+        const note = new NoteWASM(owner, BigInt(10000000000), rho, randomBytes(32));
+        // the on-chain note set: only `cmx` matters for rebuilding the tree
+        const notes = [
+            { nullifier: randomBytes(32), cmx: note.cmx, encryptedNote: randomBytes(580), cvNet: randomBytes(32) }
+        ];
+        // buildSpendableNotes only reads `.note` and `.index` off a recovered note
+        const recovered = [{ note, index: 0 }];
+        const { spends, anchor } = sdk.shielded.buildSpendableNotes(notes, recovered);
+        expect(spends).toHaveLength(1);
+        expect(spends[0]).toEqual(expect.any(SpendableNoteWASM));
+        expect(anchor).toBeInstanceOf(Uint8Array);
+        // the produced spend + anchor must actually prove a spend transition
+        const stateTransition = sdk.shielded.createStateTransition('shieldedTransfer', {
+            spends,
+            recipient: OrchardAddressWASM.fromSeed(randomBytes(32), COIN_TYPE, ACCOUNT),
+            transferAmount: BigInt(1000000),
+            changeAddress: owner,
+            seed,
+            coinType: COIN_TYPE,
+            account: ACCOUNT,
+            anchor
+        });
+        expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+    }, 60000);
+    describe('should be able to create state transition', () => {
+        test('should be able to create a shield transition', () => {
+            const seed = randomBytes(32);
+            const recipient = OrchardAddressWASM.fromSeed(seed, COIN_TYPE, ACCOUNT);
+            const privateKey = new PrivateKeyWASM(randomBytes(32), 'testnet');
+            const address = platformAddress(privateKey.getPublicKey().hash160());
+            const stateTransition = sdk.shielded.createStateTransition('shield', {
+                recipient,
+                shieldAmount: BigInt(50000000),
+                inputs: [new InputAddressWASM(address, 0, BigInt(100000000))],
+                privateKeys: [privateKey],
+                feeStrategy: [AddressFundsFeeStrategyStepWASM.DeductFromInput(0)],
+                userFeeIncrease: 0
+                // memo omitted -> defaults to an empty memo
+            });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        }, 60000);
+        test('should be able to create a shieldFromAssetLock transition', () => {
+            const seed = randomBytes(32);
+            const recipient = OrchardAddressWASM.fromSeed(seed, COIN_TYPE, ACCOUNT);
+            const privateKey = PrivateKeyWASM.fromHex('edd04a71bddb31e530f6c2314fd42ada333f6656bb853ece13f0577a8fd30612', 'testnet');
+            const txid = '61aede830477254876d435a317241ad46753c4b1350dc991a45ebcf19ab80a11';
+            const assetLockProof = AssetLockProofWASM.createChainAssetLockProof(1337, new OutPointWASM(txid, 0));
+            const stateTransition = sdk.shielded.createStateTransition('shieldFromAssetLock', {
+                recipient,
+                shieldAmount: BigInt(50000000),
+                assetLockProof,
+                privateKey,
+                memo: 'shielded-memo-padded-to-32-bytes',
+                dummyOutputs: 0
+            });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        }, 60000);
+        test('should be able to create a shieldedTransfer transition', () => {
+            const seed = randomBytes(32);
+            const { spend, anchor, owner } = makeSpendableNote(seed, BigInt(10000000000));
+            const recipient = OrchardAddressWASM.fromSeed(randomBytes(32), COIN_TYPE, ACCOUNT);
+            const stateTransition = sdk.shielded.createStateTransition('shieldedTransfer', {
+                spends: [spend],
+                recipient,
+                transferAmount: BigInt(1000000),
+                changeAddress: owner,
+                seed,
+                coinType: COIN_TYPE,
+                account: ACCOUNT,
+                anchor,
+                memo: 'shielded-memo-padded-to-32-bytes'
+            });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        }, 60000);
+        test('should be able to create an unshield transition', () => {
+            const seed = randomBytes(32);
+            const { spend, anchor, owner } = makeSpendableNote(seed, BigInt(10000000000));
+            const stateTransition = sdk.shielded.createStateTransition('unshield', {
+                spends: [spend],
+                outputAddress: platformAddress(),
+                unshieldAmount: BigInt(1000000),
+                changeAddress: owner,
+                seed,
+                coinType: COIN_TYPE,
+                account: ACCOUNT,
+                anchor,
+                memo: 'shielded-memo-padded-to-32-bytes'
+            });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        }, 60000);
+        test('should be able to create a shieldedWithdrawal transition', () => {
+            const seed = randomBytes(32);
+            const { spend, anchor, owner } = makeSpendableNote(seed, BigInt(10000000000));
+            const stateTransition = sdk.shielded.createStateTransition('shieldedWithdrawal', {
+                spends: [spend],
+                withdrawalAmount: BigInt(1000000),
+                outputScript: CoreScriptWASM.newP2PKH(randomBytes(20)),
+                coreFeePerByte: 1,
+                pooling: 'Standard',
+                changeAddress: owner,
+                seed,
+                coinType: COIN_TYPE,
+                account: ACCOUNT,
+                anchor,
+                memo: 'shielded-memo-padded-to-32-bytes'
+            });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        }, 60000);
+        // The proving step succeeds, but `IdentityCreateFromShieldedPoolResultWASM.identityId`
+        // (read while assembling the transition) rejects the derived id for synthetic notes.
+        // A real run needs a funded note and signed keys, so this is covered against a live pool.
+        test('should be able to create an identityCreateFromShieldedPool transition', () => {
+            const seed = randomBytes(32);
+            const { spend, anchor, owner } = makeSpendableNote(seed, BigInt(20000000000));
+            const privateKey = PrivateKeyWASM.fromHex('a1286dd195e2b8e1f6bdc946c56a53e0c544750d6452ddc0f4c593ef311f21af', 'testnet');
+            const identityPublicKeyInCreation = {
+                id: 0,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.MASTER,
+                keyType: KeyType.ECDSA_SECP256K1,
+                readOnly: false,
+                data: privateKey.getPublicKey().bytes()
+            };
+            const stateTransition = sdk.shielded.createStateTransition('identityCreateFromShieldedPool', {
+                publicKeys: [identityPublicKeyInCreation],
+                privateKeys: [privateKey],
+                denomination: BigInt(10000000000),
+                sendToAddressOnCreationFailure: platformAddress(),
+                spends: [spend],
+                changeAddress: owner,
+                seed,
+                coinType: COIN_TYPE,
+                account: ACCOUNT,
+                anchor,
+                memo: 'shielded-memo-padded-to-32-bytes'
+            });
+            expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
+        }, 60000);
+    });
+});

package/types.d.ts

@@ -1,4 +1,4 @@
-import { CoreScriptWASM, DocumentWASM, GasFeesPaidByWASM, IdentifierLike, IdentifierWASM, KeyType, PlatformAddressWASM, Purpose, SecurityLevel, TokenEmergencyActionWASM, TokenPricingScheduleWASM } from 'pshenmic-dpp';
+import { AddressFundsFeeStrategyStepWASM, AssetLockProofWASM, CoreScriptWASM, DocumentWASM, GasFeesPaidByWASM, IdentifierLike, IdentifierWASM, InputAddressWASM, KeyType, OrchardAddressWASM, PlatformAddressLike, PlatformAddressWASM, PlatformVersionWASM, PoolingLike, PrivateKeyWASM, Purpose, SecurityLevel, SpendableNoteWASM, TokenEmergencyActionWASM, TokenPricingScheduleWASM } from 'pshenmic-dpp';
 export { CoreScriptWASM, DocumentWASM, GasFeesPaidByWASM, IdentifierWASM, KeyType, Purpose, SecurityLevel, TokenEmergencyActionWASM, TokenPricingScheduleWASM, StateTransitionWASM, BatchTransitionWASM, IdentityPublicKeyWASM, PrivateKeyWASM, DataContractUpdateTransitionWASM, IdentityWASM, IdentityUpdateTransitionWASM, IdentityCreditTransferWASM, MasternodeVoteTransitionWASM, IdentifierLike, PlatformAddressLike } from 'pshenmic-dpp';
 export type Network = 'mainnet' | 'testnet';
 export { DashPlatformSDK } from './src/DashPlatformSDK.js';
@@ -20,6 +20,80 @@ export interface DocumentTransitionParams {
         gasFeesPaidBy: GasFeesPaidByWASM;
     };
 }
+export interface ShieldedTransitionBaseParams {
+    /** version of the platform (defaults to the latest supported version) */
+    platformVersion?: PlatformVersionWASM;
+}
+/** Spend inputs shared by `shieldedWithdrawal`, `unshield`, `shieldedTransfer` and `identityCreateFromShieldedPool`. */
+export interface ShieldedSpendParams extends ShieldedTransitionBaseParams {
+    spends: SpendableNoteWASM[];
+    changeAddress: OrchardAddressWASM;
+    seed: Uint8Array;
+    coinType: number;
+    account: number;
+    anchor: Uint8Array;
+    /** optional UTF-8 memo string (defaults to an empty memo) */
+    memo?: string;
+}
+/** Transparent platform addresses -> pool (deposit). */
+export interface ShieldParams extends ShieldedTransitionBaseParams {
+    recipient: OrchardAddressWASM;
+    shieldAmount: bigint;
+    inputs: InputAddressWASM[];
+    privateKeys: PrivateKeyWASM[];
+    feeStrategy: AddressFundsFeeStrategyStepWASM[];
+    userFeeIncrease: number;
+    /** optional UTF-8 memo string (defaults to an empty memo) */
+    memo?: string;
+    senderOvk?: Uint8Array;
+}
+/** Asset lock -> pool (deposit). */
+export interface ShieldFromAssetLockParams extends ShieldedTransitionBaseParams {
+    recipient: OrchardAddressWASM;
+    shieldAmount: bigint;
+    assetLockProof: AssetLockProofWASM;
+    privateKey: PrivateKeyWASM;
+    /** optional UTF-8 memo string (defaults to an empty memo) */
+    memo?: string;
+    dummyOutputs: number;
+    senderOvk?: Uint8Array;
+    surplusOutput?: PlatformAddressLike;
+}
+/** Pool -> core L1 (spend). */
+export interface ShieldedWithdrawalParams extends ShieldedSpendParams {
+    withdrawalAmount: bigint;
+    outputScript: CoreScriptWASM;
+    coreFeePerByte: number;
+    pooling: PoolingLike;
+}
+/** Pool -> platform identity balance (spend). */
+export interface UnshieldParams extends ShieldedSpendParams {
+    outputAddress: PlatformAddressLike;
+    unshieldAmount: bigint;
+}
+/** Pool -> pool (spend). */
+export interface ShieldedTransferParams extends ShieldedSpendParams {
+    recipient: OrchardAddressWASM;
+    transferAmount: bigint;
+}
+/** Pool -> new identity (spend). */
+export interface IdentityCreateFromShieldedPoolParams extends ShieldedSpendParams {
+    publicKeys: IdentityPublicKeyInCreation[];
+    privateKeys: PrivateKeyWASM[];
+    denomination: bigint;
+    sendToAddressOnCreationFailure: PlatformAddressLike;
+}
+/** Maps each shielded transition type to the params it requires. */
+export interface ShieldedTransitionParamsMap {
+    shield: ShieldParams;
+    shieldFromAssetLock: ShieldFromAssetLockParams;
+    shieldedWithdrawal: ShieldedWithdrawalParams;
+    unshield: UnshieldParams;
+    shieldedTransfer: ShieldedTransferParams;
+    identityCreateFromShieldedPool: IdentityCreateFromShieldedPoolParams;
+}
+export type ShieldedTransitionType = keyof ShieldedTransitionParamsMap;
+export type ShieldedTransitionParams = ShieldedTransitionParamsMap[ShieldedTransitionType];
 export interface MasternodeInfo {
     proTxHash: string;
     address: string;
@@ -210,3 +284,13 @@ export interface PlatformAddressInfo {
     nonce: number;
     balance: bigint;
 }
+export interface ShieldedEncryptedNote {
+    nullifier: Uint8Array;
+    cmx: Uint8Array;
+    encryptedNote: Uint8Array;
+    cvNet: Uint8Array;
+}
+export interface ShieldedNullifierStatus {
+    nullifier: Uint8Array;
+    isSpent: boolean;
+}