@dashevo/wasm-dpp 0.23.0-dev.10

package/test/integration/stateTransition/StateTransitionFacade.spec.js

@@ -0,0 +1,418 @@
+const { PrivateKey } = require('@dashevo/dashcore-lib');
+
+const DashPlatformProtocol = require('../../../lib/DashPlatformProtocol');
+
+const DataContractCreateTransition = require('../../../lib/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition');
+
+const ValidationResult = require('../../../lib/validation/ValidationResult');
+
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
+const getIdentityCreateTransitionFixture = require('../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+
+const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
+
+const DataContractFactory = require('../../../lib/dataContract/DataContractFactory');
+const DocumentFactory = require('../../../lib/document/DocumentFactory');
+
+const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
+
+const MissingOptionError = require('../../../lib/errors/MissingOptionError');
+const createDPPMock = require('../../../lib/test/mocks/createDPPMock');
+const SomeConsensusError = require('../../../lib/test/mocks/SomeConsensusError');
+
+describe('StateTransitionFacade', () => {
+  let dpp;
+  let dataContractCreateTransition;
+  let documentsBatchTransition;
+  let stateRepositoryMock;
+  let dataContract;
+  let identityPublicKey;
+
+  beforeEach(async function beforeEach() {
+    const privateKeyModel = new PrivateKey();
+    const privateKey = privateKeyModel.toWIF();
+    const publicKey = privateKeyModel.toPublicKey().toBuffer();
+    const publicKeyId = 1;
+
+    identityPublicKey = new IdentityPublicKey()
+      .setId(publicKeyId)
+      .setType(IdentityPublicKey.TYPES.ECDSA_SECP256K1)
+      .setData(publicKey)
+      .setPurpose(IdentityPublicKey.PURPOSES.AUTHENTICATION)
+      .setSecurityLevel(IdentityPublicKey.PURPOSES.MASTER);
+
+    dataContract = getDataContractFixture();
+
+    const dataContractFactory = new DataContractFactory(createDPPMock(), undefined);
+
+    dataContractCreateTransition = dataContractFactory.createDataContractCreateTransition(
+      dataContract,
+    );
+    await dataContractCreateTransition.sign(identityPublicKey, privateKey);
+
+    const documentFactory = new DocumentFactory(createDPPMock(), undefined, undefined);
+
+    documentsBatchTransition = documentFactory.createStateTransition({
+      create: getDocumentsFixture(dataContract),
+    });
+    await documentsBatchTransition.sign(identityPublicKey, privateKey);
+
+    const getPublicKeyById = this.sinonSandbox.stub().returns(identityPublicKey);
+    const getBalance = this.sinonSandbox.stub().returns(10000);
+
+    const identity = {
+      getPublicKeyById,
+      type: 2,
+      getBalance,
+    };
+
+    const timeInSeconds = Math.ceil(new Date().getTime() / 1000);
+
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    stateRepositoryMock.fetchIdentity.resolves(identity);
+    stateRepositoryMock.fetchLatestPlatformBlockHeader.resolves({
+      time: {
+        seconds: timeInSeconds,
+      },
+    });
+
+    dpp = new DashPlatformProtocol({
+      stateRepository: stateRepositoryMock,
+    });
+
+    await dpp.initialize();
+  });
+
+  describe('createFromObject', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.stateTransition.createFromObject(
+          dataContractCreateTransition.toObject(),
+        );
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should skip checking for state repository if skipValidation is set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      await dpp.stateTransition.createFromObject(
+        dataContractCreateTransition.toObject(),
+        { skipValidation: true },
+      );
+    });
+
+    it('should create State Transition from plain object', async () => {
+      const result = await dpp.stateTransition.createFromObject(
+        dataContractCreateTransition.toObject(),
+      );
+
+      expect(result).to.be.an.instanceOf(DataContractCreateTransition);
+
+      expect(result.toObject()).to.deep.equal(dataContractCreateTransition.toObject());
+    });
+  });
+
+  describe('createFromBuffer', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.stateTransition.createFromBuffer(
+          dataContractCreateTransition.toBuffer(),
+        );
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should skip checking for state repository if skipValidation is set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      await dpp.stateTransition.createFromBuffer(
+        dataContractCreateTransition.toBuffer(),
+        { skipValidation: true },
+      );
+    });
+
+    it('should create State Transition from string', async () => {
+      const result = await dpp.stateTransition.createFromBuffer(
+        dataContractCreateTransition.toBuffer(),
+      );
+
+      expect(result).to.be.an.instanceOf(DataContractCreateTransition);
+
+      expect(result.toObject()).to.deep.equal(dataContractCreateTransition.toObject());
+    });
+  });
+
+  describe('validate', () => {
+    let validateBasicSpy;
+    let validateSignatureSpy;
+    let validateFeeSpy;
+    let validateStateSpy;
+
+    beforeEach(function beforeEach() {
+      validateBasicSpy = this.sinonSandbox.spy(
+        dpp.stateTransition,
+        'validateBasic',
+      );
+
+      validateSignatureSpy = this.sinonSandbox.spy(
+        dpp.stateTransition,
+        'validateSignature',
+      );
+
+      validateFeeSpy = this.sinonSandbox.spy(
+        dpp.stateTransition,
+        'validateFee',
+      );
+
+      validateStateSpy = this.sinonSandbox.spy(
+        dpp.stateTransition,
+        'validateState',
+      );
+    });
+
+    it('should return invalid result if State Transition structure is invalid', async () => {
+      const rawStateTransition = dataContractCreateTransition.toObject();
+      delete rawStateTransition.protocolVersion;
+
+      const result = await dpp.stateTransition.validate(rawStateTransition);
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.false();
+
+      expect(validateBasicSpy).to.be.calledOnceWithExactly(rawStateTransition);
+      expect(validateSignatureSpy).to.not.be.called();
+      expect(validateFeeSpy).to.not.be.called();
+      expect(validateStateSpy).to.not.be.called();
+    });
+
+    it('should return invalid result if State Transition signature is invalid', async () => {
+      dataContractCreateTransition.signature = Buffer.alloc(65).fill(1);
+
+      const result = await dpp.stateTransition.validate(dataContractCreateTransition);
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.false();
+
+      expect(validateBasicSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateSignatureSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateFeeSpy).to.not.be.called();
+      expect(validateStateSpy).to.not.be.called();
+    });
+
+    it('should return invalid result if not enough balance to pay fee for State Transition', async () => {
+      const consensusError = new SomeConsensusError('error');
+
+      dpp.stateTransition.validateStateTransitionFee = () => new ValidationResult([consensusError]);
+
+      const result = await dpp.stateTransition.validate(dataContractCreateTransition);
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.false();
+
+      expect(validateBasicSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateSignatureSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateFeeSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateStateSpy).to.not.be.called();
+    });
+
+    it('should return invalid result if State Transition is invalid against state', async () => {
+      const consensusError = new SomeConsensusError('error');
+
+      dpp.stateTransition.validateStateTransitionState = () => (
+        new ValidationResult([consensusError])
+      );
+
+      const result = await dpp.stateTransition.validate(dataContractCreateTransition);
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.false();
+
+      expect(validateBasicSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateSignatureSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateFeeSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateStateSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+    });
+
+    it('should validate DataContractCreateTransition', async () => {
+      const result = await dpp.stateTransition.validate(
+        dataContractCreateTransition,
+      );
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+
+      expect(validateBasicSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateSignatureSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateFeeSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+      expect(validateStateSpy).to.be.calledOnceWithExactly(dataContractCreateTransition);
+    });
+
+    it('should validate DocumentsBatchTransition', async function it() {
+      stateRepositoryMock.fetchDocuments.resolves([]);
+
+      stateRepositoryMock.fetchDataContract.resolves(dataContract);
+      stateRepositoryMock.fetchIdentity.resolves({
+        getPublicKeyById: this.sinonSandbox.stub().returns(identityPublicKey),
+        getBalance: this.sinonSandbox.stub().returns(10000),
+      });
+
+      const result = await dpp.stateTransition.validate(
+        documentsBatchTransition,
+      );
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+
+      expect(validateBasicSpy).to.be.calledOnceWithExactly(documentsBatchTransition);
+      expect(validateSignatureSpy).to.be.calledOnceWithExactly(documentsBatchTransition);
+      expect(validateFeeSpy).to.be.calledOnceWithExactly(documentsBatchTransition);
+      expect(validateStateSpy).to.be.calledOnceWithExactly(documentsBatchTransition);
+    });
+  });
+
+  describe('validateBasic', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.stateTransition.validateBasic(
+          dataContractCreateTransition.toObject(),
+        );
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should validate State Transition', async () => {
+      const result = await dpp.stateTransition.validateBasic(
+        dataContractCreateTransition.toObject(),
+      );
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+    });
+  });
+
+  describe('validateSignature', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.stateTransition.validateSignature(
+          dataContractCreateTransition,
+        );
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should validate identity signed State Transition', async () => {
+      const result = await dpp.stateTransition.validateSignature(
+        dataContractCreateTransition,
+      );
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+    });
+
+    it('should validate key signed State Transition', async () => {
+      const oneTimePrivateKey = new PrivateKey(
+        'af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837',
+      );
+
+      const identityCreateTransition = getIdentityCreateTransitionFixture(oneTimePrivateKey);
+
+      await identityCreateTransition.signByPrivateKey(
+        oneTimePrivateKey,
+        IdentityPublicKey.TYPES.ECDSA_SECP256K1,
+      );
+
+      const result = await dpp.stateTransition.validateSignature(
+        identityCreateTransition,
+      );
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+    });
+  });
+
+  describe('validateFee', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.stateTransition.validateFee(
+          dataContractCreateTransition,
+        );
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should validate State Transition', async () => {
+      const result = await dpp.stateTransition.validateFee(
+        dataContractCreateTransition,
+      );
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+    });
+  });
+
+  describe('validateState', () => {
+    it('should throw MissingOption if stateRepository is not set', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      try {
+        await dpp.stateTransition.validateState(
+          dataContractCreateTransition,
+        );
+
+        expect.fail('MissingOption should be thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(MissingOptionError);
+        expect(e.getOptionName()).to.equal('stateRepository');
+      }
+    });
+
+    it('should validate State Transition', async () => {
+      const result = await dpp.stateTransition.validateState(
+        dataContractCreateTransition,
+      );
+
+      expect(result).to.be.an.instanceOf(ValidationResult);
+      expect(result.isValid()).to.be.true();
+    });
+  });
+});

