hive-stream 2.0.2 → 2.0.5

package/tests/contracts/lotto.contract.spec.ts

@@ -0,0 +1,324 @@
+import { sleep } from '@hiveio/dhive/lib/utils';
+
+import { TimeAction } from './../../src/actions';
+import { LottoContract } from './../../src/contracts/lotto.contract';
+import { Streamer } from '../../src/streamer';
+
+import fiftyValidEntrants from './entrants.json';
+
+describe('Lotto Contract', () => {
+    let sut: Streamer;
+    let contract: LottoContract;
+
+    beforeEach(async () => {
+        sut = new Streamer({ ACTIVE_KEY: '' });
+        contract = new LottoContract();
+
+        // @ts-ignore
+        sut.adapter = {
+            db: jest.fn(),
+            create: jest.fn(),
+            destroy: jest.fn(),
+            loadActions: jest.fn(),
+            loadState: jest.fn(),
+            saveState: jest.fn(),
+            processBlock: jest.fn(),
+            processOperation: jest.fn(),
+            processTransfer: jest.fn(),
+            processCustomJson: jest.fn(),
+            find: jest.fn(),
+            findOne: jest.fn(),
+            insert: jest.fn(),
+            replace: jest.fn()
+        };
+
+        jest.restoreAllMocks();
+
+        await sut.start();
+    });
+
+    afterEach(async () => {
+        await sut.stop();
+    });
+
+    test('Registers the lotto contract', () => {
+        sut.registerContract('testlotto', contract);
+
+        const findContract = sut['contracts'].find(c => c.name === 'testlotto');
+
+        expect(findContract).not.toBeUndefined();
+    });
+
+    test('User enters the lotto, existing draw found', async () => {
+        try {
+            sut.registerContract('testlotto', contract);
+
+            contract['_instance'] = sut;
+
+            const mockEntry = { startDate: new Date(), type: 'hourly', status: 'active', entries: [] };
+
+            jest.spyOn(sut['adapter'], 'find').mockResolvedValue(mockEntry);
+    
+            jest.spyOn(contract, 'buy');
+            jest.spyOn(contract as any, 'getBalance').mockResolvedValue(2000);
+    
+            jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+            jest.spyOn(sut, 'verifyTransfer').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokens').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokensMultiple').mockResolvedValue(true as any);
+    
+            const memo = JSON.stringify({
+                hivePayload: {
+                    id: 'hivestream',
+                    name: 'testlotto',
+                    action: 'buy',
+                    payload: {
+                        type: 'hourly'
+                    }
+                }
+            });
+    
+            sut.processOperation(['transfer', { from: 'testuser', amount: '10.000 HIVE', memo }], 778782, 'dfjfsdfsdfsd34hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
+    
+            await sleep(100);
+    
+            expect(contract.buy).toBeCalled();
+        } catch (e) {
+            throw e;
+        }
+    });
+
+    test('User enters the lotto, but they have hit the entry limit', async () => {
+        try {
+            sut.registerContract('testlotto', contract);
+
+            contract['_instance'] = sut;
+
+            const entries = [];
+
+            for (const entrant of fiftyValidEntrants) {
+                // @ts-ignore
+                entries.push({
+                    account: entrant.from,
+                    date: new Date()
+                });
+            }
+
+            const mockData = { startDate: new Date(), type: 'hourly', status: 'active', entries };
+            jest.spyOn(sut['adapter'], 'find').mockResolvedValue(mockData);
+    
+            jest.spyOn(contract, 'buy');
+            jest.spyOn(contract as any, 'getBalance').mockResolvedValue(2000);
+    
+            jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+            jest.spyOn(sut, 'verifyTransfer').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokens').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokensMultiple').mockResolvedValue(true as any);
+            jest.spyOn(contract, 'getPreviousUserTicketsForCurrentDrawType').mockResolvedValue(3);
+    
+            const memo = JSON.stringify({
+                hivePayload: {
+                    id: 'hivestream',
+                    name: 'testlotto',
+                    action: 'buy',
+                    payload: {
+                        type: 'hourly'
+                    }
+                }
+            });
+    
+            sut.processOperation(['transfer', { from: 'beggars', amount: '10.000 HIVE', memo }], 778782, 'dfjfsdfsdfsd34hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
+    
+            await sleep(100);
+    
+            expect(sut.transferHiveTokens).toBeCalledWith('beggars', 'beggars', '10.000', 'HIVE', '[Refund] You have exceeded the allowed number of entries');
+        } catch (e) {
+            throw e;
+        }
+    });
+
+    test('Draw the hourly lottery', async () => {
+        try {
+            sut.registerContract('testlotto', contract);
+
+            contract['_instance'] = sut;
+            
+            const entries = [];
+
+            for (const entrant of fiftyValidEntrants) {
+                // @ts-ignore
+                entries.push({
+                    account: entrant.from,
+                    date: new Date()
+                });
+            }
+
+            const mockInsertedData = { startDate: new Date(), type: 'hourly', status: 'active', entries };
+            jest.spyOn(sut['adapter'], 'find').mockResolvedValue(mockInsertedData);
+    
+            jest.spyOn(contract, 'buy');
+            jest.spyOn(contract as any, 'getBalance').mockResolvedValue(2000);
+    
+            jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+            jest.spyOn(sut, 'verifyTransfer').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokens').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokensMultiple').mockResolvedValue(true as any);
+    
+            const drawn = await contract.drawHourlyLottery();
+
+            if (drawn) {
+                expect(drawn).toHaveLength(3);
+                expect(sut.transferHiveTokensMultiple).toBeCalledTimes(2);
+                expect(sut.transferHiveTokensMultiple).toBeCalledWith('beggars', expect.any(Array), '164.667', 'HIVE', expect.stringContaining('Congratulations you won the hourly lottery. You won 164.667 HIVE'));
+                expect(sut.transferHiveTokensMultiple).toBeCalledWith(expect.any(String), expect.any(Array), '0.001', 'HIVE', expect.stringContaining('Sorry, you didn\'t win the hourly draw. Winners:'));
+            }
+        } catch (e) {
+            throw e;
+        }
+    });
+
+    test('Draw the hourly lottery, but not enough entrants, so we refund', async () => {
+        try {
+            sut.registerContract('testlotto', contract);
+
+            contract['_instance'] = sut;
+            
+            const entries = [];
+            const reducedEntries = fiftyValidEntrants.slice(0, 2);
+
+            for (const entrant of reducedEntries) {
+                // @ts-ignore
+                entries.push({
+                    account: entrant.from,
+                    date: new Date()
+                });
+            }
+
+            const mockResponse = [{ startDate: new Date(), type: 'hourly', status: 'active', entries }];
+            jest.spyOn(sut['adapter'], 'find').mockResolvedValue(mockResponse);
+    
+            jest.spyOn(contract, 'buy');
+            jest.spyOn(contract as any, 'getBalance').mockResolvedValue(2000);
+    
+            jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+            jest.spyOn(sut, 'verifyTransfer').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokens').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokensMultiple').mockResolvedValue(true as any);
+    
+            const drawn = await contract.drawHourlyLottery();
+
+            expect(sut.transferHiveTokensMultiple).toBeCalledTimes(1);
+        } catch (e) {
+            throw e;
+        }
+    });
+
+    test('Draw the hourly lottery, balance cannot afford to pay out winnings', async () => {
+        try {
+            sut.registerContract('testlotto', contract);
+
+            contract['_instance'] = sut;
+            
+            const entries = [];
+
+            for (const entrant of fiftyValidEntrants) {
+                // @ts-ignore
+                entries.push({
+                    account: entrant.from,
+                    date: new Date()
+                });
+            }
+
+            const mockData = [{ startDate: new Date(), type: 'hourly', status: 'active', entries }];
+            jest.spyOn(sut['adapter'], 'find').mockResolvedValue(mockData);
+    
+            jest.spyOn(contract, 'buy');
+            jest.spyOn(contract as any, 'getBalance').mockResolvedValue(10);
+    
+            jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+            jest.spyOn(sut, 'verifyTransfer').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokens').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokensMultiple').mockResolvedValue(true as any);
+
+            expect(contract.drawHourlyLottery()).rejects.toEqual(new Error('Balance is less than amount to pay out'));
+        } catch (e) {
+            throw e;
+        }
+    });
+
+    test('Draw the daily lottery', async () => {
+        try {
+            sut.registerContract('testlotto', contract);
+
+            contract['_instance'] = sut;
+            
+            const entries = [];
+            const entrants = [...fiftyValidEntrants, ...fiftyValidEntrants];
+
+            for (const entrant of entrants) {
+                // @ts-ignore
+                entries.push({
+                    account: entrant.from,
+                    date: new Date()
+                });
+            }
+
+            const mockData = [{ startDate: new Date(), type: 'daily', status: 'active', entries }];
+            jest.spyOn(sut['adapter'], 'find').mockResolvedValue(mockData);
+    
+            jest.spyOn(contract, 'buy');
+            jest.spyOn(contract as any, 'getBalance').mockResolvedValue(2000);
+    
+            jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+            jest.spyOn(sut, 'verifyTransfer').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokens').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokensMultiple').mockResolvedValue(true as any);
+    
+            const drawn = await contract.drawDailyLottery();
+
+            expect(drawn).toHaveLength(10);
+            expect(sut.transferHiveTokensMultiple).toBeCalledWith('beggars', expect.any(Array), '98.800', 'HIVE', 'Congratulations you won the daily lottery. You won 98.800 HIVE');
+        } catch (e) {
+            throw e;
+        }
+    });
+
+    test('User attempts to enter lotto with invalid currency, refund them', async () => {
+        try {
+            sut.registerContract('testlotto', contract);
+
+            contract['_instance'] = sut;
+
+            const mockData = { startDate: new Date(), type: 'hourly', status: 'active', entries: [] };
+            jest.spyOn(sut['adapter'], 'find').mockResolvedValue(mockData);
+    
+            jest.spyOn(contract, 'buy');
+            jest.spyOn(contract as any, 'getBalance').mockResolvedValue(2000);
+    
+            jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+            jest.spyOn(sut, 'verifyTransfer').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokens').mockResolvedValue(true as any);
+            jest.spyOn(sut, 'transferHiveTokensMultiple').mockResolvedValue(true as any);
+    
+            const memo = JSON.stringify({
+                hivePayload: {
+                    id: 'hivestream',
+                    name: 'testlotto',
+                    action: 'buy',
+                    payload: {
+                        type: 'hourly'
+                    }
+                }
+            });
+    
+            sut.processOperation(['transfer', { from: 'testuser', amount: '10.000 HBD', memo }], 778782, 'dfjfsdfsdfsd34hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
+    
+            await sleep(100);
+    
+            expect(sut.transferHiveTokens).toBeCalledWith('beggars', 'testuser', '10.000', 'HBD', '[Refund] You sent an invalid currency.');
+        } catch (e) {
+            throw e;
+        }
+    });
+
+});

