pshenmic-dpp 2.0.0-dev.24 → 2.0.0-dev.26

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

@@ -8,6 +8,7 @@ export declare class RecoveredNoteWASM {
     /** The action's global leaf position in the commitment tree. */
     get index(): number;
     get note(): NoteWASM;
+    get nullifier(): Uint8Array;
     static createFromRawInstance(rawInstance: RecoveredNoteNAPI): RecoveredNoteWASM;
 }
 /**

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

@@ -11,6 +11,9 @@ export class RecoveredNoteWASM {
     get note() {
         return NoteWASM.createFromRawInstance(this._rawRecoveredNote.note);
     }
+    get nullifier() {
+        return this._rawRecoveredNote.nullifier;
+    }
     static createFromRawInstance(rawInstance) {
         const instance = Object.create(RecoveredNoteWASM.prototype);
         instance._rawRecoveredNote = rawInstance;

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

@@ -1,4 +1,4 @@
-import type { IdentityCreateFromShieldedPoolTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { PlatformVersionNAPI, IdentityCreateFromShieldedPoolTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { IdentityPublicKeyInCreationWASM } from '../IdentityPublicKeyInCreation.js';
 import { SerializedActionWASM } from './SerializedAction.js';
 import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
@@ -25,6 +25,7 @@ export declare class IdentityCreateFromShieldedPoolTransitionWASM {
     set sendToAddressOnCreationFailure(value: PlatformAddressLike);
     get identityId(): IdentifierWASM;
     set identityId(value: IdentifierLike);
+    static computeMinimumFee(numActions: number, numKeys: number, platformVersion?: PlatformVersionNAPI): bigint;
     toStateTransition(): StateTransitionWASM;
     static fromStateTransition(st: StateTransitionWASM): IdentityCreateFromShieldedPoolTransitionWASM;
     static createFromRawInstance(rawInstance: IdentityCreateFromShieldedPoolTransitionNAPI): IdentityCreateFromShieldedPoolTransitionWASM;

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

@@ -59,6 +59,9 @@ export class IdentityCreateFromShieldedPoolTransitionWASM {
     set identityId(value) {
         this._rawIdentityCreateFromShieldedPoolTransition.identityId = prepareIdentifierValue(value);
     }
+    static computeMinimumFee(numActions, numKeys, platformVersion) {
+        return BigInt(dppProvider.dpp.IdentityCreateFromShieldedPoolTransitionNAPI.computeMinimumFee(numActions, numKeys, platformVersion));
+    }
     toStateTransition() {
         return StateTransitionWASM.createFromRawInstance(this._rawIdentityCreateFromShieldedPoolTransition.toStateTransition());
     }

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

@@ -1,4 +1,4 @@
-import type { ShieldFromAssetLockTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { PlatformVersionNAPI, ShieldFromAssetLockTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { SerializedActionWASM } from './SerializedAction.js';
 import { AssetLockProofWASM } from '../AssetLockProof/AssetLockProof.js';
 import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
@@ -24,6 +24,7 @@ export declare class ShieldFromAssetLockTransitionWASM {
     set surplusOutput(value: PlatformAddressLike | undefined);
     get signature(): Uint8Array;
     set signature(value: Uint8Array);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
     toStateTransition(): StateTransitionWASM;
     static fromStateTransition(st: StateTransitionWASM): ShieldFromAssetLockTransitionWASM;
     static createFromRawInstance(rawInstance: ShieldFromAssetLockTransitionNAPI): ShieldFromAssetLockTransitionWASM;

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

@@ -63,6 +63,9 @@ export class ShieldFromAssetLockTransitionWASM {
     set signature(value) {
         this._rawShieldFromAssetLockTransition.signature = value;
     }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.ShieldFromAssetLockTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
     toStateTransition() {
         return StateTransitionWASM.createFromRawInstance(this._rawShieldFromAssetLockTransition.toStateTransition());
     }

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

@@ -1,4 +1,4 @@
-import type { ShieldTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { PlatformVersionNAPI, ShieldTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { InputAddressWASM } from '../AddressTransitions/entities/InputAddress.js';
 import { AddressFundsFeeStrategyStepWASM } from '../AddressTransitions/entities/AddressFundsFeeStrategyStep.js';
 import { AddressWitnessWASM } from '../PlatformAddress/AddressWitness.js';
@@ -26,6 +26,7 @@ export declare class ShieldTransitionWASM {
     set userFeeIncrease(value: number);
     get inputWitnesses(): AddressWitnessWASM[];
     set inputWitnesses(value: AddressWitnessWASM[]);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
     toStateTransition(): StateTransitionWASM;
     static fromStateTransition(st: StateTransitionWASM): ShieldTransitionWASM;
     static createFromRawInstance(rawInstance: ShieldTransitionNAPI): ShieldTransitionWASM;

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

@@ -64,6 +64,9 @@ export class ShieldTransitionWASM {
     set inputWitnesses(value) {
         this._rawShieldTransition.inputWitnesses = value.map(w => w._rawWitness);
     }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.ShieldTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
     toStateTransition() {
         return StateTransitionWASM.createFromRawInstance(this._rawShieldTransition.toStateTransition());
     }

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

@@ -1,4 +1,4 @@
-import type { ShieldedTransferTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { PlatformVersionNAPI, ShieldedTransferTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { SerializedActionWASM } from './SerializedAction.js';
 import { StateTransitionWASM } from '../StateTransition.js';
 export declare class ShieldedTransferTransitionWASM {
@@ -15,6 +15,7 @@ export declare class ShieldedTransferTransitionWASM {
     set proof(value: Uint8Array);
     get bindingsSignature(): Uint8Array;
     set bindingsSignature(value: Uint8Array);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
     toStateTransition(): StateTransitionWASM;
     static fromStateTransition(st: StateTransitionWASM): ShieldedTransferTransitionWASM;
     static createFromRawInstance(rawInstance: ShieldedTransferTransitionNAPI): ShieldedTransferTransitionWASM;

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

@@ -37,6 +37,9 @@ export class ShieldedTransferTransitionWASM {
     set bindingsSignature(value) {
         this._rawShieldedTransferTransition.bindingsSignature = value;
     }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.ShieldedTransferTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
     toStateTransition() {
         return StateTransitionWASM.createFromRawInstance(this._rawShieldedTransferTransition.toStateTransition());
     }

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

@@ -1,4 +1,4 @@
-import type { ShieldedWithdrawalTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { PlatformVersionNAPI, ShieldedWithdrawalTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { SerializedActionWASM } from './SerializedAction.js';
 import { CoreScriptWASM } from '../CoreScript.js';
 import { PoolingLike } from '../../types.js';
@@ -23,6 +23,7 @@ export declare class ShieldedWithdrawalTransitionWASM {
     set pooling(value: PoolingLike);
     get outputScript(): CoreScriptWASM;
     set outputScript(value: CoreScriptWASM);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
     toStateTransition(): StateTransitionWASM;
     static fromStateTransition(st: StateTransitionWASM): ShieldedWithdrawalTransitionWASM;
     static createFromRawInstance(rawInstance: ShieldedWithdrawalTransitionNAPI): ShieldedWithdrawalTransitionWASM;

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

@@ -57,6 +57,9 @@ export class ShieldedWithdrawalTransitionWASM {
     set outputScript(value) {
         this._rawShieldedWithdrawalTransition.outputScript = value._rawCoreScript;
     }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.ShieldedWithdrawalTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
     toStateTransition() {
         return StateTransitionWASM.createFromRawInstance(this._rawShieldedWithdrawalTransition.toStateTransition());
     }

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

@@ -1,4 +1,4 @@
-import type { UnshieldTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
+import type { PlatformVersionNAPI, UnshieldTransitionNAPI } from '../../../../binaries/bindingsTypes.js';
 import { SerializedActionWASM } from './SerializedAction.js';
 import { PlatformAddressWASM } from '../PlatformAddress/PlatformAddress.js';
 import { PlatformAddressLike } from '../../types.js';
@@ -19,6 +19,7 @@ export declare class UnshieldTransitionWASM {
     set proof(value: Uint8Array);
     get bindingsSignature(): Uint8Array;
     set bindingsSignature(value: Uint8Array);
+    static computeMinimumFee(numActions: number, platformVersion?: PlatformVersionNAPI): bigint;
     toStateTransition(): StateTransitionWASM;
     static fromStateTransition(st: StateTransitionWASM): UnshieldTransitionWASM;
     static createFromRawInstance(rawInstance: UnshieldTransitionNAPI): UnshieldTransitionWASM;

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

@@ -45,6 +45,9 @@ export class UnshieldTransitionWASM {
     set bindingsSignature(value) {
         this._rawUnshieldTransition.bindingsSignature = value;
     }
+    static computeMinimumFee(numActions, platformVersion) {
+        return BigInt(dppProvider.dpp.UnshieldTransitionNAPI.computeMinimumFee(numActions, platformVersion));
+    }
     toStateTransition() {
         return StateTransitionWASM.createFromRawInstance(this._rawUnshieldTransition.toStateTransition());
     }

package/dist/src/dpp/types.d.ts

@@ -250,6 +250,12 @@ export type VerifiedStateTransitionResultVariantsRAW = protocol.DataContractNAPI
 export interface VerifiedStateTransitionResult {
     rootHash: Uint8Array;
     result: VerifiedStateTransitionResultVariants;
+    /**
+     * Whether the proof binds the execution of this specific state transition.
+     * When false, the result is a height-pinned snapshot of the state the
+     * transition affects, not evidence that the transition executed.
+     */
+    isExecutionProved: boolean;
 }
 export type WhereOperator = '=' | '==' | '>' | '>=' | '<' | '<=' | 'Between' | 'between' | 'BetweenExcludeBounds' | 'betweenExcludeBounds' | 'betweenexcludebounds' | 'between_exclude_bounds' | 'BetweenExcludeLeft' | 'betweenExcludeLeft' | 'betweenexcludeleft' | 'between_exclude_left' | 'BetweenExcludeRight' | 'betweenExcludeRight' | 'betweenexcluderight' | 'between_exclude_right' | 'In' | 'in' | 'StartsWith' | 'startsWith' | 'startswith' | 'starts_with';
 export type WhereClause = [

package/dist/src/dpp/verify/StateTransition/verifyStateTransitionResult.js

@@ -5,6 +5,7 @@ export function verifyStateTransitionResult(proof, stateTransition, blockInfo, k
     const verified = dppProvider.dpp.verifyStateTransitionResult(proof, stateTransition._rawStateTransition, new dppProvider.dpp.BlockInfoNAPI(blockInfo.timeMs.toString(), blockInfo.height.toString(), blockInfo.coreHeight, blockInfo.epoch), knownContractsArray.map(contract => contract._rawDataContract), valueToDynamicValue(platformVersion));
     return {
         rootHash: verified.rootHash,
-        result: convertResult(verified.result)
+        result: convertResult(verified.result),
+        isExecutionProved: verified.isExecutionProved
     };
 }

package/package.json

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

package/tests/unit/ShieldedTransitions.spec.ts

@@ -18,6 +18,7 @@ import {
   Purpose,
   SecurityLevel,
   KeyType,
+  PlatformVersionWASM,
   StateTransitionWASM
 } from 'pshenmic-dpp'
 
@@ -190,6 +191,27 @@ describe('ShieldedTransferTransition', function () {
       expect(restored.actions.length).toEqual(1)
     })
   })