package/test/integration/stateTransition/calculateStateTransitionFee.spec.js

@@ -0,0 +1,35 @@
+const calculateStateTransitionFee = require('../../../lib/stateTransition/fee/calculateStateTransitionFee');
+
+const getIdentityCreateTransitionFixture = require('../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
+const IdentityPublicKey = require('../../../lib/identity/IdentityPublicKey');
+const ReadOperation = require('../../../lib/stateTransition/fee/operations/ReadOperation');
+const WriteOperation = require('../../../lib/stateTransition/fee/operations/WriteOperation');
+const DeleteOperation = require('../../../lib/stateTransition/fee/operations/DeleteOperation');
+const PreCalculatedOperation = require('../../../lib/stateTransition/fee/operations/PreCalculatedOperation');
+
+describe('calculateStateTransitionFee', () => {
+  let stateTransition;
+
+  beforeEach(async () => {
+    const privateKey = 'af432c476f65211f45f48f1d42c9c0b497e56696aa1736b40544ef1a496af837';
+
+    stateTransition = getIdentityCreateTransitionFixture();
+    await stateTransition.signByPrivateKey(privateKey, IdentityPublicKey.TYPES.ECDSA_SECP256K1);
+  });
+
+  // TODO: Must be more comprehensive. After we settle all factors and formula.
+  it('should calculate fee based on executed operations', () => {
+    const executionContext = stateTransition.getExecutionContext();
+
+    executionContext.addOperation(
+      new ReadOperation(10),
+      new WriteOperation(5, 5),
+      new DeleteOperation(6, 6),
+      new PreCalculatedOperation(12, 12),
+    );
+
+    const result = calculateStateTransitionFee(stateTransition);
+
+    expect(result).to.equal(13616);
+  });
+});

package/test/integration/util/generateEntropy.spec.js

@@ -0,0 +1,17 @@
+const { generate: generateEntropy } = require('../../../lib/util/entropyGenerator');
+
+describe('generateEntropy', () => {
+  it('should generate a byte array of length 32', () => {
+    const entropy = generateEntropy();
+
+    expect(Buffer.isBuffer(entropy)).to.be.true();
+    expect(entropy.byteLength).to.be.equal(32);
+  });
+
+  it('should generate random byte array', () => {
+    const randomBuffer = generateEntropy();
+    const secondRandomBuffer = generateEntropy();
+
+    expect(randomBuffer).to.not.deep.equal(secondRandomBuffer);
+  });
+});

package/test/integration/util/serializer.spec.js

@@ -0,0 +1,24 @@
+const { encode } = require('../../../lib/util/serializer');
+
+const DataSerializationError = require('../../../lib/util/errors/MaxEncodedBytesReachedError');
+
+describe('serializer', function main() {
+  this.timeout(10000);
+
+  describe('#encode', () => {
+    it('should throw an error if payload is larger that 16 Kb', () => {
+      const payload = {};
+      for (let i = 0; i < 10000; i++) {
+        payload[i] = i;
+      }
+
+      try {
+        encode(payload);
+        expect.fail('Error was not thrown');
+      } catch (e) {
+        expect(e).to.be.an.instanceOf(DataSerializationError);
+        expect(e.getPayload()).to.deep.equal(payload);
+      }
+    });
+  });
+});

package/test/unit/DashPlatformProtocol.spec.js

@@ -0,0 +1,79 @@
+const { default: Ajv } = require('ajv/dist/2020');
+
+const protocolVersion = require('../../lib/version/protocolVersion');
+
+const DashPlatformProtocol = require('../../lib/DashPlatformProtocol');
+const JsonSchemaValidator = require('../../lib/validation/JsonSchemaValidator');
+
+const createStateRepositoryMock = require('../../lib/test/mocks/createStateRepositoryMock');
+
+describe('DashPlatformProtocol', () => {
+  let dpp;
+  let stateRepositoryMock;
+  let jsonSchemaValidatorMock;
+
+  beforeEach(async function beforeEach() {
+    stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
+    jsonSchemaValidatorMock = {};
+
+    dpp = new DashPlatformProtocol({
+      stateRepository: stateRepositoryMock,
+      jsonSchemaValidator: jsonSchemaValidatorMock,
+    });
+    await dpp.initialize();
+  });
+
+  describe('constructor', () => {
+    it('should create JsonSchemaValidator if not passed in options', async () => {
+      dpp = new DashPlatformProtocol();
+      await dpp.initialize();
+
+      const jsonSchemaValidator = dpp.getJsonSchemaValidator();
+
+      expect(jsonSchemaValidator).to.be.instanceOf(JsonSchemaValidator);
+      expect(jsonSchemaValidator.ajv).to.be.instanceOf(Ajv);
+    });
+
+    it('should set default protocol version', () => {
+      dpp = new DashPlatformProtocol();
+
+      expect(dpp.protocolVersion).to.equal(protocolVersion.latestVersion);
+    });
+  });
+
+  describe('getStateRepository', () => {
+    it('should return StateRepository', () => {
+      const result = dpp.getStateRepository();
+
+      expect(result).to.equal(stateRepositoryMock);
+    });
+  });
+
+  describe('getJsonSchemaValidator', () => {
+    it('should return JsonSchemaValidator', () => {
+      const result = dpp.getJsonSchemaValidator();
+
+      expect(result).to.equal(jsonSchemaValidatorMock);
+    });
+  });
+
+  describe('setProtocolVersion', () => {
+    it('should set protocol version', () => {
+      expect(dpp.protocolVersion).to.equal(protocolVersion.latestVersion);
+
+      dpp.setProtocolVersion(42);
+
+      expect(dpp.protocolVersion).to.equal(42);
+    });
+  });
+
+  describe('getProtocolVersion', () => {
+    it('should get protocol version', () => {
+      expect(dpp.getProtocolVersion()).to.equal(protocolVersion.latestVersion);
+
+      dpp.setProtocolVersion(42);
+
+      expect(dpp.getProtocolVersion()).to.equal(42);
+    });
+  });
+});

package/test/unit/Identifier.spec.js

@@ -0,0 +1,123 @@
+const crypto = require('crypto');
+const bs58 = require('bs58');
+const Identifier = require('../../lib/identifier/Identifier');
+const IdentifierError = require('../../lib/identifier/errors/IdentifierError');
+
+describe('Identifier', () => {
+  let buffer;
+
+  beforeEach(() => {
+    buffer = crypto.randomBytes(32);
+  });
+
+  describe('#constructor', () => {
+    it('should accept Buffer', () => {
+      const identifier = new Identifier(buffer);
+
+      expect(identifier).to.be.deep.equal(buffer);
+      expect(identifier).to.be.an.instanceOf(Identifier);
+    });
+
+    it('should throw error if first argument is not Buffer', () => {
+      expect(
+        () => new Identifier(1),
+      ).to.throw(IdentifierError, 'Identifier expects Buffer');
+    });
+
+    it('should throw error if buffer is not 32 bytes long', () => {
+      expect(
+        () => new Identifier(Buffer.alloc(30)),
+      ).to.throw(IdentifierError, 'Identifier must be 32 long');
+    });
+  });
+
+  describe('#toBuffer', () => {
+    it('should return a new normal Buffer', () => {
+      const identifier = new Identifier(buffer);
+
+      expect(identifier.toBuffer()).to.deep.equal(buffer);
+    });
+  });
+
+  describe('#encodeCBOR', () => {
+    let encoderMock;
+
+    beforeEach(function before() {
+      encoderMock = {
+        pushAny: this.sinonSandbox.stub(),
+      };
+    });
+
+    it('should encode using cbor encoder', () => {
+      const identifier = new Identifier(buffer);
+
+      const result = identifier.encodeCBOR(encoderMock);
+
+      expect(result).to.be.true();
+      expect(encoderMock.pushAny).to.be.calledOnceWithExactly(buffer);
+    });
+  });
+
+  describe('#toJSON', () => {
+    it('should return a base58 encoded string', () => {
+      const identifier = new Identifier(buffer);
+
+      const string = identifier.toJSON();
+
+      expect(string).to.equal(bs58.encode(buffer));
+    });
+  });
+
+  describe('#toString', () => {
+    it('should return a base58 encoded string by default', () => {
+      const base58string = bs58.encode(buffer);
+
+      const identifier = new Identifier(buffer);
+
+      const string = identifier.toString();
+
+      expect(string).to.equal(base58string);
+    });
+
+    it('should return a string encoded with specified encoding', () => {
+      const identifier = new Identifier(buffer);
+
+      const string = identifier.toString('base64');
+
+      expect(string).to.equal(buffer.toString('base64'));
+    });
+  });
+
+  describe('#from', () => {
+    it('should create an instance from Buffer', async () => {
+      const identifier = Identifier.from(buffer);
+
+      expect(identifier).to.be.an.instanceOf(Identifier);
+      expect(identifier).to.deep.equal(buffer);
+    });
+
+    it('should throw error if buffer is passed among with encoding', async () => {
+      expect(
+        () => Identifier.from(buffer, 'base64'),
+      ).to.throw(IdentifierError, 'encoding accepted only with type string');
+    });
+
+    it('should create an instance with a base58 string', () => {
+      const string = bs58.encode(buffer);
+
+      const identifier = Identifier.from(string);
+
+      expect(identifier).to.be.an.instanceOf(Identifier);
+      expect(identifier).to.deep.equal(buffer);
+    });
+
+    it('should create an instance with a base64 string', () => {
+      const string = buffer.toString('base64');
+
+      const identifier = Identifier.from(string, 'base64');
+
+      expect(identifier).to.be.an.instanceOf(Identifier);
+      expect(identifier).to.deep.equal(buffer);
+    });
+  });
+});