pshenmic-dpp 2.0.0-dev.9 → 2.0.0

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

package/tests/unit/TokenConfiguration.spec.ts

@@ -0,0 +1,114 @@
+import {
+  AuthorizedActionTakersWASM,
+  IdentifierWASM,
+  TokenConfigurationWASM
+} from 'pshenmic-dpp'
+import { buildTokenConfiguration } from './utils/buildTokenConfiguration'
+
+describe('TokenConfiguration', function () {
+  describe('constructor', function () {
+    test('should build a token configuration with defaults from the helper', function () {
+      const config = buildTokenConfiguration()
+
+      expect(config).toBeInstanceOf(TokenConfigurationWASM)
+      expect(config.baseSupply).toEqual(BigInt(100000))
+      expect(config.maxSupply).toBeUndefined()
+      expect(config.description).toBeUndefined()
+      expect(config.startAsPaused).toEqual(false)
+      expect(config.isAllowedTransferToFrozenBalance).toEqual(false)
+    })
+
+    test('should set max supply and description when provided', function () {
+      const config = buildTokenConfiguration({
+        baseSupply: BigInt(500),
+        maxSupply: BigInt(1000),
+        description: 'hello'
+      })
+
+      expect(config.baseSupply).toEqual(BigInt(500))
+      expect(config.maxSupply).toEqual(BigInt(1000))
+      expect(config.description).toEqual('hello')
+    })
+  })
+
+  describe('getters', function () {
+    test('should expose the convention decimals', function () {
+      const config = buildTokenConfiguration()
+
+      expect(config.conventions.decimals).toEqual(8)
+    })
+
+    test('should default mainControlGroup to undefined', function () {
+      const config = buildTokenConfiguration()
+
+      expect(config.mainControlGroup).toBeUndefined()
+    })
+  })
+
+  describe('setters', function () {
+    test('should allow updating baseSupply', function () {
+      const config = buildTokenConfiguration()
+
+      config.baseSupply = BigInt(7)
+
+      expect(config.baseSupply).toEqual(BigInt(7))
+    })
+
+    test('should allow updating maxSupply to a value and back to undefined', function () {
+      const config = buildTokenConfiguration()
+
+      config.maxSupply = BigInt(42)
+      expect(config.maxSupply).toEqual(BigInt(42))
+
+      config.maxSupply = undefined
+      expect(config.maxSupply).toBeUndefined()
+    })
+
+    test('should allow updating description', function () {
+      const config = buildTokenConfiguration()
+
+      config.description = 'updated'
+
+      expect(config.description).toEqual('updated')
+    })
+
+    test('should allow updating startAsPaused / isAllowedTransferToFrozenBalance', function () {
+      const config = buildTokenConfiguration()
+
+      config.startAsPaused = true
+      config.isAllowedTransferToFrozenBalance = true
+
+      expect(config.startAsPaused).toEqual(true)
+      expect(config.isAllowedTransferToFrozenBalance).toEqual(true)
+    })
+
+    test('should allow updating mainControlGroup', function () {
+      const config = buildTokenConfiguration()
+
+      config.mainControlGroup = 3
+
+      expect(config.mainControlGroup).toEqual(3)
+    })
+
+    test('should allow updating mainControlGroupCanBeModified', function () {
+      const config = buildTokenConfiguration()
+
+      config.mainControlGroupCanBeModified = AuthorizedActionTakersWASM.ContractOwner()
+
+      expect(config.mainControlGroupCanBeModified).toBeDefined()
+    })
+  })
+
+  describe('calculateTokenId', function () {
+    test('should derive a deterministic token id from a contract id and position', function () {
+      const contractId = new IdentifierWASM('HEAmUtC72dPcZ59yyLUgfS8pfrEWqzYfDPzTofgWxXRr')
+
+      const tokenIdA = TokenConfigurationWASM.calculateTokenId(contractId, 0)
+      const tokenIdB = TokenConfigurationWASM.calculateTokenId(contractId, 0)
+      const tokenIdC = TokenConfigurationWASM.calculateTokenId(contractId, 1)
+
+      expect(tokenIdA.base58()).toEqual(tokenIdB.base58())
+      expect(tokenIdA.base58()).not.toEqual(tokenIdC.base58())
+    })
+  })
+})

package/tests/unit/WebAssembly.spec.ts