+
+  describe('computeMinimumFee', function () {
+    test('should return a positive fee', function () {
+      const fee = ShieldedTransferTransitionWASM.computeMinimumFee(2)
+
+      expect(typeof fee).toEqual('bigint')
+      expect(fee).toBeGreaterThan(BigInt(0))
+    })
+
+    test('should grow with the action count', function () {
+      const oneAction = ShieldedTransferTransitionWASM.computeMinimumFee(1)
+      const twoActions = ShieldedTransferTransitionWASM.computeMinimumFee(2)
+
+      expect(twoActions).toBeGreaterThan(oneAction)
+    })
+
+    test('should default to the latest platform version', function () {
+      expect(ShieldedTransferTransitionWASM.computeMinimumFee(2))
+        .toEqual(ShieldedTransferTransitionWASM.computeMinimumFee(2, PlatformVersionWASM.PLATFORM_V12))
+    })
+  })
 })
 
 describe('ShieldTransition', function () {
@@ -291,6 +313,27 @@ describe('ShieldTransition', function () {
       expect(restored.actions.length).toEqual(1)
     })
   })
+
+  describe('computeMinimumFee', function () {
+    test('should return a positive fee', function () {
+      const fee = ShieldTransitionWASM.computeMinimumFee(2)
+
+      expect(typeof fee).toEqual('bigint')
+      expect(fee).toBeGreaterThan(BigInt(0))
+    })
+
+    test('should grow with the action count', function () {
+      const oneAction = ShieldTransitionWASM.computeMinimumFee(1)
+      const twoActions = ShieldTransitionWASM.computeMinimumFee(2)
+
+      expect(twoActions).toBeGreaterThan(oneAction)
+    })
+
+    test('should default to the latest platform version', function () {
+      expect(ShieldTransitionWASM.computeMinimumFee(2))
+        .toEqual(ShieldTransitionWASM.computeMinimumFee(2, PlatformVersionWASM.PLATFORM_V12))
+    })
+  })
 })
 
 describe('UnshieldTransition', function () {
@@ -381,6 +424,27 @@ describe('UnshieldTransition', function () {
       expect(restored.bindingsSignature).toEqual(bindingsSignature)
     })
   })
