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

package/src/shielded/index.d.ts

@@ -0,0 +1,130 @@
+import GRPCConnectionPool from '../grpcConnectionPool.js';
+import { ShieldedEncryptedNote, ShieldedNullifierStatus, ShieldedTransitionParamsMap, ShieldedTransitionType } from '../../types.js';
+import { RecoveredNoteWASM, ShieldedBuilderWASM, SpendableNoteWASM, StateTransitionWASM } from 'pshenmic-dpp';
+/**
+ * Shielded controller for requesting information about shielded pool
+ *
+ * @hideconstructor
+ */
+export declare class ShieldedController {
+    /** @ignore **/
+    grpcPool: GRPCConnectionPool;
+    /** @ignore **/
+    shieldedBuilder?: ShieldedBuilderWASM;
+    constructor(grpcPool: GRPCConnectionPool);
+    /**
+     * Set bindings instance of builder
+     * Needed for custom builder load, because ShieldedBuilderWASM inits very slow on old hardware
+     */
+    init(builder?: ShieldedBuilderWASM): ShieldedBuilderWASM;
+    /**
+     * Lazily constructs and caches a {ShieldedBuilderWASM}. Construction builds
+     * the Halo 2 proving key (~seconds), so the instance is created once and reused.
+     *
+     * @ignore
+     */
+    getShieldedBuilder(): ShieldedBuilderWASM;
+    /**
+     * 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[]>}
+     */
+    getShieldedEncryptedNotes(startIndex: bigint, count: number): Promise<ShieldedEncryptedNote[]>;
+    /**
+     * Retrieves the set of valid anchors (note commitment tree roots) currently
+     * accepted by the shielded pool.
+     *
+     * @return {Promise<Uint8Array[]>}
+     */
+    getShieldedAnchors(): Promise<Uint8Array[]>;
+    /**
+     * Retrieves the most recent anchor (note commitment tree root) of the shielded pool.
+     *
+     * @return {Promise<Uint8Array>}
+     */
+    getMostRecentShieldedAnchor(): Promise<Uint8Array | undefined>;
+    /**
+     * Retrieves the total balance currently held in the shielded pool.
+     *
+     * @return {Promise<bigint>}
+     */
+    getShieldedPoolState(): Promise<bigint | undefined>;
+    /**
+     * Retrieves the total count of notes (leaves) in the shielded notes
+     * commitment tree. Useful as a denominator for shielded sync progress.
+     *
+     * @return {Promise<bigint>}
+     */
+    getShieldedNotesCount(): Promise<bigint | undefined>;
+    /**
+     * 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[]>}
+     */
+    getShieldedNullifiers(nullifiers: Uint8Array[]): Promise<ShieldedNullifierStatus[]>;
+    /**
+     * 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: ShieldedEncryptedNote[], seed: Uint8Array, account: number): RecoveredNoteWASM[];
+    /**
+     * 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: ShieldedEncryptedNote[], recovered: RecoveredNoteWASM[]): {
+        spends: SpendableNoteWASM[];
+        anchor: Uint8Array;
+    };
+    /**
+     * 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<K extends ShieldedTransitionType>(type: K, params: ShieldedTransitionParamsMap[K]): StateTransitionWASM;
+}

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/src/stateTransitions/broadcast.js

@@ -11,8 +11,9 @@ export default async function broadcast(grpcPool, stateTransition) {
         await grpcPool.getClient().broadcastStateTransition(broadcastStateTransitionRequest);
     }
     catch (err) {
-        if (err.meta?.['dash-serialized-consensus-error-bin']?.length !== 0) {
-            throw new Error(deserializeConsensusError(err.meta['dash-serialized-consensus-error-bin']));
+        const errorBin = err.meta?.['dash-serialized-consensus-error-bin'];
+        if (errorBin?.length !== 0 && errorBin != null) {
+            throw new Error(deserializeConsensusError(errorBin));
         }
         else {
             throw err;

package/test/unit/DataContract.spec.js

@@ -11,7 +11,7 @@ describe('DataContract', () => {
         ownerIdentifier = 'GARSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec';
         identityNonce = BigInt(11);
         config = {
-            $format_version: '1',
+            $formatVersion: '1',
             canBeDeleted: true,
             readonly: true,
             keepsHistory: false,

package/test/unit/Document.spec.js

@@ -1,4 +1,4 @@
-import { DocumentWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { DocumentWASM, GasFeesPaidByWASM, StateTransitionWASM } from 'pshenmic-dpp';
 import { DashPlatformSDK } from '../../src/DashPlatformSDK.js';
 let sdk;
 let dataContract;
@@ -42,6 +42,35 @@ describe('Document', () => {
         expect(document.dataContractId.base58()).toEqual(dataContract);
         expect(document).toEqual(expect.any(DocumentWASM));
     });
+    test('should be able to get document with startAt', async () => {
+        const dataContract = '6hVQW16jyvZyGSQk2YVty4ND6bgFXozizYWnPt753uW5';
+        const documentType = 'torrent';
+        const limit = 5;
+        // @ts-expect-error
+        const [firstQueriedDoc] = (await sdk.documents.query(dataContract, documentType, null, null, limit)).toReversed();
+        // @ts-expect-error
+        const [secondQueriedDoc] = await sdk.documents.query(dataContract, documentType, null, null, limit, firstQueriedDoc.id);
+        expect(secondQueriedDoc.id.base58()).toEqual(firstQueriedDoc.id.base58());
+        expect(secondQueriedDoc.createdAtBlockHeight).toEqual(undefined);
+        expect(secondQueriedDoc.dataContractId.base58()).toEqual(dataContract);
+        expect(secondQueriedDoc).toEqual(expect.any(DocumentWASM));
+    });
+    test('should be able to get document with startAfter', async () => {
+        const dataContract = '6hVQW16jyvZyGSQk2YVty4ND6bgFXozizYWnPt753uW5';
+        const documentType = 'torrent';
+        const limit = 5;
+        const masterQueryLimit = limit * 2;
+        // @ts-expect-error
+        const masterQuery = await sdk.documents.query(dataContract, documentType, null, null, masterQueryLimit);
+        // @ts-expect-error
+        const [firstQueriedDoc] = (await sdk.documents.query(dataContract, documentType, null, null, limit)).toReversed();
+        // @ts-expect-error
+        const [secondQueriedDoc] = await sdk.documents.query(dataContract, documentType, null, null, limit, undefined, firstQueriedDoc.id);
+        expect(masterQuery[5].id.base58()).toEqual(secondQueriedDoc.id.base58());
+        expect(secondQueriedDoc.createdAtBlockHeight).toEqual(undefined);
+        expect(secondQueriedDoc.dataContractId.base58()).toEqual(dataContract);
+        expect(secondQueriedDoc).toEqual(expect.any(DocumentWASM));
+    });
     describe('should be able to create state transition', () => {
         test('should be able to create a create transition', async () => {
             const document = sdk.documents.create(dataContract, documentType, data, identity);
@@ -67,7 +96,7 @@ describe('Document', () => {
                 tokenContractPosition: 0,
                 minimumTokenCost: BigInt(1000),
                 maximumTokenCost: BigInt(100000),
-                gasFeesPaidBy: 1 /* GasFeesPaidByWASM.ContractOwner */
+                gasFeesPaidBy: GasFeesPaidByWASM.ContractOwner
             };
             const stateTransition = sdk.documents.createStateTransition(document, 'create', { identityContractNonce, tokenPaymentInfo });
             expect(stateTransition).toEqual(expect.any(StateTransitionWASM));

