dash-platform-sdk 1.0.1 → 1.0.2

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  transformIgnorePatterns: [
+    'node_modules/(?!pshenmic-dpp)'
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dash-platform-sdk",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "main": "dist/main.js",
   "devDependencies": {
     "@babel/core": "^7.26.10",
@@ -12,6 +12,7 @@
     "isomorphic-ws": "^5.0.0",
     "jest": "^29.7.0",
     "nice-grpc-web": "^3.3.6",
+    "standard": "^17.1.2",
     "stream-browserify": "^3.0.0",
     "ts-node": "^10.9.2",
     "ts-proto": "^2.6.1",
@@ -24,6 +25,7 @@
   "scripts": {
     "build": "webpack",
     "build:grpc": "yarn proto:generate && yarn proto:transpile",
+    "lint": "standard",
     "test": "jest",
     "test:debug": "node --inspect-brk ./node_modules/.bin/jest",
     "proto:generate": "grpc_tools_node_protoc --plugin=protoc-gen-ts_proto=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_out=./proto/generated --ts_proto_opt=forceLong=string,env=browser,outputServices=nice-grpc,outputServices=generic-definitions,outputJsonMethods=false,useExactTypes=false --proto_path=./proto ./proto/platform.proto",
@@ -31,6 +33,7 @@
   },
   "dependencies": {
     "@scure/base": "^1.2.4",
-    "cbor": "^10.0.3"
+    "cbor": "^10.0.3",
+    "pshenmic-dpp": "^1.0.3"
   }
 }

package/src/dataContracts/getByIdentifier.js

@@ -0,0 +1,22 @@
+import { PlatformVersionWASM } from 'pshenmic-dpp'
+import { GetDataContractRequest } from '../../proto/generated/platform'
+import parseIdentifier from '../utils/parseIdentifier'
+
+export default async function GetByIdentifier (identifier) {
+  // eslint-disable-next-line new-cap
+  const getDataContractRequest = new GetDataContractRequest.fromPartial({
+    v0: {
+      id: parseIdentifier(identifier)
+    }
+  })
+
+  const { v0 } = await this.grpcPool.getClient().getDataContract(getDataContractRequest)
+
+  const { dataContract } = v0
+
+  if (!dataContract) {
+    throw new Error(`Data Contract with identifier ${identifier} not found`)
+  }
+
+  return this.wasm.DataContractWASM.fromBytes(dataContract, true, PlatformVersionWASM.PLATFORM_V1)
+}

package/src/documents/create.js

@@ -0,0 +1,9 @@
+export default async function createDocument (dataContract, documentType, data, identityContractNonce, identity, identityPublicKey, privateKey) {
+  return new this.wasm.DocumentWASM(
+    data,
+    documentType,
+    identityContractNonce,
+    dataContract,
+    identity
+  )
+}

package/src/documents/get.js

@@ -0,0 +1,26 @@
+import { GetDocumentsRequest } from '../../proto/generated/platform.js'
+import { base58 } from '@scure/base'
+import cbor from 'cbor'
+import { DocumentWASM, PlatformVersionWASM } from 'pshenmic-dpp'
+import getByIdentifier from '../dataContracts/getByIdentifier'
+
+export default async function get (dataContractId, documentType, where, orderBy, limit = 100, startAt, startAfter) {
+  // eslint-disable-next-line new-cap
+  const getDocumentsRequest = new GetDocumentsRequest.fromPartial({
+    v0: {
+      dataContractId: base58.decode(dataContractId),
+      documentType,
+      where: where ? cbor.encode(where) : undefined,
+      orderBy: orderBy ? cbor.encode(orderBy) : undefined,
+      limit,
+      startAt: startAt || undefined,
+      startAfter: startAfter || undefined
+    }
+  })
+
+  const dataContract = await getByIdentifier.bind(this)(dataContractId)
+
+  const { v0 } = await this.grpcPool.getClient().getDocuments(getDocumentsRequest)
+
+  return v0.documents.documents.map(document => DocumentWASM.fromBytes(document, dataContract, documentType, PlatformVersionWASM.PLATFORM_V1))
+}

package/src/errors/identityNotFoundError.js

@@ -0,0 +1,3 @@
+export default class IdentityNotFoundError extends Error {
+
+}

package/src/grpcConnectionPool.js

@@ -0,0 +1,50 @@
+import getRandomArrayItem from './utils/getRandomArrayItem'
+import { createChannel, createClient } from 'nice-grpc-web'
+import { PlatformDefinition } from '../proto/generated/platform'
+import getEvonodeList from './utils/getEvonodeList'
+
+const seedNodes = {
+  testnet: [
+    'https://54.201.32.131:1443',
+    'https://52.42.202.128:1443',
+    'https://52.40.219.41:1443',
+    'https://52.89.154.48:1443',
+    'https://52.34.144.50:1443'
+  ],
+  mainnet: [
+    'https://149.202.78.214',
+    'https://52.10.213.198',
+    'https://194.163.166.185',
+    'https://66.70.170.22',
+    'https://31.220.85.180'
+  ]
+}
+
+export default class GRPCConnectionPool {
+  channels
+
+  constructor (network) {
+    this.channels = seedNodes[network].map(dapiUrl => createChannel(dapiUrl))
+
+    getEvonodeList(network)
+      .then((evonodeList) => {
+        const evonodeListDapiURLs = Object
+          .entries(evonodeList)
+          .map(([, info]) => info)
+          .filter(info => info.status === 'ENABLED')
+          .map(info => {
+            const [host] = info.address.split(':')
+
+            return `https://${host}:${info.platformHTTPPort}`
+          })
+
+        this.channels = evonodeListDapiURLs.map(dapiUrl => createChannel(dapiUrl))
+      })
+      .catch(console.error)
+  }
+
+  getClient () {
+    const channel = getRandomArrayItem(this.channels)
+    return createClient(PlatformDefinition, channel)
+  }
+}

package/src/identities/getByIdentifier.js

@@ -0,0 +1,22 @@
+import { GetIdentityRequest } from '../../proto/generated/platform'
+import parseIdentifier from '../utils/parseIdentifier'
+import { IdentityWASM } from 'pshenmic-dpp'
+
+export default async function getByIdentifier (identifier) {
+  // eslint-disable-next-line new-cap
+  const getIdentityRequest = new GetIdentityRequest.fromPartial({
+    v0: {
+      id: parseIdentifier(identifier)
+    }
+  })
+
+  const { v0 } = await this.grpcPool.getClient().getIdentity(getIdentityRequest)
+
+  const { identity } = v0
+
+  if (!identity) {
+    throw new Error(`Identity with identifier ${identifier} not found`)
+  }
+
+  return IdentityWASM.fromBytes(identity)
+}

package/src/identities/getByPublicKeyHash.js

@@ -0,0 +1,24 @@
+import {
+  GetIdentityByPublicKeyHashRequest
+} from '../../proto/generated/platform'
+import { IdentityWASM } from 'pshenmic-dpp'
+import hexToUint8Array from '../utils/hexToUint8Array'
+
+export default async function getByPublicKeyHash (hex) {
+  // eslint-disable-next-line new-cap
+  const getIdentityByPublicKeyHashRequest = new GetIdentityByPublicKeyHashRequest.fromPartial({
+    v0: {
+      publicKeyHash: hexToUint8Array(hex)
+    }
+  })
+
+  const { v0 } = await this.grpcPool.getClient().getIdentityByPublicKeyHash(getIdentityByPublicKeyHashRequest)
+
+  const { identity } = v0
+
+  if (!identity) {
+    throw new Error(`Identity with public key hash ${hex} not found`)
+  }
+
+  return IdentityWASM.fromBytes(identity)
+}

package/src/identities/getIdentityContractNonce.js

@@ -0,0 +1,26 @@
+import {
+  GetIdentityContractNonceRequest
+} from '../../proto/generated/platform'
+import parseIdentifier from '../utils/parseIdentifier'
+
+const IDENTITY_CONTRACT_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF)
+
+export default async function getIdentityContractNonce (identity, dataContract) {
+  // eslint-disable-next-line new-cap
+  const getIdentityContractNonceRequest = new GetIdentityContractNonceRequest.fromPartial({
+    v0: {
+      identityId: parseIdentifier(identity),
+      contractId: parseIdentifier(dataContract)
+    }
+  })
+
+  const { v0 } = await this.grpcPool.getClient().getIdentityContractNonce(getIdentityContractNonceRequest)
+
+  const { identityContractNonce } = v0
+
+  if (!identityContractNonce) {
+    throw new Error(`Could not get identityContractNonce for Identity with identifier ${identity}`)
+  }
+
+  return BigInt(identityContractNonce) & IDENTITY_CONTRACT_NONCE_VALUE_FILTER
+}

