dash 3.22.10 → 3.22.13

package/dist/src/SDK/Client/Platform/Platform.d.ts

@@ -38,6 +38,13 @@ interface Identities {
     get: Function;
     register: Function;
     topUp: Function;
+    utils: {
+        createAssetLockTransaction: Function;
+        createAssetLockProof: Function;
+        createIdentityCreateTransition: Function;
+        createIdentityTopUpTransition: Function;
+        waitForCoreChainLockedHeight: Function;
+    };
 }
 interface DataContracts {
     update: Function;

package/dist/src/SDK/Client/Platform/createAssetLockTransaction.d.ts

@@ -2,13 +2,14 @@ import { PrivateKey, Transaction } from "@dashevo/dashcore-lib";
 import { Platform } from "./Platform";
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {number} fundingAmount - amount of dash to fund the identity's credits
  * @return {Promise<{transaction: Transaction, privateKey: PrivateKey}>} - transaction and one time private key
  * that can be used to sign registration/top-up state transition
  */
-export default function createAssetLockTransaction(platform: Platform, fundingAmount: any): Promise<{
+export declare function createAssetLockTransaction(this: Platform, fundingAmount: any): Promise<{
     transaction: Transaction;
     privateKey: PrivateKey;
     outputIndex: number;
 }>;
+export default createAssetLockTransaction;

package/dist/src/SDK/Client/Platform/methods/identities/internal/createAssetLockProof.d.ts

@@ -2,10 +2,11 @@ import { Transaction } from "@dashevo/dashcore-lib";
 import { Platform } from "../../../Platform";
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {Transaction} assetLockTransaction
  * @param {number} outputIndex - index of the funding output in the asset lock transaction
  * @return {AssetLockProof} - asset lock proof to be used in the state transition
  * that can be used to sign registration/top-up state transition
  */
-export default function createAssetLockProof(platform: Platform, assetLockTransaction: Transaction, outputIndex: number): Promise<any>;
+export declare function createAssetLockProof(this: Platform, assetLockTransaction: Transaction, outputIndex: number): Promise<any>;
+export default createAssetLockProof;

package/dist/src/SDK/Client/Platform/methods/identities/internal/createIdentityCreateTransition.d.ts

@@ -2,14 +2,15 @@ import { PrivateKey } from "@dashevo/dashcore-lib";
 import { Platform } from "../../../Platform";
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {AssetLockProof} assetLockProof - asset lock transaction proof for the identity create transition
  * @param {PrivateKey} assetLockPrivateKey - private key used in asset lock
  * @return {{identity: Identity, identityCreateTransition: IdentityCreateTransition}} - identity, state transition and index of the key used to create it
  * that can be used to sign registration/top-up state transition
  */
-export default function createIdentityCreateTransition(platform: Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey): Promise<{
+export declare function createIdentityCreateTransition(this: Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey): Promise<{
     identity: any;
     identityCreateTransition: any;
     identityIndex: number;
 }>;
+export default createIdentityCreateTransition;

package/dist/src/SDK/Client/Platform/methods/identities/internal/createIdnetityTopUpTransition.d.ts

@@ -2,11 +2,12 @@ import { PrivateKey } from "@dashevo/dashcore-lib";
 import { Platform } from "../../../Platform";
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {AssetLockProof} assetLockProof - asset lock transaction proof for the identity create transition
  * @param {PrivateKey} assetLockPrivateKey - private key used in asset lock
  * @param {string|Buffer|Identifier} identityId
  * @return {{identity: Identity, identityCreateTransition: IdentityCreateTransition}} - identity, state transition and index of the key used to create it
  * that can be used to sign registration/top-up state transition
  */
-export default function createIdentityTopUpTransition(platform: Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey, identityId: any): Promise<any>;
+export declare function createIdentityTopUpTransition(this: Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey, identityId: any): Promise<any>;
+export default createIdentityTopUpTransition;

package/dist/src/SDK/Client/Platform/methods/identities/internal/waitForCoreChainLockedHeight.d.ts

@@ -1,5 +1,6 @@
 import { Platform } from "../../../Platform";
-export default function waitForCoreChainLockedHeight(platform: Platform, expectedCoreHeight: number): Promise<{
+export declare function waitForCoreChainLockedHeight(this: Platform, expectedCoreHeight: number): Promise<{
     promise: Promise<any>;
     cancel: Function;
 }>;
+export default waitForCoreChainLockedHeight;

package/dist/src/SDK/SDK.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Client as _Client } from './Client';
 import { Platform as _Platform } from './Platform';
+import { StateTransitionBroadcastError } from '../errors/StateTransitionBroadcastError';
 import { Wallet as _Wallet, Account as _Account, DerivableKeyChain as _KeyChain } from '@dashevo/wallet-lib';
 export declare namespace SDK {
     let DAPIClient: any;
@@ -62,6 +63,7 @@ export declare namespace SDK {
                 UNKNOWN: string;
             };
             STORAGE: {
+                version: number;
                 autosaveIntervalTime: number;
             };
             TXIN_OUTPOINT_TXID_BYTES: number;
@@ -185,5 +187,12 @@ export declare namespace SDK {
             };
         };
     };
+    let PlatformProtocol: any;
+    let Essentials: {
+        Buffer: typeof Buffer;
+    };
+    let Errors: {
+        StateTransitionBroadcastError: typeof StateTransitionBroadcastError;
+    };
 }
 export { SDK as default };

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "dash",
-  "version": "3.22.10",
+  "version": "3.22.13",
   "description": "Dash library for JavaScript/TypeScript ecosystem (Wallet, DAPI, Primitives, BLS, ...)",
   "main": "build/src/index.js",
   "unpkg": "dist/dash.min.js",
+  "browser": "dist/dash.min.js",
   "types": "dist/src/index.d.ts",
   "scripts": {
     "start:dev": "nodemon --exec 'yarn run build && yarn run test:unit'",
-    "build": "yarn run build:ts",
-    "build:web": "yarn run build:ts && webpack --stats-error-details",
+    "start:ts": "tsc --watch",
+    "build": "yarn run build:ts && webpack --stats-error-details",
     "build:ts": "tsc",
     "lint": "",
     "test": "yarn run test:unit && yarn run test:functional && yarn run test:browsers",
     "test:browsers": "karma start ./karma.conf.js --single-run",
     "test:unit": "TS_NODE_COMPILER_OPTIONS={\"target\":\"es6\"} ts-mocha \"src/**/*.spec.ts\"",
     "test:functional": "yarn run build && mocha --recursive tests/functional/**/*.js",
-    "prepublishOnly": "yarn run build:web",
+    "prepublishOnly": "yarn run build",
     "prepare": "yarn run build"
   },
   "ultra": {
@@ -34,14 +35,14 @@
   },
   "homepage": "https://github.com/dashevo/DashJS#readme",
   "dependencies": {
-    "@dashevo/dapi-client": "~0.22.10",
-    "@dashevo/dashcore-lib": "~0.19.38",
-    "@dashevo/dashpay-contract": "~0.22.10",
-    "@dashevo/dpns-contract": "~0.22.10",
-    "@dashevo/dpp": "~0.22.10",
-    "@dashevo/grpc-common": "~0.22.10",
-    "@dashevo/masternode-reward-shares-contract": "~0.22.10",
-    "@dashevo/wallet-lib": "~7.22.10",
+    "@dashevo/dapi-client": "~0.22.13",
+    "@dashevo/dashcore-lib": "~0.19.39",
+    "@dashevo/dashpay-contract": "~0.22.13",
+    "@dashevo/dpns-contract": "~0.22.13",
+    "@dashevo/dpp": "~0.22.13",
+    "@dashevo/grpc-common": "~0.22.13",
+    "@dashevo/masternode-reward-shares-contract": "~0.22.13",
+    "@dashevo/wallet-lib": "~7.22.13",
     "bs58": "^4.0.1",
     "node-inspect-extracted": "^1.0.8"
   },
@@ -71,6 +72,7 @@
     "karma-mocha-reporter": "^2.2.5",
     "karma-webpack": "^5.0.0",
     "mocha": "^9.1.2",
+    "net": "^1.0.2",
     "nodemon": "^2.0.4",
     "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
@@ -81,6 +83,8 @@
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "string_decoder": "^1.3.0",
+    "terser-webpack-plugin": "^5.3.1",
+    "tls": "^0.0.1",
     "ts-loader": "^8.0.2",
     "ts-mocha": "^8.0.0",
     "ts-mock-imports": "^1.3.0",

package/src/SDK/Client/Platform/Platform.ts

@@ -4,6 +4,8 @@ import DashPlatformProtocol from "@dashevo/dpp";
 import Client from "../Client";
 import { IStateTransitionResult } from './IStateTransitionResult';
 
+import createAssetLockTransaction from "./createAssetLockTransaction";
+
 import broadcastDocument from "./methods/documents/broadcast";
 import createDocument from "./methods/documents/create";
 import getDocument from "./methods/documents/get";
@@ -16,6 +18,10 @@ import getContract from "./methods/contracts/get";
 import getIdentity from "./methods/identities/get";
 import registerIdentity from "./methods/identities/register";
 import topUpIdentity from "./methods/identities/topUp";
+import createIdentityCreateTransition from "./methods/identities/internal/createIdentityCreateTransition";
+import createIdentityTopUpTransition from "./methods/identities/internal/createIdnetityTopUpTransition";
+import createAssetLockProof from "./methods/identities/internal/createAssetLockProof";
+import waitForCoreChainLockedHeight from "./methods/identities/internal/waitForCoreChainLockedHeight";
 
 import registerName from "./methods/names/register";
 import resolveName from "./methods/names/resolve";
@@ -65,6 +71,13 @@ interface Identities {
     get: Function,
     register: Function,
     topUp: Function,
+    utils: {
+        createAssetLockTransaction: Function
+        createAssetLockProof: Function
+        createIdentityCreateTransition: Function
+        createIdentityTopUpTransition: Function
+        waitForCoreChainLockedHeight: Function
+    }
 }
 
 interface DataContracts {
@@ -144,6 +157,13 @@ export class Platform {
             register: registerIdentity.bind(this),
             get: getIdentity.bind(this),
             topUp: topUpIdentity.bind(this),
+            utils: {
+                createAssetLockProof: createAssetLockProof.bind(this),
+                createAssetLockTransaction: createAssetLockTransaction.bind(this),
+                createIdentityCreateTransition: createIdentityCreateTransition.bind(this),
+                createIdentityTopUpTransition: createIdentityTopUpTransition.bind(this),
+                waitForCoreChainLockedHeight: waitForCoreChainLockedHeight.bind(this),
+            }
         };
 
         this.client = options.client;
@@ -172,3 +192,4 @@ export class Platform {
         await this.dpp.initialize();
     }
 }
+

package/src/SDK/Client/Platform/createAssetLockTransaction.ts

@@ -7,12 +7,13 @@ const ASSET_LOCK_OUTPUT_INDEX = 0;
 
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {number} fundingAmount - amount of dash to fund the identity's credits
  * @return {Promise<{transaction: Transaction, privateKey: PrivateKey}>} - transaction and one time private key
  * that can be used to sign registration/top-up state transition
  */
-export default async function createAssetLockTransaction(platform : Platform, fundingAmount): Promise<{ transaction: Transaction, privateKey: PrivateKey, outputIndex: number }> {
+export async function createAssetLockTransaction(this : Platform, fundingAmount): Promise<{ transaction: Transaction, privateKey: PrivateKey, outputIndex: number }> {
+    const platform = this;
     const account = await platform.client.getWalletAccount();
 
     // @ts-ignore
@@ -61,3 +62,5 @@ export default async function createAssetLockTransaction(platform : Platform, fu
         outputIndex: ASSET_LOCK_OUTPUT_INDEX,
     };
 }
+
+export default createAssetLockTransaction;

package/src/SDK/Client/Platform/methods/identities/internal/createAssetLockProof.ts

@@ -7,13 +7,14 @@ const { InstantLockTimeoutError, TxMetadataTimeoutError } = require('@dashevo/wa
 
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {Transaction} assetLockTransaction
  * @param {number} outputIndex - index of the funding output in the asset lock transaction
  * @return {AssetLockProof} - asset lock proof to be used in the state transition
  * that can be used to sign registration/top-up state transition
  */
-export default async function createAssetLockProof(platform : Platform, assetLockTransaction: Transaction, outputIndex: number): Promise<any> {
+export async function createAssetLockProof(this : Platform, assetLockTransaction: Transaction, outputIndex: number): Promise<any> {
+    const platform = this;
     await platform.initialize();
 
     const account = await platform.client.getWalletAccount();
@@ -119,3 +120,5 @@ export default async function createAssetLockProof(platform : Platform, assetLoc
       })
     ]);
 }
+
+export default createAssetLockProof;

package/src/SDK/Client/Platform/methods/identities/internal/createIdentityCreateTransition.ts

@@ -4,13 +4,14 @@ import IdentityPublicKey from "@dashevo/dpp/lib/identity/IdentityPublicKey"
 
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {AssetLockProof} assetLockProof - asset lock transaction proof for the identity create transition
  * @param {PrivateKey} assetLockPrivateKey - private key used in asset lock
  * @return {{identity: Identity, identityCreateTransition: IdentityCreateTransition}} - identity, state transition and index of the key used to create it
  * that can be used to sign registration/top-up state transition
  */
-export default async function createIdentityCreateTransition(platform : Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey): Promise<{ identity: any, identityCreateTransition: any, identityIndex: number }> {
+export async function createIdentityCreateTransition(this : Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey): Promise<{ identity: any, identityCreateTransition: any, identityIndex: number }> {
+    const platform = this;
     await platform.initialize();
 
     const account = await platform.client.getWalletAccount();
@@ -45,3 +46,5 @@ export default async function createIdentityCreateTransition(platform : Platform
 
     return { identity, identityCreateTransition, identityIndex };
 }
+
+export default createIdentityCreateTransition;

package/src/SDK/Client/Platform/methods/identities/internal/createIdnetityTopUpTransition.ts

@@ -4,14 +4,15 @@ import IdentityPublicKey from "@dashevo/dpp/lib/identity/IdentityPublicKey"
 
 /**
  * Creates a funding transaction for the platform identity and returns one-time key to sign the state transition
- * @param {Platform} platform
+ * @param {Platform} this
  * @param {AssetLockProof} assetLockProof - asset lock transaction proof for the identity create transition
  * @param {PrivateKey} assetLockPrivateKey - private key used in asset lock
  * @param {string|Buffer|Identifier} identityId
  * @return {{identity: Identity, identityCreateTransition: IdentityCreateTransition}} - identity, state transition and index of the key used to create it
  * that can be used to sign registration/top-up state transition
  */
-export default async function createIdentityTopUpTransition(platform : Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey, identityId: any): Promise<any> {
+export async function createIdentityTopUpTransition(this : Platform, assetLockProof: any, assetLockPrivateKey: PrivateKey, identityId: any): Promise<any> {
+    const platform = this;
     await platform.initialize();
 
     const { dpp } = platform;
@@ -31,3 +32,5 @@ export default async function createIdentityTopUpTransition(platform : Platform,
 
     return identityTopUpTransition;
 }
+
+export default createIdentityTopUpTransition;

package/src/SDK/Client/Platform/methods/identities/internal/waitForCoreChainLockedHeight.ts

@@ -2,10 +2,11 @@ import { Platform } from "../../../Platform";
 
 import { ownerId as dpnsOwnerId } from "@dashevo/dpns-contract/lib/systemIds";
 
-export default async function waitForCoreChainLockedHeight(
-  platform : Platform,
+export async function waitForCoreChainLockedHeight(
+  this : Platform,
   expectedCoreHeight : number,
 ): Promise<{ promise: Promise<any>, cancel: Function }> {
+  const platform = this;
   await platform.initialize();
 
   const interval = 5000;
@@ -64,6 +65,6 @@ export default async function waitForCoreChainLockedHeight(
   }
 }
 
-
+export default waitForCoreChainLockedHeight;
 
 

package/src/SDK/Client/Platform/methods/identities/register.ts

@@ -1,7 +1,4 @@
 import { Platform } from "../../Platform";
-import createAssetLockTransaction from "../../createAssetLockTransaction";
-import createIdentityCreateTransition from "./internal/createIdentityCreateTransition";
-import createAssetLockProof from "./internal/createAssetLockProof";
 import broadcastStateTransition from "../../broadcastStateTransition";
 
 /**
@@ -24,15 +21,17 @@ export default async function register(
         transaction: assetLockTransaction,
         privateKey: assetLockPrivateKey,
         outputIndex: assetLockOutputIndex
-    } = await createAssetLockTransaction(this, fundingAmount);
+    } = await this.identities.utils.createAssetLockTransaction(fundingAmount);
 
     // Broadcast Asset Lock transaction
     await account.broadcastTransaction(assetLockTransaction);
-    const assetLockProof = await createAssetLockProof(this, assetLockTransaction, assetLockOutputIndex);
 
-    const { identity, identityCreateTransition, identityIndex } = await createIdentityCreateTransition(
-        this, assetLockProof, assetLockPrivateKey
-    );
+    const assetLockProof = await this.identities.utils
+      .createAssetLockProof(assetLockTransaction, assetLockOutputIndex);
+
+    const { identity, identityCreateTransition, identityIndex } = await this.identities.utils
+      .createIdentityCreateTransition(assetLockProof, assetLockPrivateKey);
+
     await broadcastStateTransition(this, identityCreateTransition);
 
     // If state transition was broadcast without any errors, import identity to the account

package/src/SDK/Client/Platform/methods/identities/topUp.ts

@@ -1,10 +1,6 @@
-// @ts-ignore
 import Identifier from "@dashevo/dpp/lib/Identifier";
 import {Platform} from "../../Platform";
 
-import createAssetLockTransaction from "../../createAssetLockTransaction";
-import createAssetLockProof from "./internal/createAssetLockProof";
-import createIdentityTopUpTransition from "./internal/createIdnetityTopUpTransition";
 import broadcastStateTransition from "../../broadcastStateTransition";
 
 /**
@@ -28,15 +24,16 @@ export async function topUp(this: Platform, identityId: Identifier | string, amo
         transaction: assetLockTransaction,
         privateKey: assetLockPrivateKey,
         outputIndex: assetLockOutputIndex
-    } = await createAssetLockTransaction(this, amount);
+    } = await this.identities.utils.createAssetLockTransaction(amount);
 
     // Broadcast Asset Lock transaction
     await account.broadcastTransaction(assetLockTransaction);
     // Create a proof for the asset lock transaction
-    const assetLockProof = await createAssetLockProof(this, assetLockTransaction, assetLockOutputIndex);
+    const assetLockProof = await this.identities.utils
+      .createAssetLockProof(assetLockTransaction, assetLockOutputIndex);
 
-    // @ts-ignore
-    const identityTopUpTransition = await createIdentityTopUpTransition(this, assetLockProof, assetLockPrivateKey, identityId);
+    const identityTopUpTransition = await this.identities.utils
+      .createIdentityTopUpTransition(assetLockProof, assetLockPrivateKey, identityId);
 
     // Broadcast ST
     await broadcastStateTransition(this, identityTopUpTransition);

package/src/SDK/SDK.ts

@@ -3,34 +3,47 @@ import { Core as _Core } from './Core';
 import { Platform as _Platform } from './Platform';
 import { default as _DAPIClient } from '@dashevo/dapi-client';
 
+import { StateTransitionBroadcastError } from '../errors/StateTransitionBroadcastError'
+
 import {
-    Wallet as _Wallet,
-    Account as _Account,
-    DerivableKeyChain as _KeyChain,
-    CONSTANTS as _WalletLibCONSTANTS,
-    EVENTS as _WalletLibEVENTS,
-    utils as _WalletLibUtils,
-    plugins as _WalletLibPlugins
+  Wallet as _Wallet,
+  Account as _Account,
+  DerivableKeyChain as _KeyChain,
+  CONSTANTS as _WalletLibCONSTANTS,
+  EVENTS as _WalletLibEVENTS,
+  utils as _WalletLibUtils,
+  plugins as _WalletLibPlugins
 } from '@dashevo/wallet-lib';
 
 export namespace SDK {
-    export let DAPIClient = _DAPIClient;
-    export let Client = _Client;
+  export let DAPIClient = _DAPIClient;
+  export let Client = _Client;
+
+  export let Core = _Core;
+  // TODO: consider marking as DEPRECATED and use PlatformProtocol below instead
+  export let Platform = _Platform;
+
+  // Wallet-lib primitives
+  export let Wallet = _Wallet;
+  export let Account = _Account;
+  export let KeyChain = _KeyChain;
 
-    export let Core = _Core;
-    export let Platform = _Platform;
+  // TODO: consider merging into Wallet above and mark as DEPRECATED
+  export let WalletLib = {
+    CONSTANTS: _WalletLibCONSTANTS,
+    EVENTS: _WalletLibEVENTS,
+    plugins: _WalletLibPlugins,
+    utils: _WalletLibUtils,
+  }
 
-    // Wallet-lib primitives
-    export let Wallet = _Wallet;
-    export let Account = _Account;
-    export let KeyChain = _KeyChain;
+  export let PlatformProtocol = Platform.DashPlatformProtocol;
 
-    export let WalletLib = {
-        CONSTANTS: _WalletLibCONSTANTS,
-        EVENTS: _WalletLibEVENTS,
-        plugins: _WalletLibPlugins,
-        utils: _WalletLibUtils,
-    }
+  export let Essentials = {
+    Buffer,
+  }
 
+  export let Errors = {
+    StateTransitionBroadcastError
+  }
 }
 export { SDK as default };

package/webpack.base.config.js

@@ -1,8 +1,10 @@
 const path = require('path');
 const webpack = require('webpack');
+const TerserPlugin = require("terser-webpack-plugin");
 
 const baseConfig = {
   entry: './src/index.ts',
+  devtool: 'eval',
   module: {
     rules: [
       {
@@ -12,6 +14,14 @@ const baseConfig = {
       },
     ],
   },
+  optimization: {
+    minimize: true,
+    minimizer: [new TerserPlugin({
+      terserOptions: {
+        keep_classnames: true // fixes empty string in `object.constructor.name`
+      }
+    })],
+  },
   resolve: {
     extensions: ['.ts', '.js', '.json'],
     fallback: {
@@ -29,6 +39,10 @@ const baseConfig = {
       zlib: require.resolve('browserify-zlib'),
       events: require.resolve('events/'),
       string_decoder: require.resolve('string_decoder/'),
+      tls: require.resolve('tls/'),
+      net: require.resolve('net/'),
+      // Browser build have to use native WebSocket
+      ws: require.resolve('./build-utils/ws'),
     },
   },
   plugins: [

package/webpack.config.js

@@ -4,11 +4,15 @@ const webpackBaseConfig = require("./webpack.base.config");
 const webConfig =  {
   ...webpackBaseConfig,
   entry: './build/src/index.js',
+  devtool: 'source-map',
   mode: 'production',
+  target: 'web',
   output: {
     path: path.resolve(__dirname, 'dist'),
-    libraryTarget: 'umd',
-    library: 'Dash',
+    library: {
+      name: 'Dash',
+      type: 'umd'
+    },
     filename: 'dash.min.js',
     // fixes ReferenceError: window is not defined
     globalObject: "(typeof self !== 'undefined' ? self : this)"