pshenmic-dpp 2.0.0-dev.9 → 2.0.0

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

@@ -75,6 +75,35 @@ const converters = () => {
             })]
     ]);
 };
+function convertPlatformAddressInfos(infos) {
+    return infos.map(info => ({
+        nonce: info.nonce,
+        address: PlatformAddressWASM.createFromRawInstance(info.address),
+        balance: info.credits != null ? BigInt(info.credits) : undefined
+    }));
+}
+function convertVerifiedDocuments(docs) {
+    return docs.map(item => ({
+        id: IdentifierWASM.createFromRawInstance(item.id),
+        document: item.document != null
+            ? DocumentWASM.createFromRawInstance(item.document)
+            : undefined
+    }));
+}
+function convertAssetLockValue(v) {
+    return {
+        initialCreditValue: BigInt(v.initialCreditValue),
+        txOutScript: v.txOutScript,
+        remainingCreditValue: BigInt(v.remainingCreditValue),
+        usedTags: v.usedTags
+    };
+}
+function convertStoredAssetLockInfo(v) {
+    return {
+        type: v.type,
+        value: v.value != null ? convertAssetLockValue(v.value) : undefined
+    };
+}
 function convertArray(result) {
     const [first] = result;
     if (first == null)
@@ -86,26 +115,62 @@ function convertArray(result) {
         }));
     }
     if (first instanceof dppProvider.dpp.VerifiedDocumentNAPI) {
-        return result.map(item => ({
-            id: IdentifierWASM.createFromRawInstance(item.id),
-            document: item.document != null
-                ? DocumentWASM.createFromRawInstance(item.document)
-                : undefined
-        }));
+        return convertVerifiedDocuments(result);
     }
     if (first instanceof dppProvider.dpp.PlatformAddressInfoNAPI) {
-        return result.map(item => ({
-            nonce: item.nonce,
-            address: PlatformAddressWASM.createFromRawInstance(item.address),
-            balance: item.credits != null ? BigInt(item.credits) : undefined
-        }));
+        return convertPlatformAddressInfos(result);
     }
     throw new Error('Unknown array type');
 }