package/src/identities/getIdentityNonce.js

@@ -0,0 +1,25 @@
+import {
+  GetIdentityNonceRequest
+} from '../../proto/generated/platform'
+import parseIdentifier from '../utils/parseIdentifier'
+
+const IDENTITY_NONCE_VALUE_FILTER = BigInt(0xFFFFFFFFFF)
+
+export default async function getIdentityNonce (identifier) {
+  // eslint-disable-next-line new-cap
+  const getIdentityNonceRequest = new GetIdentityNonceRequest.fromPartial({
+    v0: {
+      identityId: parseIdentifier(identifier)
+    }
+  })
+
+  const { v0 } = await this.grpcPool.getClient().getIdentityNonce(getIdentityNonceRequest)
+
+  const { identityNonce } = v0
+
+  if (!identityNonce) {
+    throw new Error(`Could not get identityNonce for Identity with identifier ${identifier}`)
+  }
+
+  return BigInt(identityNonce) & IDENTITY_NONCE_VALUE_FILTER
+}

package/src/identities/getIdentityPublicKeys.js

@@ -0,0 +1,19 @@
+import { GetIdentityKeysRequest, KeyRequestType } from '../../proto/generated/platform'
+import parseIdentifier from '../utils/parseIdentifier'
+
+export default async function getIdentityPublicKeys (identifier) {
+  // eslint-disable-next-line new-cap
+  const getIdentityKeysRequest = new GetIdentityKeysRequest.fromPartial({
+    v0: {
+      identityId: parseIdentifier(identifier),
+      requestType: KeyRequestType.fromPartial({ allKeys: {} })
+    }
+  })
+
+  const { v0 } = await this.grpcPool.getClient().getIdentityKeys(getIdentityKeysRequest)
+
+  const { keys } = v0
+  const { keysBytes } = keys
+
+  return keysBytes.map((bytes) => this.wasm.IdentityPublicKeyWASM.fromBytes(bytes))
+}