+
+  describe('computeMinimumFee', function () {
+    test('should return a positive fee', function () {
+      const fee = UnshieldTransitionWASM.computeMinimumFee(2)
+
+      expect(typeof fee).toEqual('bigint')
+      expect(fee).toBeGreaterThan(BigInt(0))
+    })
+
+    test('should grow with the action count', function () {
+      const oneAction = UnshieldTransitionWASM.computeMinimumFee(1)
+      const twoActions = UnshieldTransitionWASM.computeMinimumFee(2)
+
+      expect(twoActions).toBeGreaterThan(oneAction)
+    })
+
+    test('should default to the latest platform version', function () {
+      expect(UnshieldTransitionWASM.computeMinimumFee(2))
+        .toEqual(UnshieldTransitionWASM.computeMinimumFee(2, PlatformVersionWASM.PLATFORM_V12))
+    })
+  })
 })
 
 describe('ShieldFromAssetLockTransition', function () {
@@ -491,6 +555,27 @@ describe('ShieldFromAssetLockTransition', function () {
       expect(restored.actions.length).toEqual(1)
     })
   })
+
+  describe('computeMinimumFee', function () {
+    test('should return a positive fee', function () {
+      const fee = ShieldFromAssetLockTransitionWASM.computeMinimumFee(2)
+
+      expect(typeof fee).toEqual('bigint')
+      expect(fee).toBeGreaterThan(BigInt(0))
+    })
+
+    test('should grow with the action count', function () {
+      const oneAction = ShieldFromAssetLockTransitionWASM.computeMinimumFee(1)
+      const twoActions = ShieldFromAssetLockTransitionWASM.computeMinimumFee(2)
+
+      expect(twoActions).toBeGreaterThan(oneAction)
+    })
+
+    test('should default to the latest platform version', function () {
+      expect(ShieldFromAssetLockTransitionWASM.computeMinimumFee(2))
+        .toEqual(ShieldFromAssetLockTransitionWASM.computeMinimumFee(2, PlatformVersionWASM.PLATFORM_V12))
+    })
+  })
 })
 
 describe('ShieldedWithdrawalTransition', function () {
@@ -590,6 +675,27 @@ describe('ShieldedWithdrawalTransition', function () {
       expect(restored.pooling).toEqual('Never')
     })
   })