+function convertTuple(result) {
+    const [first, second] = result;
+    if (first instanceof dppProvider.dpp.StoredAssetLockInfoNAPI) {
+        return {
+            storedAssetLockInfo: convertStoredAssetLockInfo(first),
+            infos: convertPlatformAddressInfos(second)
+        };
+    }
+    if (first instanceof dppProvider.dpp.IdentityNAPI) {
+        return {
+            identity: IdentityWASM.createFromRawInstance(first),
+            nullifiers: second
+        };
+    }
+    if (Array.isArray(first) && Array.isArray(second)) {
+        const secondFirst = second[0];
+        if (secondFirst != null && secondFirst instanceof dppProvider.dpp.VerifiedDocumentNAPI) {
+            return {
+                nullifiers: first,
+                documents: convertVerifiedDocuments(second)
+            };
+        }
+        return {
+            nullifiers: first,
+            infos: secondFirst != null ? convertPlatformAddressInfos(second) : []
+        };
+    }
+    throw new Error('Unknown tuple type');
+}
 export function convertResult(result) {
     if (Array.isArray(result)) {
+        if (result.length === 2) {
+            const [first] = result;
+            if (first instanceof dppProvider.dpp.StoredAssetLockInfoNAPI || first instanceof dppProvider.dpp.IdentityNAPI) {
+                return convertTuple(result);
+            }
+            if (Array.isArray(first) && (first.length === 0 || Array.isArray(first[0]))) {
+                return convertTuple(result);
+            }
+        }
+        const [first] = result;
+        if (first != null && Array.isArray(first) && first[0] instanceof Uint8Array) {
+            return result;
+        }
         return convertArray(result);
     }
+    if (result instanceof dppProvider.dpp.StoredAssetLockInfoNAPI) {
+        return convertStoredAssetLockInfo(result);
+    }
     for (const [Type, handler] of converters()) {
         if (result instanceof Type) {
             return handler(result);

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/dist/src/dpp/verify/System/verifyFinalizedEpochInfosProof.d.ts

@@ -0,0 +1,2 @@
+import { PlatformVersionLike, VerifiedFinalizedEpochsInfo } from "../../types.js";
+export declare function verifyFinalizedEpochInfosProof(proof: Uint8Array, startEpoch: number, startEpochIncluded: boolean, endEpoch: number, endEpochIncluded: boolean, platformVersion: PlatformVersionLike): VerifiedFinalizedEpochsInfo;

package/dist/src/dpp/verify/System/verifyFinalizedEpochInfosProof.js

@@ -0,0 +1,27 @@
+import { dppProvider } from '../../provider.js';
+import { valueToDynamicValue } from '../../utils.js';
+import { IdentifierWASM } from "../../structs/Identifier.js";
+export function verifyFinalizedEpochInfosProof(proof, startEpoch, startEpochIncluded, endEpoch, endEpochIncluded, platformVersion) {
+    const result = dppProvider.dpp.verifyFinalizedEpochInfosProof(proof, startEpoch, startEpochIncluded, endEpoch, endEpochIncluded, valueToDynamicValue(platformVersion));
+    return {
+        rootHash: result.rootHash,
+        epochInfos: result.epochInfos.map(([epochIndex, info]) => ({
+            epochIndex: epochIndex,
+            firstBlockTime: new Date(Number(info.firstBlockTime)),
+            firstBlockHeight: BigInt(info.firstBlockHeight),
+            totalBlocksInEpoch: BigInt(info.totalBlocksInEpoch),
+            firstCoreBlockHeight: info.firstCoreBlockHeight,
+            nextEpochStartCoreBlockHeight: info.nextEpochStartCoreBlockHeight,
+            totalProcessingFees: BigInt(info.totalProcessingFees),
+            totalDistributedStorageFees: BigInt(info.totalDistributedStorageFees),
+            totalCreatedStorageFees: BigInt(info.totalCreatedStorageFees),
+            coreBlockRewards: BigInt(info.coreBlockRewards),
+            blockProposers: info.blockProposers.map(([proposer, count]) => ({
+                proposer: IdentifierWASM.createFromRawInstance(proposer),
+                count: BigInt(count),
+            })),
+            feeMultiplierPermille: BigInt(info.feeMultiplierPermille),
+            protocolVersion: info.protocolVersion,
+        }))
+    };
+}

package/dist/src/native.d.ts

@@ -0,0 +1,3 @@
+export * from './dpp/enums.js';
+export * from './dpp/dpp.js';
+export * from './dpp/types.js';

package/dist/src/native.js

@@ -0,0 +1,8 @@
+// @ts-ignore
+import protocol from '../binaries/node.cjs';
+import { dppProvider } from './dpp/provider.js';
+// @ts-ignore
+dppProvider.setDpp(protocol);
+export * from './dpp/enums.js';
+export * from './dpp/dpp.js';
+export * from './dpp/types.js';

package/dist/utils/{base122.js → base122.cjs}

@@ -1,3 +1,4 @@
+"use strict";
 // Original code: https://github.com/kevinAlbs/Base122
 // Provides functions for encoding/decoding data to and from base-122.
 const kIllegals = [
@@ -15,7 +16,7 @@ const kShortened = 0b111; // Uses the illegal index to signify the last two-byte
  * with raw data bytes or a string of bytes (i.e. the type of argument to btoa())
  * @returns {Uint8Array} The data in a regular array representing byte values.
  */
-export function decode(base122Data) {
+function decode(base122Data) {
     const strData = typeof (base122Data) === 'string' ? base122Data : utf8DataToString(base122Data);
     const decoded = [];
     let curByte = 0;
@@ -61,3 +62,4 @@ export function decode(base122Data) {
 function utf8DataToString(data) {
     return new TextDecoder().decode(data);
 }
+module.exports = { decode };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "pshenmic-dpp",
-  "version": "2.0.0-dev.9",
+  "version": "2.0.0",
   "main": "dist/src/wasm.js",
   "types": "dist/src/wasm.d.ts",
   "react-native": "./dist/src/react-native.js",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/owl352/pshenmic-dpp"
+    "url": "git+https://github.com/owl352/pshenmic-dpp.git"
   },
   "scripts": {
     "build:bin": "node build.cjs",
-    "build:ts": "tsc && cp -R pkg/**/*.*.node dist/binaries/",
+    "build:ts": "tsc && cp -R pkg/**/*.*.node dist/binaries/ && cp -R pkg/binaries/native dist/binaries/",
     "build:full": "npm run build:bin && npm run build:ts",
     "ferric:build": "ferric build",
     "bundle": "rollup -c",
@@ -20,41 +20,31 @@
     "lint:rust": "cargo fmt",
     "lint:src": "ts-standard --fix ./pkg/src",
     "lint:tests": "ts-standard --fix ./pkg/src",
-    "lint": "npm run lint:rust && npm run lint:src && npm run lint:tests"
+    "lint": "npm run lint:rust && npm run lint:src && npm run lint:tests",
+    "prepack": "npm pkg delete devDependencies"
   },
   "files": [
     "dist/",
     "tests/"
   ],
+  "exports": {
+    ".": {
+      "browser": "./dist/src/wasm.js",
+      "node": "./dist/src/native.js",
+      "react-native": "./dist/src/react-native.js",
+      "default": "./dist/src/wasm.js"
+    },
+    "./wasm": "./dist/src/wasm.js",
+    "./wasm/utils": "./dist/src/dpp/utils.js",
+    "./native": "./dist/src/native.js"
+  },
   "author": "owl352",
   "license": "ISC",
   "description": "",
-  "devDependencies": {
-    "@babel/core": "^7.28.5",
-    "@babel/preset-env": "^7.28.5",
-    "@babel/preset-typescript": "^7.28.5",
-    "@scure/base": "^1.2.4",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^24.0.13",
-    "babel": "^6.23.0",
-    "babel-jest": "^30.2.0",
-    "core-js": "^3.41.0",
-    "ferric-cli": "0.3.9",
-    "jest": "^30.2.0",
-    "mocha": "^11.1.0",
-    "node-addon-api": "^8.5.0",
-    "path": "^0.12.7",
-    "toml": "^3.0.0",
-    "ts-morph": "^26.0.0",
-    "tsx": "^4.20.6",
-    "typedoc": "^0.28.7",
-    "typescript": "^5.8.3",
-    "ts-standard": "^12.0.2"
-  },
   "dependencies": {
     "@emnapi/core": "1.9.0",
     "@emnapi/runtime": "1.9.0",
     "@tybys/wasm-util": "^0.10.1",
-    "fflate": "^0.8.2"
+    "fflate": "^0.8.3"
   }
 }

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