package/src/index.js

@@ -0,0 +1,63 @@
+import status from './node/status'
+import getDocuments from './documents/get'
+import createDocument from './documents/create'
+import getDataContractByIdentifier from './dataContracts/getByIdentifier'
+import getIdentityByIdentifier from './identities/getByIdentifier'
+import getByPublicKeyHash from './identities/getByPublicKeyHash'
+import * as wasm from 'pshenmic-dpp'
+import wasmBytes from 'pshenmic-dpp/dist/wasm/pshenmic_dpp_bg'
+import getIdentityContractNonce from './identities/getIdentityContractNonce'
+import getIdentityNonce from './identities/getIdentityNonce'
+import getIdentityPublicKeys from './identities/getIdentityPublicKeys'
+import search from './names/search'
+import GRPCConnectionPool from './grpcConnectionPool'
+import fromDocument from './stateTransitions/fromDocument'
+import broadcastStateTransition from './stateTransitions/broadcast'
+import waitForStateTransitionResult from './stateTransitions/waitForStateTransitionResult'
+
+const DEFAULT_OPTIONS = {
+  network: 'testnet'
+}
+
+export default class DashPlatformSDK {
+  constructor (options = DEFAULT_OPTIONS) {
+    wasm.initSync({ module: Buffer.from(wasmBytes, 'base64') })
+
+    this.network = options.network
+
+    this.grpcPool = new GRPCConnectionPool(this.network)
+
+    this.wasm = wasm
+
+    this.dataContracts = {
+      getByIdentifier: getDataContractByIdentifier.bind(this)
+    }
+
+    this.documents = {
+      query: getDocuments.bind(this),
+      create: createDocument.bind(this)
+    }
+
+    this.names = {
+      search: search.bind(this)
+    }
+
+    this.stateTransitions = {
+      fromDocument: fromDocument.bind(this),
+      broadcast: broadcastStateTransition.bind(this),
+      waitForStateTransitionResult: waitForStateTransitionResult.bind(this),
+    }
+
+    this.identities = {
+      getByIdentifier: getIdentityByIdentifier.bind(this),
+      getByPublicKeyHash: getByPublicKeyHash.bind(this),
+      getIdentityContractNonce: getIdentityContractNonce.bind(this),
+      getIdentityNonce: getIdentityNonce.bind(this),
+      getIdentityPublicKeys: getIdentityPublicKeys.bind(this)
+    }
+
+    this.node = {
+      status: status.bind(this)
+    }
+  }
+}

