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

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/types.d.ts

@@ -310,3 +310,38 @@ export interface VerifiedPlatformAddressesInfosWithRootHash {
     rootHash: Uint8Array;
     infos: VerifiedPlatformAddressInfo[];
 }
+export interface VerifiedShieldedEncryptedNote {
+    cmx: Uint8Array;
+    nullifier: Uint8Array;
+    cvNet: Uint8Array;
+    encryptedNote: Uint8Array;
+}
+export interface VerifiedShieldedEncryptedNotes {
+    rootHash: Uint8Array;
+    notes: VerifiedShieldedEncryptedNote[];
+    totalCount: bigint;
+}
+export interface VerifiedShieldedAnchors {
+    rootHash: Uint8Array;
+    anchors: Uint8Array[];
+}
+export interface VerifiedMostRecentShieldedAnchor {
+    rootHash: Uint8Array;
+    anchor?: Uint8Array;
+}
+export interface VerifiedShieldedPoolState {
+    rootHash: Uint8Array;
+    totalBalance?: bigint;
+}
+export interface VerifiedShieldedNotesCount {
+    rootHash: Uint8Array;
+    count?: bigint;
+}
+export interface VerifiedShieldedNullifier {
+    nullifier: Uint8Array;
+    isSpent: boolean;
+}
+export interface VerifiedShieldedNullifiers {
+    rootHash: Uint8Array;
+    nullifiers: VerifiedShieldedNullifier[];
+}

