pshenmic-dpp 2.0.0-dev.2 → 2.0.0-dev.21

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,49 @@
+import * as dpp from "pshenmic-dpp/wasm";
+import {IdentifierWASM} 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);
+    });
+  })
+});

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 };