package/src/names/search.js

@@ -0,0 +1,22 @@
+import convertToHomographSafeChars from '../utils/convertToHomographSafeChars'
+import query from '../documents/get'
+
+const DPNS_DATA_CONTRACT_ID = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec'
+
+export default async function search (name) {
+  const [label, parentDomainName] = name.split('.')
+
+  const normalizedParentDomainName = convertToHomographSafeChars(parentDomainName)
+  const normalizedLabelPrefix = convertToHomographSafeChars(label)
+
+  const where = [
+    ['normalizedParentDomainName', '==', normalizedParentDomainName],
+    ['normalizedLabel', 'startsWith', normalizedLabelPrefix]
+  ]
+
+  const orderBy = [
+    ['normalizedLabel', 'asc']
+  ]
+
+  return query.bind(this)(DPNS_DATA_CONTRACT_ID, 'domain', where, orderBy)
+}

package/src/{dapi/getStatus.js → node/status.js}

@@ -1,19 +1,20 @@
 import { GetStatusRequest } from '../../proto/generated/platform.js'
 
-export default async function getStatus() {
-  const getStatusRequest = new GetStatusRequest.fromPartial({v0: {}});
+export default async function status () {
+  // eslint-disable-next-line new-cap
+  const getStatusRequest = new GetStatusRequest.fromPartial({ v0: {} })
 
-  const response  = await this.client.getStatus(getStatusRequest)
+  const response = await this.grpcPool.getClient().getStatus(getStatusRequest)
 
-  const {v0} = response
+  const { v0 } = response
 
   // map buffers to hex string
-  v0.node.id = v0.node.id.reduce((code, acc) => acc + code.toString(16), "")
-  v0.node.proTxHash = v0.node.proTxHash.reduce((code, acc) => acc + code.toString(16), "")
-  v0.chain.latestBlockHash = v0.chain.latestBlockHash.reduce((code, acc) => acc + code.toString(16), "")
-  v0.chain.latestAppHash = v0.chain.latestAppHash.reduce((code, acc) => acc + code.toString(16), "")
-  v0.chain.earliestAppHash = v0.chain.earliestAppHash.reduce((code, acc) => acc + code.toString(16), "")
-  v0.chain.earliestBlockHash = v0.chain.earliestBlockHash.reduce((code, acc) => acc + code.toString(16), "")
+  v0.node.id = v0.node.id.reduce((code, acc) => acc + code.toString(16), '')
+  v0.node.proTxHash = v0.node.proTxHash.reduce((code, acc) => acc + code.toString(16), '')
+  v0.chain.latestBlockHash = v0.chain.latestBlockHash.reduce((code, acc) => acc + code.toString(16), '')
+  v0.chain.latestAppHash = v0.chain.latestAppHash.reduce((code, acc) => acc + code.toString(16), '')
+  v0.chain.earliestAppHash = v0.chain.earliestAppHash.reduce((code, acc) => acc + code.toString(16), '')
+  v0.chain.earliestBlockHash = v0.chain.earliestBlockHash.reduce((code, acc) => acc + code.toString(16), '')
 
   return v0
 }

package/src/stateTransitions/broadcast.js

@@ -0,0 +1,12 @@
+import { BroadcastStateTransitionRequest } from '../../proto/generated/platform'
+
+export default async function broadcast (stateTransition) {
+  // eslint-disable-next-line new-cap
+  const broadcastStateTransitionRequest = new BroadcastStateTransitionRequest.fromPartial({
+    v0: {
+      stateTransition: stateTransition.toBuffer()
+    }
+  })
+
+  await this.grpcPool.getClient().broadcastStateTransition(broadcastStateTransitionRequest)
+}

package/src/stateTransitions/fromDocument.js

@@ -0,0 +1,5 @@
+export default async function fromDocument (document, batchType, identityContractNonce, params = {}) {
+  const documentsBatch = this.wasm.DocumentBatchWASM.new(batchType, document, identityContractNonce)
+
+  return documentsBatch.toStateTransition()
+}

package/src/stateTransitions/waitForStateTransitionResult.js

@@ -0,0 +1,18 @@
+import { WaitForStateTransitionResultRequest } from '../../proto/generated/platform'
+
+export default async function waitForStateTransitionResult (stateTransitionHash) {
+  // eslint-disable-next-line new-cap
+  const waitForStateTransitionResultRequest = new WaitForStateTransitionResultRequest.fromPartial({
+    v0: {
+      stateTransitionHash
+    }
+  })
+
+  const { v0 } = await this.grpcPool.getClient().waitForStateTransitionResult(waitForStateTransitionResultRequest)
+
+  const { error } = v0
+
+  if (error) {
+    throw new Error(error)
+  }
+}

package/src/utils/convertToHomographSafeChars.js

@@ -0,0 +1,17 @@
+/**
+ * @param {string} input
+ * @return {string}
+ */
+export default function convertToHomographSafeChars (input) {
+  return input.toLowerCase().replace(/[oli]/g, (match) => {
+    if (match === 'o') {
+      return '0'
+    }
+
+    if (match === 'l' || match === 'i') {
+      return '1'
+    }
+
+    return match
+  })
+}

package/src/utils/getEvonodeList.js

@@ -0,0 +1,33 @@
+export default async function getEvonodeList (network) {
+  const baseUrl = {
+    testnet: 'https://trpc.digitalcash.dev',
+    mainnet: 'https://rpc.digitalcash.dev'
+  }[network]
+
+  // let basicAuth = btoa(`user:pass`);
+  const payload = JSON.stringify({
+    method: 'masternodelist',
+    params: [
+      'evo'
+    ]
+  })
+
+  const resp = await fetch(baseUrl, {
+    method: 'POST',
+    headers: {
+      // "Authorization": `Basic ${basicAuth}`,
+      'Content-Type': 'application/json'
+    },
+    body: payload
+  })
+
+  const data = await resp.json()
+
+  if (data.error) {
+    const err = new Error(data.error.message)
+    Object.assign(err, data.error)
+    throw err
+  }
+
+  return data.result
+}

package/src/utils/getRandomArrayItem.js

@@ -0,0 +1,3 @@
+export default function getRandomArrayItem (array) {
+  return array[Math.floor((Math.random() * array.length))]
+}

package/src/utils/hexToUint8Array.js

@@ -0,0 +1,3 @@
+export default function hexToUint8Array (hex) {
+  return Uint8Array.from(hex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)))
+}