package/tests/setup.ts

@@ -0,0 +1,19 @@
+import { GlobalWithFetchMock } from 'jest-fetch-mock';
+
+// (global as any).console = {
+//     log: jest.fn(), // console.log are ignored in tests
+
+//     // Keep native behaviour for other methods, use those to print out things in your own tests, not `console.log`
+//     error: console.error,
+//     warn: console.warn,
+//     info: console.info,
+//     debug: console.debug,
+// };
+
+const customGlobal: GlobalWithFetchMock = global as unknown as GlobalWithFetchMock;
+customGlobal.fetch = require('jest-fetch-mock');
+customGlobal.fetchMock = customGlobal.fetch;
+
+process.on('unhandledRejection', (error) => {
+  throw error; // Or whatever you like...
+});

package/tests/streamer.spec.ts

@@ -0,0 +1,152 @@
+import { TimeAction } from '../src/actions';
+import { Streamer } from '../src/streamer';
+
+describe('Streamer', () => {
+    let sut: Streamer;
+
+    beforeEach(() => {
+        sut = new Streamer({
+            JSON_ID: 'testing'
+        });
+    });
+
+    afterEach(() => {
+        sut.stop();
+    });
+
+    describe('Adapters', () => {
+        test('Registers adapter and calls the create lifecycle method', () => {
+            const adapter = {
+                create: jest.fn().mockResolvedValue(true),
+                destroy: jest.fn()
+            };
+
+            sut.registerAdapter(adapter);
+
+            expect(adapter.create).toBeCalled();
+        });
+    });
+
+    describe('Actions', () => {
+        test('Registers a new action', async () => {
+            const adapter = {
+                create: jest.fn().mockResolvedValue(true),
+                destroy: jest.fn(),
+                loadActions: jest.fn().mockResolvedValue([])
+            };
+
+            sut.registerAdapter(adapter);
+
+            const action = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
+
+            await sut.registerAction(action);
+
+            const foundAction = sut['actions'].find(a => a.id === 'testoneminute');
+
+            expect(foundAction).not.toBeUndefined();
+        });
+
+        test('Does not allow duplicate actions of the same id', async () => {
+            const adapter = {
+                create: jest.fn().mockResolvedValue(true),
+                destroy: jest.fn(),
+                loadActions: jest.fn().mockResolvedValue([])
+            };
+
+            sut.registerAdapter(adapter);
+
+            const action = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
+            const action2 = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
+
+            await sut.registerAction(action);
+            await sut.registerAction(action2);
+
+            expect(sut['actions'].length).toStrictEqual(1);
+        });
+
+        test('Registers actions loaded from adapter loadActions call', async () => {
+            const adapter = {
+                create: jest.fn().mockResolvedValue(true),
+                destroy: jest.fn(),
+                loadActions: jest.fn().mockResolvedValue([new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod')])
+            };
+
+            sut.registerAdapter(adapter);
+
+            const action = new TimeAction('1h', 'testonehour', 'testcontract', 'testmethod');
+
+            await sut.registerAction(action);
+
+            const foundAction = sut['actions'].find(a => a.id === 'testoneminute');
+
+            expect(foundAction).not.toBeUndefined();
+        });
+    });
+
+    describe('Contracts', () => {
+        test('Should register a new contract', () => {
+            const contract = {
+                myMethod: jest.fn()
+            };
+
+            sut.registerContract('testcontract', contract);
+
+            expect(contract['_instance']).toBeInstanceOf(Streamer);
+            expect(sut['contracts'].length).toStrictEqual(1);
+        });
+
+        test('Should register a new contract and call its create method', () => {
+            const contract = {
+                create: jest.fn(),
+                myMethod: jest.fn()
+            };
+
+            sut.registerContract('testcontract', contract);
+
+            expect(contract.create).toBeCalled();
+            expect(contract['_instance']).toBeInstanceOf(Streamer);
+            expect(sut['contracts'].length).toStrictEqual(1);
+        });
+
+        test('Should unregister a registered contract', () => {
+            const contract = {
+                myMethod: jest.fn()
+            };
+
+            sut.registerContract('testcontract', contract);
+            sut.unregisterContract('testcontract');
+
+            expect(sut['contracts'].length).toStrictEqual(0);
+        });
+
+        test('Should unregister a registered contract and call its destroy method', () => {
+            const contract = {
+                destroy: jest.fn(),
+                myMethod: jest.fn()
+            };
+
+            sut.registerContract('testcontract', contract);
+            sut.unregisterContract('testcontract');
+
+            expect(contract.destroy).toBeCalled();
+            expect(sut['contracts'].length).toStrictEqual(0);
+        });
+    });
+
+    test('Start method should resume from previous block number', async () => {
+        const adapter = {
+            loadState: jest.fn().mockResolvedValue({ lastBlockNumber: 509992 })
+        };
+
+        sut.registerAdapter(adapter);
+
+        jest.spyOn(sut as any, 'getBlock').mockImplementation(() => true);
+        jest.spyOn(sut as any, 'getLatestBlock').mockImplementation(() => true);
+
+        await sut.start();
+
+        expect(sut['lastBlockNumber']).toStrictEqual(509992);
+
+        sut.stop();
+    });
+});

package/tests/utils.spec.ts

@@ -0,0 +1,95 @@
+import { Utils } from './../src/utils';
+
+describe('Utils', () => {
+
+    describe('Round Precision', () => {
+        test('Properly rounds precision of number to 3 places', () => {
+            const value = 99.299223;
+    
+            expect(Utils.roundPrecision(value, 3)).toStrictEqual(99.299);
+        });
+    
+        test('Properly rounds precision of number up and to 3 places', () => {
+            const value = 99.2966;
+    
+            expect(Utils.roundPrecision(value, 3)).toStrictEqual(99.297);
+        });
+    
+        test('Invalid numeric values passed', () => {
+            expect(Utils.roundPrecision('dasd', 3)).toBeNaN();
+        });
+    });
+
+    test('Should generate two deterministic numbers', () => {
+        // Should generate a deterministic random number
+        expect(Utils.randomNumber('dasdasdas', '2312fsdfsdfsdf', 'kfjlksdjflksdjf999')).toStrictEqual(26);
+
+        expect(Utils.randomNumber('fdfsdfsdfsdfsf', '2312fsdfsdfsdf', 'kfjlksdjflksdjf999')).toStrictEqual(43);
+    });
+
+    test('Should shuffle array in a non-deterministic way', () => {
+        const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+        const arrayCloned = [...array];
+        
+        Utils.shuffle(array);
+
+        expect(array).not.toMatchObject(arrayCloned);
+    });
+
+    describe('Generate String', () => {
+        test('Generates a memo 6 characters in length', () => {
+            expect(Utils.randomString(6)).toHaveLength(6);
+        });
+    
+        test('Generates a memo using default 12 character length', () => {
+            expect(Utils.randomString()).toHaveLength(12);
+        });
+    });
+
+    describe('Random Range', () => {
+        test('Should generate a random number between 0 and 10', () => {
+            expect(Utils.randomRange(0, 10)).toBeLessThanOrEqual(10);
+        });
+
+        test('Should generate the number 10', () => {
+            expect(Utils.randomRange(10, 10)).toStrictEqual(10);
+        });
+
+        test('Only pass min and not max', () => {
+            expect(Utils.randomRange(0)).toBeLessThanOrEqual(2000);
+        });
+
+        test('Pass non numeric values to random range', () => {
+            expect(Utils.randomRange('dd' as any, 'asjj' as any)).toBeNaN();
+        });
+    });
+
+    describe('Convert Hive Amount', () => {
+        test('Converts amount', async () => {
+            const amount = 25;
+            const fiatSymbol = 'USD';
+            const hiveSymbol = 'HIVE';
+
+            (fetch as any)
+                .once(JSON.stringify({'success':true,'message':'','result':{'Bid':6905.98900000,'Ask':6925.65900000,'Last':6925.66500000}}))
+                .once(JSON.stringify({'success':true,'message':'','result':{'Bid':0.00003083,'Ask':0.00003169,'Last':0.00003192}}))
+                .once(JSON.stringify({'success':true,'message':'','result':{'Bid':0.00010800,'Ask':0.00010900,'Last':0.00010800}}))
+                .once(JSON.stringify({'rates':{'CAD':1.4383752203,'HKD':7.7558193453,'ISK':140.4989335064,'PHP':51.4003524066,'DKK':6.9281276083,'HUF':326.7458035797,'CZK':25.6283038116,'GBP':0.862190485,'RON':4.4960586108,'SEK':10.2675507744,'IDR':16574.9976815358,'INR':76.1620142817,'BRL':5.0683483261,'RUB':79.8293610313,'HRK':7.053695632,'JPY':110.4609106928,'THB':32.8646944264,'CHF':0.982101456,'EUR':0.9273856997,'MYR':4.4449596587,'BGN':1.8137809515,'TRY':6.5859222851,'CNY':7.0838356673,'NOK':11.3667810442,'NZD':1.7563757767,'ZAR':17.6333116943,'USD':1.0,'MXN':24.6805156264,'SGD':1.4601687842,'AUD':1.7236390615,'ILS':3.6698506909,'KRW':1256.7003616804,'PLN':4.2711675786},'base':'USD','date':'2020-03-23'}));
+    
+            const value = await Utils.convertHiveAmount(amount, fiatSymbol, hiveSymbol);
+            
+            expect(fetch).toBeCalledWith(`https://api.bittrex.com/v3/markets/USD-BTC/ticker`);
+            expect(fetch).toBeCalledWith(`https://api.bittrex.com/v3/markets/HIVE-BTC/ticker`);
+            expect(fetch).toBeCalledWith(`https://api.bittrex.com/v3/markets/HBD-BTC/ticker`);
+
+            expect(value).toStrictEqual(113.088);
+        });
+    });
+
+    describe('Get transfer URL', () => {
+        test('Gets a transfer URL string', () => {
+            expect(Utils.getTransferUrl('beggars', 'TEST123', '10.000 HIVE', 'http://localhost:5001')).toStrictEqual(`https://hivesigner.com/sign/transfer?to=beggars&memo=TEST123&amount=10.000 HIVE&redirect_uri=http://localhost:5001`);
+        });
+    });
+
+});

package/tsconfig.build.json

@@ -1,20 +1,23 @@
-{
-    "compilerOptions": {
-        "module": "commonjs",
-        "esModuleInterop": true,
-        "target": "es6",
-        "allowSyntheticDefaultImports": true,
-        "moduleResolution": "node",
-        "declaration": true,
-        "sourceMap": true,
-        "outDir": "dist",
-        "baseUrl": ".",
-        "paths": {
-            "*": [
-                "node_modules/*",
-                "src/types/*"
-            ]
-        }
-    },
-    "exclude": ["node_modules", ".vscode", "dist", "test"]
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "esModuleInterop": true,
+        "target": "esnext",
+        "allowSyntheticDefaultImports": true,
+        "emitDecoratorMetadata": true,
+        "experimentalDecorators": true,
+        "resolveJsonModule": true,
+        "moduleResolution": "node",
+        "declaration": true,
+        "sourceMap": true,
+        "outDir": "dist",
+        "baseUrl": ".",
+        "paths": {
+            "*": [
+                "node_modules/*",
+                "src/types/*"
+            ]
+        }
+    },
+    "exclude": ["node_modules", ".vscode", "dist", "tests"]
 }

package/tslint.json

@@ -1,21 +1,21 @@
-{
-    "extends": [
-      "tslint:recommended"   
-    ],
-    "jsRules": {},
-    "rules": {
-        "quotemark": [true, "single"],
-        "ordered-imports": false,
-        "interface-name": false,
-        "object-literal-sort-keys": false,
-        "eofline": false,
-        "no-console": false,
-        "member-ordering": false,
-        "max-line-length": false,
-        "trailing-comma": false,
-        "no-string-literal": false,
-        "arrow-parens": false,
-        "object-literal-key-quotes": false
-    },
-    "rulesDirectory": []
+{
+    "extends": [
+      "tslint:recommended"   
+    ],
+    "jsRules": {},
+    "rules": {
+        "quotemark": [true, "single"],
+        "ordered-imports": false,
+        "interface-name": false,
+        "object-literal-sort-keys": false,
+        "eofline": false,
+        "no-console": false,
+        "member-ordering": false,
+        "max-line-length": false,
+        "trailing-comma": false,
+        "no-string-literal": false,
+        "arrow-parens": false,
+        "object-literal-key-quotes": false
+    },
+    "rulesDirectory": []
   }