+
+  describe('computeMinimumFee', function () {
+    test('should return a positive fee', function () {
+      const fee = ShieldedWithdrawalTransitionWASM.computeMinimumFee(2)
+
+      expect(typeof fee).toEqual('bigint')
+      expect(fee).toBeGreaterThan(BigInt(0))
+    })
+
+    test('should grow with the action count', function () {
+      const oneAction = ShieldedWithdrawalTransitionWASM.computeMinimumFee(1)
+      const twoActions = ShieldedWithdrawalTransitionWASM.computeMinimumFee(2)
+
+      expect(twoActions).toBeGreaterThan(oneAction)
+    })
+
+    test('should default to the latest platform version', function () {
+      expect(ShieldedWithdrawalTransitionWASM.computeMinimumFee(2))
+        .toEqual(ShieldedWithdrawalTransitionWASM.computeMinimumFee(2, PlatformVersionWASM.PLATFORM_V12))
+    })
+  })
 })
 
 describe('IdentityCreateFromShieldedPoolTransition', function () {
@@ -706,4 +812,66 @@ describe('IdentityCreateFromShieldedPoolTransition', function () {
       expect(restored.identityId.bytes()).toEqual(identityId.bytes())
     })
   })
+
+  describe('computeMinimumFee', function () {
+    test('should return a positive fee', function () {
+      const fee = IdentityCreateFromShieldedPoolTransitionWASM.computeMinimumFee(2, 3)
+
+      expect(typeof fee).toEqual('bigint')
+      expect(fee).toBeGreaterThan(BigInt(0))
+    })
+
+    test('should grow with the action count', function () {
+      const oneAction = IdentityCreateFromShieldedPoolTransitionWASM.computeMinimumFee(1, 3)
+      const twoActions = IdentityCreateFromShieldedPoolTransitionWASM.computeMinimumFee(2, 3)
+
+      expect(twoActions).toBeGreaterThan(oneAction)
+    })
+
+    test('should grow with the key count', function () {
+      const oneKey = IdentityCreateFromShieldedPoolTransitionWASM.computeMinimumFee(2, 1)
+      const threeKeys = IdentityCreateFromShieldedPoolTransitionWASM.computeMinimumFee(2, 3)
+
+      expect(threeKeys).toBeGreaterThan(oneKey)
+    })
+
+    test('should default to the latest platform version', function () {
+      expect(IdentityCreateFromShieldedPoolTransitionWASM.computeMinimumFee(2, 3))
+        .toEqual(IdentityCreateFromShieldedPoolTransitionWASM.computeMinimumFee(2, 3, PlatformVersionWASM.PLATFORM_V12))
+    })
+  })
+})
+
+describe('computeMinimumFee across shielded transitions', function () {
+  const numActions = 2
+
+  test('Shield should be the compute-only fee, without the per-action storage term', function () {
+    expect(ShieldTransitionWASM.computeMinimumFee(numActions))
+      .toBeLessThan(ShieldedTransferTransitionWASM.computeMinimumFee(numActions))
+  })
+
+  test('Shield and ShieldedTransfer should agree with no actions', function () {
+    expect(ShieldTransitionWASM.computeMinimumFee(0))
+      .toEqual(ShieldedTransferTransitionWASM.computeMinimumFee(0))
+  })
+
+  test('ShieldFromAssetLock should match ShieldedTransfer', function () {
+    expect(ShieldFromAssetLockTransitionWASM.computeMinimumFee(numActions))
+      .toEqual(ShieldedTransferTransitionWASM.computeMinimumFee(numActions))
+  })
+
+  test('Unshield should add the output address write on top of ShieldedTransfer', function () {
+    expect(UnshieldTransitionWASM.computeMinimumFee(numActions))
+      .toBeGreaterThan(ShieldedTransferTransitionWASM.computeMinimumFee(numActions))
+  })
+
+  test('ShieldedWithdrawal should add the withdrawal document write on top of Unshield', function () {
+    expect(ShieldedWithdrawalTransitionWASM.computeMinimumFee(numActions))
+      .toBeGreaterThan(UnshieldTransitionWASM.computeMinimumFee(numActions))
+  })
+
+  test('IdentityCreateFromShieldedPool should add the identity create floor on top of ShieldedTransfer', function () {
+    expect(IdentityCreateFromShieldedPoolTransitionWASM.computeMinimumFee(numActions, 1))
+      .toBeGreaterThan(ShieldedTransferTransitionWASM.computeMinimumFee(numActions))
+  })
 })