package/src/utils/parseIdentifier.js

@@ -0,0 +1,7 @@
+import { base58 } from '@scure/base'
+
+export default function parseIdentifier (identifier) {
+  if (typeof identifier === 'string') {
+    return base58.decode(identifier)
+  }
+}

package/test/unit/index.spec.js

@@ -1,4 +1,7 @@
-import DashPlatformSDK from '../../index'
+/* global describe, test, beforeAll, expect */
+
+import DashPlatformSDK from '../../src/index'
+import { DataContractWASM, DocumentWASM, IdentityPublicKeyWASM, IdentityWASM } from 'pshenmic-dpp'
 
 let sdk
 
@@ -12,7 +15,7 @@ describe('DashPlatformSDK', () => {
   })
 
   test('should be able to call getStatus', async () => {
-    const status = await sdk.utils.getStatus()
+    const status = await sdk.node.status()
 
     expect(status.version.software.dapi).toEqual(expect.any(String))
     expect(status.version.software.drive).toEqual(expect.any(String))
@@ -56,9 +59,84 @@ describe('DashPlatformSDK', () => {
     expect(status.time.epoch).toEqual(expect.any(Number))
   })
 
-  test('should be able to call getDocuments()', async () => {
-    const documents = await sdk.documents.get('GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec', 'domain')
+  test('should be able to create document', async () => {
+    const dataContract = '6QMfQTdKpC3Y9uWBcTwXeY3KdzRLDqASUsDnQ4MEc9XC'
+    const identity = 'B7kcE1juMBWEWkuYRJhVdAE2e6RaevrGxRsa1DrLCpQH'
+    const identityContractNonce = BigInt(1)
+    const documentType = 'pool'
+    const data = {
+      name: 'MyPool',
+      type: 'EVONODE',
+      status: 'INACTIVE',
+      description: 'test pool'
+    }
+
+    const document = await sdk.documents.create(dataContract, documentType, data, identityContractNonce, identity)
+
+    expect(document).toEqual(expect.any(DocumentWASM))
+  })
+
+  test('should be able to get data contract', async () => {
+    const dataContractIdentifier = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec'
+
+    const dataContract = await sdk.dataContracts.getByIdentifier(dataContractIdentifier)
+
+    expect(dataContract).toEqual(expect.any(DataContractWASM))
+  })
+
+  test('should be able to get documents', async () => {
+    const dataContract = 'GWRSAVFMjXx8HpQFaNJMqBV7MBgMK4br5UESsB4S31Ec'
+    const documentType = 'domain'
+
+    const [document] = await sdk.documents.query(dataContract, documentType)
+
+    expect(document).toEqual(expect.any(DocumentWASM))
+  })
+
+  test('should be able to search names by DPNS name', async () => {
+    const [document] = await sdk.names.search('xyz.dash')
+
+    expect(document).toEqual(expect.any(DocumentWASM))
+  })
+
+  test('should be able to get identity by identifier', async () => {
+    const identifier = 'B7kcE1juMBWEWkuYRJhVdAE2e6RaevrGxRsa1DrLCpQH'
+
+    const identity = await sdk.identities.getByIdentifier(identifier)
+
+    expect(identity).toEqual(expect.any(IdentityWASM))
+  })
+
+  test('should be able to get identity by public key hash', async () => {
+    const publicKeyHash = 'c5b7fdfa5731e1b31b1b42c13959756e8db22b3b'
+
+    const identity = await sdk.identities.getByPublicKeyHash(publicKeyHash)
+
+    expect(identity).toEqual(expect.any(IdentityWASM))
+  })
+
+  test('should be able to get identity contract nonce', async () => {
+    const identifier = 'B7kcE1juMBWEWkuYRJhVdAE2e6RaevrGxRsa1DrLCpQH'
+    const dataContract = '6QMfQTdKpC3Y9uWBcTwXeY3KdzRLDqASUsDnQ4MEc9XC'
+
+    const identityContractNonce = await sdk.identities.getIdentityContractNonce(identifier, dataContract)
+
+    expect(identityContractNonce).toEqual(expect.any(BigInt))
+  })
+
+  test('should be able to get identity nonce', async () => {
+    const identifier = 'B7kcE1juMBWEWkuYRJhVdAE2e6RaevrGxRsa1DrLCpQH'
+
+    const identityNonce = await sdk.identities.getIdentityNonce(identifier)
+
+    expect(identityNonce).toEqual(expect.any(BigInt))
+  })
+
+  test('should be able to get identity public keys', async () => {
+    const identifier = 'B7kcE1juMBWEWkuYRJhVdAE2e6RaevrGxRsa1DrLCpQH'
+
+    const identityPublicKeys = await sdk.identities.getIdentityPublicKeys(identifier)
 
-    expect(documents.length).toEqual(100)
+    expect(identityPublicKeys.every(identityPublicKey => identityPublicKey instanceof IdentityPublicKeyWASM)).toBeTruthy()
   })
 })

package/webpack.config.js

@@ -1,18 +1,17 @@
-const path = require('path');
+const path = require('path')
 
 module.exports = {
   mode: 'production',
-  entry: './index.js',
+  entry: './src/index.js',
   resolve: {
     fallback: {
-      "stream":  require.resolve("stream-browserify"),
-      "buffer": require.resolve("buffer/")
-    },
+      stream: require.resolve('stream-browserify'),
+      buffer: require.resolve('buffer/')
+    }
   },
   output: {
     globalObject: 'this',
     path: path.resolve(__dirname, 'dist'),
     libraryTarget: 'umd'
-  },
-};
-
+  }
+}