@@ -0,0 +1,88 @@
+import * as dpp from "pshenmic-dpp/wasm";
+import {IdentifierWASM, ShieldedBuilderWASM} from "pshenmic-dpp/wasm";
+
+let identifierBytes: Uint8Array;
+
+describe("dpp", function () {
+  beforeAll(async function () {
+    identifierBytes = Uint8Array.from([
+      9, 40, 40, 237, 192, 129, 211, 186, 26, 84, 240, 67, 37, 155, 148, 19,
+      104, 242, 199, 24, 136, 27, 6, 169, 211, 71, 136, 59, 33, 191, 227, 19,
+    ]);
+  });
+
+  it('dpp object shouldn\'t be undefined or empty', () => {
+    expect(dpp).toBeDefined();
+  });
+
+  describe('classes accesibles', function () {
+    test("should allows to create Identifier from base58 via dpp object", function () {
+      const identifier = dpp.IdentifierWASM.fromBase58(
+        "ckBqfQe7LU7vwrwXopyCB4n5phZShjA16BGhNGpsD5U",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from base64 via IdentifierWASM import", function () {
+      const identifier = IdentifierWASM.fromBase64(
+        "CSgo7cCB07oaVPBDJZuUE2jyxxiIGwap00eIOyG/4xM=",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from hex", function () {
+      const identifier = IdentifierWASM.fromHex(
+        "092828edc081d3ba1a54f043259b941368f2c718881b06a9d347883b21bfe313",
+      );
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+
+    test("should allows to create Identifier from bytes", function () {
+      const identifier = IdentifierWASM.fromBytes(identifierBytes);
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    });
+  })
+
+  describe('shielded init', function () {
+    test('should allow to use old instances after shielded init', async function () {
+      const identifier = IdentifierWASM.fromBytes(identifierBytes);
+
+      const builder = new ShieldedBuilderWASM()
+
+      await builder.init();
+
+      expect(identifier.bytes()).toEqual(identifierBytes);
+    })
+
+    test('should build a real Halo 2 proof with instances created before init', async function () {
+      const seed = new Uint8Array(64).fill(7);
+
+      // created BEFORE init — must stay usable by the proving call
+      const recipient = dpp.OrchardAddressWASM.fromSeed(seed, 1, 0);
+      const senderOvk = dpp.orchardOvkFromSeed(seed, 1, 0);
+      const privateKey = dpp.PrivateKeyWASM.fromWIF('cUy4wbim4y9NDwC24omx8oWY5WqfmjSU2gdcZtTXza2xDCAkQXRP');
+      const outPoint = new dpp.OutPointWASM('79af4b339ddfee8c9b6d08d74155373c6ef547cda5e65473a254b9b0f8533f0c', 0);
+      const assetLockProof = dpp.AssetLockProofWASM.createChainAssetLockProof(1499737, outPoint);
+      const memo = dpp.ShieldedMemoWASM.empty();
+
+      const builder = new ShieldedBuilderWASM();
+      await builder.init();
+
+      const st = await builder.shieldFromAssetLock(
+        recipient,
+        40_000_000_000n,
+        assetLockProof,
+        privateKey,
+        memo,
+        0,
+        senderOvk
+      );
+
+      expect(st.hex().length).toBeGreaterThan(0);
+    }, 120000)
+  })
+});

package/tests/unit/utils/buildTokenConfiguration.ts

@@ -0,0 +1,66 @@
+import {
+  AuthorizedActionTakersWASM,
+  ChangeControlRulesWASM,
+  TokenConfigurationConventionWASM,
+  TokenConfigurationWASM,
+  TokenDistributionRulesWASM,
+  TokenKeepsHistoryRulesWASM,
+  TokenMarketplaceRulesWASM,
+  TokenTradeModeWASM
+} from 'pshenmic-dpp'
+
+export function buildChangeControlRules (): ChangeControlRulesWASM {
+  return new ChangeControlRulesWASM(
+    AuthorizedActionTakersWASM.NoOne(),
+    AuthorizedActionTakersWASM.NoOne(),
+    false,
+    false,
+    false
+  )
+}
+
+export function buildTokenConfiguration (
+  overrides: { baseSupply?: bigint, maxSupply?: bigint, description?: string } = {}
+): TokenConfigurationWASM {
+  const conventions = new TokenConfigurationConventionWASM({}, 8)
+
+  const keepsHistory = new TokenKeepsHistoryRulesWASM(false, false, false, false, false, false)
+
+  const distributionRules = new TokenDistributionRulesWASM(
+    buildChangeControlRules(),
+    buildChangeControlRules(),
+    false,
+    buildChangeControlRules(),
+    buildChangeControlRules(),
+    undefined,
+    undefined,
+    undefined
+  )
+
+  const marketplaceRules = new TokenMarketplaceRulesWASM(
+    TokenTradeModeWASM.NotTradeable(),
+    buildChangeControlRules()
+  )
+
+  return new TokenConfigurationWASM(
+    conventions,
+    buildChangeControlRules(),
+    overrides.baseSupply ?? BigInt(100000),
+    keepsHistory,
+    false,
+    false,
+    buildChangeControlRules(),
+    distributionRules,
+    marketplaceRules,
+    buildChangeControlRules(),
+    buildChangeControlRules(),
+    buildChangeControlRules(),
+    buildChangeControlRules(),
+    buildChangeControlRules(),
+    buildChangeControlRules(),
+    AuthorizedActionTakersWASM.NoOne(),
+    overrides.maxSupply,
+    undefined,
+    overrides.description
+  )
+}

package/dist/binaries/wasm/wasmBytes.d.ts

@@ -1,2 +0,0 @@
-declare const bytes: string;
-export { bytes };