pshenmic-dpp 2.0.0-dev.25 → 2.0.0-dev.27

package/dist/src/dpp/structs/StateTransition.d.ts

@@ -1,4 +1,4 @@
-import type { StateTransitionNAPI } from '../../../binaries/bindingsTypes.js';
+import type { StateTransitionNAPI, PlatformVersionNAPI } from '../../../binaries/bindingsTypes.js';
 import { PrivateKeyWASM } from './PrivateKey.js';
 import { IdentityPublicKeyWASM } from './IdentityPublicKey.js';
 import { IdentifierLike, KeyTypeLike, PurposeLike } from '../types.js';
@@ -29,6 +29,7 @@ export declare class StateTransitionWASM {
     setIdentityContractNonce(nonce: bigint): void;
     setIdentityNonce(nonce: bigint): void;
     getSignableBytes(): Uint8Array;
+    calculateMinRequiredFee(platformVersion?: PlatformVersionNAPI): bigint;
     bytes(): Uint8Array;
     hex(): string;
     base64(): string;

package/dist/src/dpp/structs/StateTransition.js

@@ -79,6 +79,9 @@ export class StateTransitionWASM {
     getSignableBytes() {
         return this._rawStateTransition.getSignableBytes();
     }
+    calculateMinRequiredFee(platformVersion) {
+        return BigInt(this._rawStateTransition.calculateMinRequiredFee(platformVersion));
+    }
     bytes() {
         return this._rawStateTransition.bytes();
     }

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.25",
+  "version": "2.0.0-dev.27",
   "main": "dist/src/wasm.js",
   "types": "dist/src/wasm.d.ts",
   "react-native": "./dist/src/react-native.js",

package/tests/unit/AddressTransitionsFees.spec.ts

@@ -0,0 +1,274 @@
+import {
+  AddressCreditWithdrawalTransitionWASM,
+  AddressFundingFromAssetLockTransitionWASM,
+  AddressFundsFeeStrategyStepWASM,
+  AddressFundsTransferTransitionWASM,
+  AddressWitnessWASM,
+  AssetLockProofWASM,
+  CoreScriptWASM,
+  IdentityCreateFromAddressesTransitionWASM,
+  IdentityCreditTransferToAddressesTransitionWASM,
+  IdentityPublicKeyInCreationWASM,
+  IdentityTopUpFromAddressesTransitionWASM,
+  InputAddressWASM,
+  KeyType,
+  OutPointWASM,
+  OutputAddressNullableCreditsWASM,
+  OutputAddressWASM,
+  PlatformAddressWASM,
+  PlatformVersionWASM,
+  Purpose,
+  SecurityLevel
+} from 'pshenmic-dpp'
+
+// Min fee components from the platform fee version (STATE_TRANSITION_MIN_FEES_VERSION1)
+// Storage charged by the node for one address balance entry that does not exist yet,
+// as pinned by platform's own fee regression suite.
+const NEW_ADDRESS_STORAGE_FEE = BigInt(6075000)
+const INPUT_COST = BigInt(500000)
+const OUTPUT_COST = BigInt(6000000)
+const ADDRESS_CREDIT_WITHDRAWAL_COST = BigInt(400000000)
+const IDENTITY_CREATE_BASE_COST = BigInt(2000000)
+const IDENTITY_KEY_IN_CREATION_COST = BigInt(6500000)
+const IDENTITY_TOPUP_BASE_COST = BigInt(500000)
+const CREDIT_TRANSFER_TO_ADDRESSES_COST = BigInt(500000)
+
+function randomBytes (length: number): Uint8Array {
+  const bytes = new Uint8Array(length)
+  for (let i = 0; i < length; i++) {
+    bytes[i] = Math.floor(Math.random() * 256)
+  }
+  return bytes
+}
+
+function createTestAddress (): PlatformAddressWASM {
+  const addressBytes = new Uint8Array(21)
+  addressBytes[0] = 0x00
+  addressBytes.set(randomBytes(20), 1)
+  return PlatformAddressWASM.fromBytes(addressBytes)
+}
+
+function createTestInputs (count: number): InputAddressWASM[] {
+  return Array.from(
+    { length: count },
+    () => new InputAddressWASM(createTestAddress(), 0, BigInt(500000000))
+  )
+}
+
+function createTestOutputs (count: number): OutputAddressWASM[] {
+  return Array.from(
+    { length: count },
+    () => new OutputAddressWASM(createTestAddress(), BigInt(100000))
+  )
+}
+
+function createTestWitnesses (count: number): AddressWitnessWASM[] {
+  return Array.from({ length: count }, () => AddressWitnessWASM.P2PKH(randomBytes(65)))
+}
+
+const feeStrategy = (): AddressFundsFeeStrategyStepWASM[] =>
+  [AddressFundsFeeStrategyStepWASM.DeductFromInput(0)]
+
+describe('AddressFundsTransferTransition fees', function () {
+  describe('estimateMinFee', function () {
+    test('should price inputs and outputs', function () {
+      expect(AddressFundsTransferTransitionWASM.estimateMinFee(1, 1))
+        .toEqual(INPUT_COST + OUTPUT_COST)
+
+      expect(AddressFundsTransferTransitionWASM.estimateMinFee(2, 3))
+        .toEqual(INPUT_COST * BigInt(2) + OUTPUT_COST * BigInt(3))
+    })
+
+    test('should charge at least one output', function () {
+      expect(AddressFundsTransferTransitionWASM.estimateMinFee(1, 0))
+        .toEqual(AddressFundsTransferTransitionWASM.estimateMinFee(1, 1))
+    })
+
+    test('should grow with the input and output counts', function () {
+      const one = AddressFundsTransferTransitionWASM.estimateMinFee(1, 1)
+      const two = AddressFundsTransferTransitionWASM.estimateMinFee(2, 2)
+
+      expect(two).toBeGreaterThan(one)
+    })
+
+    test('should default to the latest platform version', function () {
+      expect(AddressFundsTransferTransitionWASM.estimateMinFee(1, 1))
+        .toEqual(AddressFundsTransferTransitionWASM.estimateMinFee(1, 1, PlatformVersionWASM.PLATFORM_V13))
+    })
+  })
+
+  describe('calculateMinRequiredFee', function () {
+    test('should match the estimate for the transition inputs and outputs', function () {
+      const transition = new AddressFundsTransferTransitionWASM(
+        createTestInputs(2),
+        feeStrategy(),
+        0,
+        createTestWitnesses(2),
+        createTestOutputs(1)
+      )
+
+      expect(transition.calculateMinRequiredFee())
+        .toEqual(AddressFundsTransferTransitionWASM.estimateMinFee(2, 1))
+    })
+  })
+})
+
+describe('AddressCreditWithdrawalTransition fees', function () {
+  const outputScript = (): CoreScriptWASM => CoreScriptWASM.newP2PKH(randomBytes(20))
+
+  describe('estimateMinFee', function () {
+    test('should price the withdrawal, its inputs and its change output', function () {
+      expect(AddressCreditWithdrawalTransitionWASM.estimateMinFee(1, false))
+        .toEqual(ADDRESS_CREDIT_WITHDRAWAL_COST + INPUT_COST)
+
+      expect(AddressCreditWithdrawalTransitionWASM.estimateMinFee(1, true))
+        .toEqual(ADDRESS_CREDIT_WITHDRAWAL_COST + INPUT_COST + OUTPUT_COST)
+    })
+
+    test('should grow with the input count', function () {
+      expect(AddressCreditWithdrawalTransitionWASM.estimateMinFee(2, false))
+        .toBeGreaterThan(AddressCreditWithdrawalTransitionWASM.estimateMinFee(1, false))
+    })
+  })
+
+  describe('calculateMinRequiredFee', function () {
+    test('should match the estimate without a change output', function () {
+      const transition = new AddressCreditWithdrawalTransitionWASM(
+        createTestInputs(1),
+        feeStrategy(),
+        1,
+        'Standard',
+        outputScript(),
+        0,
+        createTestWitnesses(1)
+      )
+
+      expect(transition.calculateMinRequiredFee())
+        .toEqual(AddressCreditWithdrawalTransitionWASM.estimateMinFee(1, false))
+    })
+
+    test('should match the estimate with a change output', function () {
+      const transition = new AddressCreditWithdrawalTransitionWASM(
+        createTestInputs(1),
+        feeStrategy(),
+        1,
+        'Standard',
+        outputScript(),
+        0,
+        createTestWitnesses(1),
+        createTestOutputs(1)[0]
+      )
+
+      expect(transition.calculateMinRequiredFee())
+        .toEqual(AddressCreditWithdrawalTransitionWASM.estimateMinFee(1, true))
+    })
+  })
+})
+
+describe('IdentityCreateFromAddressesTransition fees', function () {
+  test('calculateMinRequiredFee should price the base cost, inputs, output and keys', function () {
+    const publicKeys = [
+      new IdentityPublicKeyInCreationWASM(
+        0,
+        Purpose.AUTHENTICATION,
+        SecurityLevel.MASTER,
+        KeyType.ECDSA_SECP256K1,
+        false,
+        randomBytes(33)
+      )
+    ]
+
+    const transition = new IdentityCreateFromAddressesTransitionWASM(
+      publicKeys,
+      createTestInputs(1),
+      feeStrategy(),
+      0,
+      createTestWitnesses(1),
+      createTestOutputs(1)[0]
+    )
+
+    expect(transition.calculateMinRequiredFee()).toEqual(
+      IDENTITY_CREATE_BASE_COST + INPUT_COST + OUTPUT_COST + IDENTITY_KEY_IN_CREATION_COST
+    )
+  })
+})
+
+describe('IdentityTopUpFromAddressesTransition fees', function () {
+  test('calculateMinRequiredFee should price the base cost, inputs and output', function () {
+    const transition = new IdentityTopUpFromAddressesTransitionWASM(
+      randomBytes(32),
+      createTestInputs(1),
+      feeStrategy(),
+      0,
+      createTestWitnesses(1),
+      createTestOutputs(1)[0]
+    )
+
+    expect(transition.calculateMinRequiredFee())
+      .toEqual(IDENTITY_TOPUP_BASE_COST + INPUT_COST + OUTPUT_COST)
+  })
+})
+
+describe('IdentityCreditTransferToAddressesTransition fees', function () {
+  test('calculateMinRequiredFee should price the base cost and each recipient', function () {
+    const transition = new IdentityCreditTransferToAddressesTransitionWASM(
+      randomBytes(32),
+      createTestOutputs(2),
+      BigInt(1),
+      0
+    )
+
+    expect(transition.calculateMinRequiredFee())
+      .toEqual(CREDIT_TRANSFER_TO_ADDRESSES_COST + OUTPUT_COST * BigInt(2))
+  })
+})
+
+describe('AddressFundingFromAssetLockTransition fees', function () {
+  test('calculateMinRequiredFee should include the asset lock base cost', function () {
+    const outPoint = new OutPointWASM('a'.repeat(64), 0)
+    const assetLockProof = AssetLockProofWASM.createChainAssetLockProof(100, outPoint)
+
+    const transition = new AddressFundingFromAssetLockTransitionWASM(
+      assetLockProof,
+      createTestInputs(1),
+      feeStrategy(),
+      0,
+      createTestWitnesses(1),
+      [new OutputAddressNullableCreditsWASM(createTestAddress(), BigInt(100000))]
+    )
+
+    const fee = transition.calculateMinRequiredFee()
+
+    expect(typeof fee).toEqual('bigint')
+    expect(fee).toBeGreaterThan(INPUT_COST + OUTPUT_COST)
+  })
+})
+
+describe('new address storage fee', function () {
+  test('should match the storage the node charges for one created address', function () {
+    expect(PlatformAddressWASM.estimateStorageFeeForNewAddresses(1))
+      .toEqual(NEW_ADDRESS_STORAGE_FEE)
+  })
+
+  test('should scale with the number of created addresses', function () {
+    expect(PlatformAddressWASM.estimateStorageFeeForNewAddresses(0)).toEqual(BigInt(0))
+    expect(PlatformAddressWASM.estimateStorageFeeForNewAddresses(3))
+      .toEqual(NEW_ADDRESS_STORAGE_FEE * BigInt(3))
+  })
+
+  test('should default to the latest platform version', function () {
+    expect(PlatformAddressWASM.estimateStorageFeeForNewAddresses(1))
+      .toEqual(PlatformAddressWASM.estimateStorageFeeForNewAddresses(1, PlatformVersionWASM.PLATFORM_V13))
+  })
+
+  test('should exceed the per output component of the min fee', function () {
+    const perOutput =
+      AddressFundsTransferTransitionWASM.estimateMinFee(1, 2) -
+      AddressFundsTransferTransitionWASM.estimateMinFee(1, 1)
+
+    // The min fee prices an output slightly below what a created address costs in storage,
+    // which is why a transfer paying a brand new address is charged a little more than its
+    // minimum required fee.
+    expect(NEW_ADDRESS_STORAGE_FEE).toBeGreaterThan(perOutput)
+  })
+})

package/tests/unit/Shielded.spec.ts

@@ -27,7 +27,9 @@ 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).
+// The memo payload field is a fixed 32 bytes (MEMO_PAYLOAD_SIZE) on the wire.
+// Text memos may be shorter and are zero-padded to it; `other` payloads are
+// taken verbatim and so must match it exactly.
 const MEMO_PAYLOAD_SIZE = 32
 
 const DASH = 100_000_000_000n
@@ -62,6 +64,7 @@ describe('ShieldedMemo', function () {
 
       expect(memo).toBeInstanceOf(ShieldedMemoWASM)
       expect(memo.toBytes().length).toEqual(36) // on-wire memo size
+      expect(memo.toString()).toEqual('')
     })
   })
 