package/dist/src/dpp/verify/Shielded/verifyMostRecentShieldedAnchorProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedMostRecentShieldedAnchor } from '../../types.js';
+export declare function verifyMostRecentShieldedAnchorProof(proof: Uint8Array, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedMostRecentShieldedAnchor;

package/dist/src/dpp/verify/Shielded/verifyMostRecentShieldedAnchorProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyMostRecentShieldedAnchorProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyMostRecentShieldedAnchorProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        anchor: result.anchor ?? undefined
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedAnchorsProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedAnchors } from '../../types.js';
+export declare function verifyShieldedAnchorsProof(proof: Uint8Array, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedAnchors;

package/dist/src/dpp/verify/Shielded/verifyShieldedAnchorsProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedAnchorsProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedAnchorsProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        anchors: result.anchors
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedEncryptedNotesProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedEncryptedNotes } from '../../types.js';
+export declare function verifyShieldedEncryptedNotesProof(proof: Uint8Array, startIndex: bigint, count: number, maxElements: number, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedEncryptedNotes;

package/dist/src/dpp/verify/Shielded/verifyShieldedEncryptedNotesProof.js

@@ -0,0 +1,15 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedEncryptedNotesProof(proof, startIndex, count, maxElements, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedEncryptedNotesProof(proof, startIndex.toString(), count, maxElements, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        notes: result.notes.map((note) => ({
+            cmx: note.cmx,
+            nullifier: note.nullifier,
+            cvNet: note.cvNet,
+            encryptedNote: note.encryptedNote
+        })),
+        totalCount: BigInt(result.totalCount)
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedNotesCountProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedNotesCount } from '../../types.js';
+export declare function verifyShieldedNotesCountProof(proof: Uint8Array, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedNotesCount;

package/dist/src/dpp/verify/Shielded/verifyShieldedNotesCountProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedNotesCountProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedNotesCountProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        count: result.count != null ? BigInt(result.count) : undefined
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedNullifiersProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedNullifiers } from '../../types.js';
+export declare function verifyShieldedNullifiersProof(proof: Uint8Array, nullifiers: Uint8Array[], verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedNullifiers;

package/dist/src/dpp/verify/Shielded/verifyShieldedNullifiersProof.js

@@ -0,0 +1,12 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedNullifiersProof(proof, nullifiers, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedNullifiersProof(proof, nullifiers, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        nullifiers: result.nullifiers.map((nullifier) => ({
+            nullifier: nullifier.nullifier,
+            isSpent: nullifier.isSpent
+        }))
+    };
+}

package/dist/src/dpp/verify/Shielded/verifyShieldedPoolStateProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedShieldedPoolState } from '../../types.js';
+export declare function verifyShieldedPoolStateProof(proof: Uint8Array, verifySubsetOfProof: boolean, platformVersion: PlatformVersionLike): VerifiedShieldedPoolState;

package/dist/src/dpp/verify/Shielded/verifyShieldedPoolStateProof.js

@@ -0,0 +1,9 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+export function verifyShieldedPoolStateProof(proof, verifySubsetOfProof, platformVersion) {
+    const result = dppProvider.dpp.verifyShieldedPoolStateProof(proof, verifySubsetOfProof, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        totalBalance: result.totalBalance != null ? BigInt(result.totalBalance) : undefined
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pshenmic-dpp",
-  "version": "2.0.0-dev.20",
+  "version": "2.0.0-dev.21",
   "main": "dist/src/wasm.js",
   "types": "dist/src/wasm.d.ts",
   "react-native": "./dist/src/react-native.js",

package/tests/unit/Shielded.spec.ts

@@ -0,0 +1,344 @@
+import {
+  ShieldedMemoWASM,
+  OrchardAddressWASM,
+  orchardOvkFromSeed,
+  NoteWASM,
+  MerklePathWASM,
+  SpendableNoteWASM,
+  CommitmentTreeWASM,
+  ShieldedBuilderWASM,
+  OrchardProverWASM,
+  InputAddressWASM,
+  AddressFundsFeeStrategyStepWASM,
+  PrivateKeyWASM,
+  PlatformAddressWASM,
+  ShieldTransitionWASM,
+  StateTransitionWASM
+} from 'pshenmic-dpp'
+
+// Deterministic 64-byte BIP-39-style seed. Orchard derives via ZIP-32
+// (m/32'/coinType'/account'), so any 64 bytes is a valid seed for derivation.
+const SEED = new Uint8Array(64)
+for (let i = 0; i < 64; i++) SEED[i] = (i * 7 + 1) & 0xff
+
+const COIN_TYPE = 1 // testnets
+const ACCOUNT = 0
+
+// A funded testnet WIF reused across the builder/deposit tests.
+const WIF = 'cUy4wbim4y9NDwC24omx8oWY5WqfmjSU2gdcZtTXza2xDCAkQXRP'
+
+// Memo payloads are a fixed 32 bytes (MEMO_PAYLOAD_SIZE).
+const MEMO_PAYLOAD_SIZE = 32
+
+const DASH = 100_000_000_000n
+
+function hexToBytes (hex: string): Uint8Array {
+  return Uint8Array.from(hex.match(/../g)!.map((x) => parseInt(x, 16)))
+}
+
+// A canonical Orchard note: rho is a valid Pallas base-field element (value 1),
+// rseed is non-degenerate. Produces a valid commitment (cmx) the tree accepts.
+function createTestNote (value: bigint = 1000n): NoteWASM {
+  const address = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
+  const rho = new Uint8Array(32)
+  rho[0] = 1
+  const rseed = new Uint8Array(32).fill(0x42)
+  return new NoteWASM(address, value, rho, rseed)
+}
+
+// Platform P2PKH address (21 bytes: 0x00 type + 20-byte pubkey hash) for a key.
+function platformAddressFromPrivateKey (pk: PrivateKeyWASM): PlatformAddressWASM {
+  const hash = hexToBytes(pk.getPublicKeyHash())
+  const bytes = new Uint8Array(21)
+  bytes[0] = 0x00
+  bytes.set(hash, 1)
+  return PlatformAddressWASM.fromBytes(bytes)
+}
+
+describe('ShieldedMemo', function () {
+  describe('empty', function () {
+    test('should create an empty memo', function () {
+      const memo = ShieldedMemoWASM.empty()
+
+      expect(memo).toBeInstanceOf(ShieldedMemoWASM)
+      expect(memo.toBytes().length).toEqual(36) // on-wire memo size
+    })
+  })
+
+  describe('fromString', function () {
+    test('should create a text memo from a 32-char string', function () {
+      const text = 'A'.repeat(MEMO_PAYLOAD_SIZE)
+      const memo = ShieldedMemoWASM.fromString(text)
+
+      expect(memo).toBeInstanceOf(ShieldedMemoWASM)
+      expect(memo.toBytes().length).toEqual(36)
+      expect(memo.toString().endsWith(text)).toBe(true)
+    })
+
+    test('should reject a payload that is not 32 bytes', function () {
+      expect(() => ShieldedMemoWASM.fromString('too short')).toThrow()
+    })
+  })
+
+  describe('other', function () {
+    test('should create a typed memo from a 32-byte payload', function () {
+      const payload = new Uint8Array(MEMO_PAYLOAD_SIZE).fill(9)
+      const memo = ShieldedMemoWASM.other(7, payload)
+
+      expect(memo).toBeInstanceOf(ShieldedMemoWASM)
+      expect(memo.toBytes().length).toEqual(36)
+    })
+
+    test('should reject a payload that is not 32 bytes', function () {
+      expect(() => ShieldedMemoWASM.other(7, new Uint8Array([1, 2, 3]))).toThrow()
+    })
+  })
+})
+
+describe('OrchardAddress', function () {
+  describe('fromSeed', function () {
+    test('should derive an address from a seed', function () {
+      const address = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
+
+      expect(address).toBeInstanceOf(OrchardAddressWASM)
+      expect(address.bytes().length).toEqual(43)
+    })
+
+    test('should be deterministic for the same seed', function () {
+      const a = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
+      const b = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
+
+      expect(a.bytes()).toEqual(b.bytes())
+    })
+  })
+
+  describe('serialization', function () {
+    test('should roundtrip through bytes', function () {
+      const address = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
+      const restored = OrchardAddressWASM.fromBytes(address.bytes())
+
+      expect(restored.bytes()).toEqual(address.bytes())
+    })
+
+    test('should roundtrip through bech32m', function () {
+      const address = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
+      const bech32m = address.toBech32m('testnet')
+      const restored = OrchardAddressWASM.fromBech32m(bech32m)
+
+      expect(restored.bytes()).toEqual(address.bytes())
+    })
+  })
+
+  describe('orchardOvkFromSeed', function () {
+    test('should derive a 32-byte outgoing viewing key', function () {
+      const ovk = orchardOvkFromSeed(SEED, COIN_TYPE, ACCOUNT)
+
+      expect(ovk.length).toEqual(32)
+    })
+  })
+})
+
+describe('Note', function () {
+  describe('constructor', function () {
+    test('should create a note from valid parts', function () {
+      const note = createTestNote()
+
+      expect(note).toBeInstanceOf(NoteWASM)
+    })
+
+    test('should reject an invalid rho', function () {
+      const address = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
+      const invalidRho = new Uint8Array(32).fill(0xff) // not a canonical field element
+      const rseed = new Uint8Array(32).fill(0x42)
+
+      expect(() => new NoteWASM(address, 1000n, invalidRho, rseed)).toThrow()
+    })
+  })
+
+  describe('getters', function () {
+    test('should return all fields', function () {
+      const note = createTestNote(1234n)
+
+      expect(note.address).toBeInstanceOf(OrchardAddressWASM)
+      expect(note.value).toEqual(1234n)
+      expect(note.rho.length).toEqual(32)
+      expect(note.rseed.length).toEqual(32)
+      expect(note.cmx.length).toEqual(32)
+    })
+  })
+
+  describe('setters', function () {
+    test('should set the value', function () {
+      const note = createTestNote()
+
+      note.value = 5000n
+      expect(note.value).toEqual(5000n)
+    })
+  })
+})
+
+describe('CommitmentTree', function () {
+  describe('append / witness / anchor', function () {
+    test('should append a commitment and produce a witness and anchor', function () {
+      const note = createTestNote()
+      const tree = new CommitmentTreeWASM()
+
+      tree.append(note.cmx, true)
+      tree.checkpoint(1)
+
+      expect(tree.maxLeafPosition()).toEqual(0)
+
+      const path = tree.witness(0)
+      expect(path).toBeInstanceOf(MerklePathWASM)
+      expect(path!.authPath.length).toEqual(32)
+
+      expect(tree.anchor().length).toEqual(32)
+    })
+
+    test('should reject a cmx that is not 32 bytes', function () {
+      const tree = new CommitmentTreeWASM()
+
+      expect(() => tree.append(new Uint8Array(16), true)).toThrow()
+    })
+  })
+})
+
+describe('MerklePath', function () {
+  let position: number
+  let authPath: Uint8Array[]
+
+  beforeAll(function () {
+    const note = createTestNote()
+    const tree = new CommitmentTreeWASM()
+    tree.append(note.cmx, true)
+    tree.checkpoint(1)
+    const path = tree.witness(0)!
+    position = path.position
+    authPath = path.authPath
+  })
+
+  describe('constructor', function () {
+    test('should create a MerklePath from parts', function () {
+      const path = new MerklePathWASM(position, authPath)
+
+      expect(path).toBeInstanceOf(MerklePathWASM)
+    })
+  })
+
+  describe('getters', function () {
+    test('should return all fields', function () {
+      const path = new MerklePathWASM(position, authPath)
+
+      expect(path.position).toEqual(position)
+      expect(path.authPath.length).toEqual(32)
+      expect(path.authPath[0].length).toEqual(32)
+    })
+  })
+
+  describe('setters', function () {
+    test('should set the position', function () {
+      const path = new MerklePathWASM(position, authPath)
+
+      path.position = 0
+      expect(path.position).toEqual(0)
+    })
+  })
+})
+
+describe('SpendableNote', function () {
+  let note: NoteWASM
+  let merklePath: MerklePathWASM
+
+  beforeAll(function () {
+    note = createTestNote()
+    const tree = new CommitmentTreeWASM()
+    tree.append(note.cmx, true)
+    tree.checkpoint(1)
+    merklePath = tree.witness(0)!
+  })
+
+  describe('constructor', function () {
+    test('should create a SpendableNote from a note and witness', function () {
+      const spendable = new SpendableNoteWASM(note, merklePath)
+
+      expect(spendable).toBeInstanceOf(SpendableNoteWASM)
+    })
+  })
+
+  describe('getters', function () {
+    test('should return the note and merkle path', function () {
+      const spendable = new SpendableNoteWASM(note, merklePath)
+
+      expect(spendable.note).toBeInstanceOf(NoteWASM)
+      expect(spendable.note.value).toEqual(note.value)
+      expect(spendable.merklePath).toBeInstanceOf(MerklePathWASM)
+      expect(spendable.merklePath.position).toEqual(merklePath.position)
+    })
+  })
+
+  describe('setters', function () {
+    test('should set the note', function () {
+      const spendable = new SpendableNoteWASM(note, merklePath)
+      const newNote = createTestNote(2000n)
+
+      spendable.note = newNote
+      expect(spendable.note.value).toEqual(2000n)
+    })
+  })
+})
+
+describe('OrchardProver', function () {
+  // Constructing the prover builds the Halo 2 proving key (~seconds).
+  test('should construct a prover', function () {
+    const prover = new OrchardProverWASM()
+
+    expect(prover).toBeInstanceOf(OrchardProverWASM)
+  }, 30000)
+})
+
+describe('ShieldedBuilder', function () {
+  // The builder builds its own Halo 2 proving key on construction (~seconds),
+  // so build it once and reuse it across the deposit test.
+  let builder: ShieldedBuilderWASM
+
+  beforeAll(function () {
+    builder = new ShieldedBuilderWASM()
+  }, 30000)
+
+  describe('constructor', function () {
+    test('should construct a builder', function () {
+      expect(builder).toBeInstanceOf(ShieldedBuilderWASM)
+    })
+  })
+
+  describe('shield (transparent -> pool deposit)', function () {
+    test('should build and prove a shield transition', function () {
+      const recipient = OrchardAddressWASM.fromSeed(SEED, COIN_TYPE, ACCOUNT)
+      const senderOvk = orchardOvkFromSeed(SEED, COIN_TYPE, ACCOUNT)
+
+      const privateKey = PrivateKeyWASM.fromWIF(WIF)
+      const inputAddress = platformAddressFromPrivateKey(privateKey)
+      // address, nonce, balance — balance must cover amount + fee.
+      const input = new InputAddressWASM(inputAddress, 0, DASH / 2n)
+
+      const st = builder.shield(
+        recipient,
+        (DASH * 4n) / 10n, // 0.4 DASH into the pool
+        [input],
+        [privateKey],
+        [AddressFundsFeeStrategyStepWASM.DeductFromInput(0)],
+        0, // user fee increase
+        ShieldedMemoWASM.empty(),
+        senderOvk
+      )
+
+      expect(st).toBeInstanceOf(StateTransitionWASM)
+
+      const transition = ShieldTransitionWASM.fromStateTransition(st)
+      expect(transition).toBeInstanceOf(ShieldTransitionWASM)
+      expect(transition.amount).toEqual((DASH * 4n) / 10n)
+      expect(transition.actions.length).toBeGreaterThanOrEqual(1)
+      expect(transition.proof.length).toBeGreaterThan(0)
+    }, 30000)
+  })
+})