package/test/unit/Identity.spec.js

@@ -1,4 +1,4 @@
-import { CoreScriptWASM, IdentityPublicKeyWASM, IdentityWASM, PrivateKeyWASM, StateTransitionWASM } from 'pshenmic-dpp';
+import { CoreScriptWASM, IdentityPublicKeyWASM, IdentityWASM, KeyType, PrivateKeyWASM, Purpose, SecurityLevel, StateTransitionWASM } from 'pshenmic-dpp';
 import { DashPlatformSDK } from '../../types.js';
 import { base58 } from '@scure/base';
 let sdk;
@@ -50,18 +50,18 @@ describe('Identity', () => {
             const privateKey1 = PrivateKeyWASM.fromHex('a1286dd195e2b8e1f6bdc946c56a53e0c544750d6452ddc0f4c593ef311f21af', 'testnet');
             const identityPublicKeyInCreation1 = {
                 id: 0,
-                purpose: 0 /* Purpose.AUTHENTICATION */,
-                securityLevel: 0 /* SecurityLevel.MASTER */,
-                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.MASTER,
+                keyType: KeyType.ECDSA_SECP256K1,
                 readOnly: false,
                 data: privateKey1.getPublicKey().bytes()
             };
             const privateKey2 = PrivateKeyWASM.fromHex('44a8195e242364b935e9d7ff2106ed109e9baf3800907f5e58a259fdfd1ca5e5', 'testnet');
             const identityPublicKeyInCreation2 = {
                 id: 1,
-                purpose: 0 /* Purpose.AUTHENTICATION */,
-                securityLevel: 2 /* SecurityLevel.HIGH */,
-                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.HIGH,
+                keyType: KeyType.ECDSA_SECP256K1,
                 readOnly: false,
                 data: privateKey2.getPublicKey().bytes()
             };
@@ -76,7 +76,7 @@ describe('Identity', () => {
                     type: 'chainLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(privateKey1, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityCreateStateTransition.signByPrivateKey(privateKey1, KeyType.ECDSA_SECP256K1);
             identityPublicKeyInCreation1.signature = identityCreateStateTransition.signature;
             // Set identity public key signature for public key 1
             identityCreateStateTransition = sdk.identities.createStateTransition('create', {
@@ -88,7 +88,7 @@ describe('Identity', () => {
                     type: 'chainLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(privateKey2, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityCreateStateTransition.signByPrivateKey(privateKey2, KeyType.ECDSA_SECP256K1);
             identityPublicKeyInCreation2.signature = identityCreateStateTransition.signature;
             // Finalize
             identityCreateStateTransition = sdk.identities.createStateTransition('create', {
@@ -100,7 +100,7 @@ describe('Identity', () => {
                     type: 'chainLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, KeyType.ECDSA_SECP256K1);
         });
         test('should be able to create IdentityCreateTransition via InstantSend', async () => {
             const assetLockPrivateKey = PrivateKeyWASM.fromHex('edd04a71bddb31e530f6c2314fd42ada333f6656bb853ece13f0577a8fd30612', 'testnet');
@@ -110,18 +110,18 @@ describe('Identity', () => {
             const privateKey1 = PrivateKeyWASM.fromHex('a1286dd195e2b8e1f6bdc946c56a53e0c544750d6452ddc0f4c593ef311f21af', 'testnet');
             const identityPublicKeyInCreation1 = {
                 id: 0,
-                purpose: 0 /* Purpose.AUTHENTICATION */,
-                securityLevel: 0 /* SecurityLevel.MASTER */,
-                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.MASTER,
+                keyType: KeyType.ECDSA_SECP256K1,
                 readOnly: false,
                 data: privateKey1.getPublicKey().bytes()
             };
             const privateKey2 = PrivateKeyWASM.fromHex('44a8195e242364b935e9d7ff2106ed109e9baf3800907f5e58a259fdfd1ca5e5', 'testnet');
             const identityPublicKeyInCreation2 = {
                 id: 1,
-                purpose: 0 /* Purpose.AUTHENTICATION */,
-                securityLevel: 2 /* SecurityLevel.HIGH */,
-                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.HIGH,
+                keyType: KeyType.ECDSA_SECP256K1,
                 readOnly: false,
                 data: privateKey2.getPublicKey().bytes()
             };
@@ -136,7 +136,7 @@ describe('Identity', () => {
                     type: 'instantLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(privateKey1, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityCreateStateTransition.signByPrivateKey(privateKey1, KeyType.ECDSA_SECP256K1);
             identityPublicKeyInCreation1.signature = identityCreateStateTransition.signature;
             // Set identity public key signature for public key 1
             identityCreateStateTransition = sdk.identities.createStateTransition('create', {
@@ -148,7 +148,7 @@ describe('Identity', () => {
                     type: 'instantLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(privateKey2, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityCreateStateTransition.signByPrivateKey(privateKey2, KeyType.ECDSA_SECP256K1);
             identityPublicKeyInCreation2.signature = identityCreateStateTransition.signature;
             // Finalize
             identityCreateStateTransition = sdk.identities.createStateTransition('create', {
@@ -160,7 +160,7 @@ describe('Identity', () => {
                     type: 'instantLock'
                 }
             });
-            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityCreateStateTransition.signByPrivateKey(assetLockPrivateKey, KeyType.ECDSA_SECP256K1);
         });
         test('should be able to create IdentityTopUpTransition via InstantSend', async () => {
             const transaction = '03000800011a468e6a7cf1c5111b09b7bca6743f2571a9bf13d2ff6d21d3d230fd1dea1e97000000006b483045022100fceb25c45e77e1a273660e4f4c9a09042fb858a57704806e14bf80a734af232a02201929893dd720cf5855e31dda577cda16df29520a9774b4f3e813a4cc468fe086012103e16ede6dc5c99f28e3a5733f47a7494992bc6ce4f98551c092645910b9888b8fffffffff0200e1f50500000000026a004054fa02000000001976a91416bbe230f46eea86fc4bf4dd550be45dc9adfcb488ac0000000024010100e1f505000000001976a9147f78813975a3282e09e284d97d93c083b202e34188ac';
@@ -177,7 +177,7 @@ describe('Identity', () => {
                     type: 'instantLock'
                 }
             });
-            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, KeyType.ECDSA_SECP256K1);
         });
         test('should be able to create IdentityTopUpTransition via ChainLock', async () => {
             const txid = '61aede830477254876d435a317241ad46753c4b1350dc991a45ebcf19ab80a11';
@@ -194,7 +194,7 @@ describe('Identity', () => {
                     type: 'chainLock'
                 }
             });
-            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityTopUpTransaction.signByPrivateKey(assetLockPrivateKey, undefined, KeyType.ECDSA_SECP256K1);
         });
         test('should be able to create IdentityUpdateTransition', async () => {
             const identityId = 'HT3pUBM1Uv2mKgdPEN1gxa7A4PdsvNY89aJbdSKQb5wR';
@@ -207,9 +207,9 @@ describe('Identity', () => {
             const identityPrivateKey = PrivateKeyWASM.fromHex('16f614c6242580628d849e3616491dda1eccce99642a85667eb9a364dc85324a', 'testnet');
             const identityPublicKeyInCreation = {
                 id: keyId,
-                purpose: 0 /* Purpose.AUTHENTICATION */,
-                securityLevel: 2 /* SecurityLevel.HIGH */,
-                keyType: 0 /* KeyType.ECDSA_SECP256K1 */,
+                purpose: Purpose.AUTHENTICATION,
+                securityLevel: SecurityLevel.HIGH,
+                keyType: KeyType.ECDSA_SECP256K1,
                 readOnly: false,
                 data: identityPrivateKey.getPublicKey().bytes()
             };
@@ -219,7 +219,7 @@ describe('Identity', () => {
                 identityNonce,
                 addPublicKeys: [identityPublicKeyInCreation]
             });
-            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, KeyType.ECDSA_SECP256K1);
             identityPublicKeyInCreation.signature = identityUpdateTransition.signature;
             identityUpdateTransition = sdk.identities.createStateTransition('update', {
                 identityId,
@@ -227,7 +227,7 @@ describe('Identity', () => {
                 identityNonce,
                 addPublicKeys: [identityPublicKeyInCreation]
             });
-            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, 0 /* KeyType.ECDSA_SECP256K1 */);
+            identityUpdateTransition.signByPrivateKey(masterPrivateKey, masterKeyId, KeyType.ECDSA_SECP256K1);
         });
         test('should able be create credit transfer transition', async () => {
             const identityId = 'QMfCRPcjXoTnZa9sA9JR2KWgGxZXMRJ4akgS3Uia1Qv';

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/PlatformAddress.spec.js

@@ -5,16 +5,16 @@ describe('PlatformAddress', () => {
         sdk = new DashPlatformSDK({ network: 'testnet' });
     });
     test('getAddressInfo', async () => {
-        const info = await sdk.platformAddresses.getAddressInfo('tdashevo1qpgz9hk6tkn5zj3653s8qkjmk9439qkf0gl4yxxw');
+        const info = await sdk.platformAddresses.getAddressInfo('tdash1kzg5azscav69z7m6dfzr9ner0a5vt7pn9ca4sz8d');
         expect(info.balance).toBeDefined();
         expect(info.nonce).toBeDefined();
         expect(info.address).toBeDefined();
     });
     test('getAddressesInfos', async () => {
         const addresses = [
-            'tdashevo1qpgz9hk6tkn5zj3653s8qkjmk9439qkf0gl4yxxw',
-            'tdashevo1qq79z66rh34l4u2axlz3jv34zwshggnenut9k093',
-            'tdashevo1qpwyg4khd0rh8px5cjphv9wx38psl6hma5krg9gk'
+            'tdash1kzg5azscav69z7m6dfzr9ner0a5vt7pn9ca4sz8d',
+            'tdash1kqr3cxhgel75ru0yrhj5eq8j8jt92m5enqrfajxw',
+            'tdash1kq9plfyacx9q26dtaxgwuw9lt78nyu2mzc3xwcxv'
         ];
         const info = await sdk.platformAddresses.getAddressesInfos(addresses);
         expect(info).toHaveLength(addresses.length);

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

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