@@ -72,11 +75,41 @@ describe('ShieldedMemo', function () {
 
       expect(memo).toBeInstanceOf(ShieldedMemoWASM)
       expect(memo.toBytes().length).toEqual(36)
-      expect(memo.toString().endsWith(text)).toBe(true)
+      expect(memo.toString()).toEqual(text)
     })
 
-    test('should reject a payload that is not 32 bytes', function () {
-      expect(() => ShieldedMemoWASM.fromString('too short')).toThrow()
+    test('should accept text shorter than the payload', function () {
+      const text = 'thanks for lunch' // 16 bytes, half the payload
+      const memo = ShieldedMemoWASM.fromString(text)
+      const bytes = memo.toBytes()
+
+      // The wire memo stays a fixed 36 bytes: a 4-byte little-endian kind tag
+      // (1 = text), the utf-8 text, then zero padding out to the 32-byte
+      // payload. The padding is not part of the decoded text.
+      expect(bytes.length).toEqual(36)
+      expect(Array.from(bytes.slice(0, 4))).toEqual([1, 0, 0, 0])
+      expect(new TextDecoder().decode(bytes.slice(4, 4 + text.length))).toEqual(text)
+      expect(bytes.slice(4 + text.length).every((byte) => byte === 0)).toBe(true)
+      expect(memo.toString()).toEqual(text)
+    })
+
+    test('should accept an empty string', function () {
+      const memo = ShieldedMemoWASM.fromString('')
+
+      expect(memo.toBytes().length).toEqual(36)
+      expect(memo.toString()).toEqual('')
+    })
+
+    test('should count multi-byte characters by their utf-8 byte length', function () {
+      // 8 x U+1F355 = 32 bytes, exactly the payload; 9 would be 36 bytes.
+      const memo = ShieldedMemoWASM.fromString('🍕'.repeat(8))
+
+      expect(memo.toString()).toEqual('🍕'.repeat(8))
+      expect(() => ShieldedMemoWASM.fromString('🍕'.repeat(9))).toThrow()
+    })
+
+    test('should reject text longer than 32 bytes', function () {
+      expect(() => ShieldedMemoWASM.fromString('A'.repeat(MEMO_PAYLOAD_SIZE + 1))).toThrow()
     })
   })
 

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))
+  })
 })