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

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/StateTransitionFees.spec.ts

@@ -0,0 +1,177 @@
+import {
+  AssetLockProofWASM,
+  BatchTransitionWASM,
+  CoreScriptWASM,
+  DataContractCreateTransitionWASM,
+  DataContractWASM,
+  IdentityCreateTransitionWASM,
+  IdentityCreditTransferWASM,
+  IdentityCreditWithdrawalTransitionWASM,
+  IdentityPublicKeyInCreationWASM,
+  IdentityTopUpTransitionWASM,
+  IdentityUpdateTransitionWASM,
+  KeyType,
+  OutPointWASM,
+  Purpose,
+  SecurityLevel,
+  StateTransitionWASM
+} from 'pshenmic-dpp'
+
+// Min fees from the platform fee version (STATE_TRANSITION_MIN_FEES_VERSION1)
+const CREDIT_TRANSFER_COST = BigInt(100000)
+const CREDIT_WITHDRAWAL_COST = BigInt(400000000)
+const IDENTITY_UPDATE_COST = BigInt(100000)
+const CONTRACT_CREATE_COST = BigInt(100000)
+const DOCUMENT_BATCH_SUB_TRANSITION_COST = BigInt(100000)
+const IDENTITY_CREATE_BASE_COST = BigInt(2000000)
+const IDENTITY_KEY_IN_CREATION_COST = BigInt(6500000)
+const IDENTITY_TOPUP_BASE_COST = BigInt(500000)
+// required asset lock duff balance × CREDITS_PER_DUFF (1000)
+const IDENTITY_CREATE_ASSET_LOCK_COST = BigInt(200000) * BigInt(1000)
+const IDENTITY_TOPUP_ASSET_LOCK_COST = BigInt(50000) * BigInt(1000)
+
+// A signed document batch transition holding a single document create transition
+const BATCH_TRANSITION_BASE64 = 'AgHv88sfWzscuW2Ob/0v5d+EgqmWG7ZIvlQG7mHWBH7z9gEAAAAB7JH7W+JkM0Vne2U1zlWYVeQNzRPTpdiWRfsgfwNS2UoCCGJsb2dQb3N0KBdMgeznVQ1smUXVFNPfE2PC379wpWVH8cdu2ilzeI0Ah/i2xfrKCm5ACQAbEQkSc+GRUkdLor4Eu7Vzf6oRc9UHBmJsb2dJZAogdhC4nVm3ufPCgdfoOKXtnhqwg7O3axyTS9WB3EFvNBYPY29tbWVudHNFbmFibGVkEwEHY29udGVudAr7AUh4nM2TTWrDMBCFrxK0jkCyJMvqLnRV6A1KFhpplJgotrEVaAi+e8clpdBuvCnNcn7ezPvQ6O3G2siemKgNSGETT8ZarhUm7hpX8yStEpVCk6xlW1auA1L34Ed/GP1wpNQw9sPEnm6s4Ht57nM/UkPE5C+5UBl8OB3G/tLF37VFscvtoTtjV6iSMRU2b1nou/KZIXf3jUvrXUHRrosbv8ltKRk30JbNl2LLpnLNuPiZ5z1NOrY5jtjRqP28vbM656zTleagJHCNXnIQiUIpgozGg2/0N2s4Yji9tlN5KXj+A97FJG1AcpZ8nnANv1wHGo22ASrFXQDJde0SBzDIdQBVRQEoDDw2aLUONPkKtfF0s9bR9bqGkJW3PNYCg/FOgIqPDarWgQrRxKapBXdCJ3pR7TjUVnJrpAo6yhSc/4dv+tPu/gNBt2qtC3B1Ymxpc2hlZEF0Av0AAAGcptJlIwRzbHVnEhV0aGlzLWlzLW15LWZpcnN0LXBvc3QIc3VidGl0bGUSD1dpdGggYSBzdWJ0aXRsZQV0aXRsZRIVVGhpcyBpcyBteSBmaXJzdCBwb3N0AAABQR+H40MbUEmFXQbTPcwy9vMD8EiTwDzMpW3YIkfSIDvHij5ZIAVvqm0ZJScJzKV7EnRUi/f1tZ/wFJfd1+LDtpps'
+
+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 createTestKey (): IdentityPublicKeyInCreationWASM {
+  return new IdentityPublicKeyInCreationWASM(
+    0,
+    Purpose.AUTHENTICATION,
+    SecurityLevel.MASTER,
+    KeyType.ECDSA_SECP256K1,
+    false,
+    randomBytes(33)
+  )
+}
+
+function createAssetLockProof (): AssetLockProofWASM {
+  return AssetLockProofWASM.createChainAssetLockProof(100, new OutPointWASM('a'.repeat(64), 0))
+}
+
+describe('IdentityCreditTransferTransition fees', function () {
+  test('calculateMinRequiredFee should return the credit transfer min fee', function () {
+    const transition = new IdentityCreditTransferWASM(
+      randomBytes(32), BigInt(100000), randomBytes(32), BigInt(1)
+    )
+
+    expect(transition.calculateMinRequiredFee()).toEqual(CREDIT_TRANSFER_COST)
+  })
+})
+
+describe('IdentityCreditWithdrawalTransition fees', function () {
+  test('calculateMinRequiredFee should return the credit withdrawal min fee', function () {
+    const transition = new IdentityCreditWithdrawalTransitionWASM(
+      randomBytes(32),
+      BigInt(1000000),
+      1,
+      'Standard',
+      BigInt(1),
+      CoreScriptWASM.newP2PKH(randomBytes(20))
+    )
+
+    expect(transition.calculateMinRequiredFee()).toEqual(CREDIT_WITHDRAWAL_COST)
+  })
+})
+
+describe('IdentityUpdateTransition fees', function () {
+  test('calculateMinRequiredFee should return the identity update min fee', function () {
+    const transition = new IdentityUpdateTransitionWASM(
+      randomBytes(32), BigInt(1), BigInt(1), [createTestKey()], []
+    )
+
+    expect(transition.calculateMinRequiredFee()).toEqual(IDENTITY_UPDATE_COST)
+  })
+})
+
+describe('IdentityCreateTransition fees', function () {
+  test('calculateMinRequiredFee should price the base cost, asset lock and keys', function () {
+    const transition = new IdentityCreateTransitionWASM([createTestKey()], createAssetLockProof())
+
+    expect(transition.calculateMinRequiredFee()).toEqual(
+      IDENTITY_CREATE_BASE_COST + IDENTITY_CREATE_ASSET_LOCK_COST + IDENTITY_KEY_IN_CREATION_COST
+    )
+  })
+
+  test('calculateMinRequiredFee should grow with the key count', function () {
+    const oneKey = new IdentityCreateTransitionWASM([createTestKey()], createAssetLockProof())
+    const twoKeys = new IdentityCreateTransitionWASM(
+      [createTestKey(), createTestKey()], createAssetLockProof()
+    )
+
+    expect(twoKeys.calculateMinRequiredFee() - oneKey.calculateMinRequiredFee())
+      .toEqual(IDENTITY_KEY_IN_CREATION_COST)
+  })
+})
+
+describe('IdentityTopUpTransition fees', function () {
+  test('calculateMinRequiredFee should price the base cost and the asset lock', function () {
+    const transition = new IdentityTopUpTransitionWASM(createAssetLockProof(), randomBytes(32))
+
+    expect(transition.calculateMinRequiredFee())
+      .toEqual(IDENTITY_TOPUP_BASE_COST + IDENTITY_TOPUP_ASSET_LOCK_COST)
+  })
+})
+
+describe('BatchTransition fees', function () {
+  test('calculateMinRequiredFee should price each sub transition', function () {
+    const batch = BatchTransitionWASM.fromStateTransition(
+      StateTransitionWASM.fromBase64(BATCH_TRANSITION_BASE64)
+    )
+
+    expect(batch.calculateMinRequiredFee())
+      .toEqual(DOCUMENT_BATCH_SUB_TRANSITION_COST * BigInt(batch.transitions.length))
+  })
+})
+
+describe('StateTransition fees', function () {
+  test('calculateMinRequiredFee should match the concrete transition', function () {
+    const transition = new IdentityCreditTransferWASM(
+      randomBytes(32), BigInt(100000), randomBytes(32), BigInt(1)
+    )
+
+    expect(transition.toStateTransition().calculateMinRequiredFee())
+      .toEqual(transition.calculateMinRequiredFee())
+  })
+
+  test('calculateMinRequiredFee should work for a deserialized transition', function () {
+    const stateTransition = StateTransitionWASM.fromBase64(BATCH_TRANSITION_BASE64)
+
+    expect(stateTransition.calculateMinRequiredFee())
+      .toEqual(DOCUMENT_BATCH_SUB_TRANSITION_COST)
+  })
+})
+
+describe('DataContractCreateTransition fees', function () {
+  const OWNER_ID_BASE58 = 'HEAmUtC72dPcZ59yyLUgfS8pfrEWqzYfDPzTofgWxXRr'
+  const DOCUMENT_SCHEMA = {
+    note: {
+      type: 'object',
+      properties: {
+        message: {
+          type: 'string',
+          position: 0
+        }
+      },
+      additionalProperties: false
+    }
+  }
+
+  test('calculateMinRequiredFee should cover the base fee plus the registration cost', function () {
+    const contract = new DataContractWASM(
+      OWNER_ID_BASE58, BigInt(1), DOCUMENT_SCHEMA, undefined, undefined, true
+    )
+    const transition = new DataContractCreateTransitionWASM(contract, BigInt(1))
+
+    expect(transition.calculateMinRequiredFee()).toBeGreaterThanOrEqual(CONTRACT_CREATE_COST)
+    expect(transition.calculateMinRequiredFee())
+      .toEqual(transition.toStateTransition().calculateMinRequiredFee())
+  })
+})