hive-stream 3.0.0 → 3.0.2

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

@@ -1,10 +1,8 @@
-import { CoinflipContract } from '../../src/contracts/coinflip.contract';
+import { createCoinflipContract } from '../../src/contracts/coinflip.contract';
 import { sleep } from '@hiveio/dhive/lib/utils';
 import { Streamer } from '../../src/streamer';
 import { createMockAdapter } from '../helpers/mock-adapter';
-import BigNumber from 'bignumber.js';
 
-// Mock uuid module at the top level
 jest.mock('uuid', () => ({
     v4: jest.fn()
 }));
@@ -13,13 +11,12 @@ import { v4 as uuidv4 } from 'uuid';
 
 describe('Coinflip Contract', () => {
     let sut: Streamer;
-    let contract: CoinflipContract;
+    let contract: ReturnType<typeof createCoinflipContract>;
 
     beforeEach(async () => {
         sut = new Streamer();
         await sut.registerAdapter(createMockAdapter());
-        
-        contract = new CoinflipContract();
+        contract = createCoinflipContract();
 
         // @ts-ignore
         sut.api = jest.fn();
@@ -27,40 +24,29 @@ describe('Coinflip Contract', () => {
 
     afterEach(async () => {
         await sut.stop();
-    });
-
-    afterEach(() => {
         jest.restoreAllMocks();
     });
 
-    afterAll(() => {
-        jest.resetAllMocks();
-    });
-
-    test('Registers the contract', () => {
-        sut.registerContract('coinflip', contract);
+    test('Registers the contract', async () => {
+        await sut.registerContract(contract);
 
         const findContract = sut['contracts'].find(c => c.name === 'coinflip');
-
         expect(findContract).not.toBeUndefined();
     });
 
     test('User wins a flip', async () => {
-        sut.registerContract('coinflip', contract);
+        await sut.registerContract(contract);
 
-        contract['_instance'] = sut;
-
-        jest.spyOn(contract as any, 'flip');
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(2000));
-
-        jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+        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['client'].database, 'getAccounts').mockResolvedValue([{ balance: '2000.000 HIVE' }] as any);
+
+        (uuidv4 as jest.Mock).mockReturnValue('j93jgsjghjdhgjfhgkfdhgkj34872394723');
 
         const memo = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'coinflip',
+            hive_stream: {
+                contract: 'coinflip',
                 action: 'flip',
                 payload: {
                     guess: 'heads',
@@ -69,154 +55,40 @@ describe('Coinflip Contract', () => {
             }
         });
 
-        (uuidv4 as jest.Mock).mockReturnValue('j93jgsjghjdhgjfhgkfdhgkj34872394723');
-
-        sut.processOperation(['transfer', { from: 'testuser', amount: '9.000 HIVE', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjs7878dkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
+        await sut.processOperation(['transfer', { from: 'testuser', amount: '9.000 HIVE', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjs7878dkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
 
         await sleep(100);
 
-        expect(contract['flip']).toBeCalled();
-        expect(contract['_instance'].getTransaction).toBeCalledWith(778782, 'fhkjsdhfkjsdf');
-        expect(contract['_instance'].transferHiveTokens).toBeCalledWith('beggars', 'testuser', '18.000', 'HIVE', '[Winner] | Guess: heads | Server Roll: heads | Previous block id: fkjs7878dkfj | BlockID: dfjfsdfsdfs4hfkj88787 | Trx ID: fhkjsdhfkjsdf | Server Seed: j93jgsjghjdhgjfhgkfdhgkj34872394723');
+        expect(sut.getTransaction).toHaveBeenCalledWith(778782, 'fhkjsdhfkjsdf');
+        expect(sut.transferHiveTokens).toHaveBeenCalledWith('beggars', 'testuser', '18.000', 'HIVE', '[Winner] | Guess: heads | Server Roll: heads | Previous block id: fkjs7878dkfj | BlockID: dfjfsdfsdfs4hfkj88787 | Trx ID: fhkjsdhfkjsdf | Server Seed: j93jgsjghjdhgjfhgkfdhgkj34872394723');
     });
 
     test('User loses a flip', async () => {
-        sut.registerContract('coinflip', contract);
-
-        contract['_instance'] = sut;
+        await sut.registerContract(contract);
 
-        jest.spyOn(contract as any, 'flip');
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(2000));
-
-        jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+        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);
-
-        const memo = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'coinflip',
-                action: 'flip',
-                payload: {
-                    guess: 'heads',
-                    seed: 'tulips'
-                }
-            }
-        });
+        jest.spyOn(sut['client'].database, 'getAccounts').mockResolvedValue([{ balance: '2000.000 HIVE' }] as any);
 
         (uuidv4 as jest.Mock).mockReturnValue('j93jgsjghjdhgjfhgkfdhgkj34872394723');
 
-        sut.processOperation(['transfer', { from: 'testuser', amount: '9.000 HIVE', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjs7878dkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
-
-        await sleep(100);
-
-        expect(contract['flip']).toBeCalled();
-        expect(contract['_instance'].getTransaction).toBeCalledWith(778782, 'fhkjsdhfkjsdf');
-        expect(contract['_instance'].transferHiveTokens).toBeCalledWith('beggars', 'testuser', '0.001', 'HIVE', '[Lost] | Guess: heads | Server Roll: tails | Previous block id: fkjs7878dkfj | BlockID: dfjfsdfsdfs4hfkj88787 | Trx ID: fhkjsdhfkjsdf | Server Seed: j93jgsjghjdhgjfhgkfdhgkj34872394723');
-    });
-
-    test('User sent an unsupported currency, refund them', async () => {
-        sut.registerContract('coinflip', contract);
-
-        contract['_instance'] = sut;
-
-        jest.spyOn(contract as any, 'flip');
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(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);
-
         const memo = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'coinflip',
+            hive_stream: {
+                contract: 'coinflip',
                 action: 'flip',
                 payload: {
-                    guess: 'heads'
-                }
-            }
-        });
-
-        sut.processOperation(['transfer', { from: 'testuser', amount: '10.000 HBD', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
-
-        await sleep(100);
-
-        expect(contract['flip']).toBeCalled();
-        expect(sut.getTransaction).toBeCalledWith(778782, 'fhkjsdhfkjsdf');
-        expect(sut.transferHiveTokens).toBeCalledWith('beggars', 'testuser', '10.000', 'HBD', '[Refund] You sent an invalid currency.');
-    });
-
-    test('Server cannot afford payout, refund user', async () => {
-        sut.registerContract('coinflip', contract);
-
-        contract['_instance'] = sut;
-
-        jest.spyOn(contract as any, 'flip');
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(10)); // Low balance
-
-        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);
-
-        const memo = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'coinflip',
-                action: 'flip',
-                payload: {
-                    guess: 'heads'
+                    guess: 'heads',
+                    seed: 'tulips'
                 }
             }
         });
 
-        sut.processOperation(['transfer', { from: 'testuser', amount: '15.000 HIVE', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
+        await sut.processOperation(['transfer', { from: 'testuser', amount: '9.000 HIVE', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjs7878dkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
 
         await sleep(100);
 
-        expect(contract['flip']).toBeCalled();
-        expect(sut.getTransaction).toBeCalledWith(778782, 'fhkjsdhfkjsdf');
-        expect(sut.transferHiveTokens).toBeCalledWith('beggars', 'testuser', '15.000', 'HIVE', '[Refund] The server cannot afford this bet payout.');
-    });
-
-    test('Queue processes multiple concurrent bets', async () => {
-        sut.registerContract('coinflip', contract);
-
-        contract['_instance'] = sut;
-
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(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);
-
-        const memo1 = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'coinflip',
-                action: 'flip',
-                payload: { guess: 'heads', seed: 'seed1' }
-            }
-        });
-
-        const memo2 = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'coinflip',
-                action: 'flip',
-                payload: { guess: 'heads', seed: 'seed2' }
-            }
-        });
-
-        (uuidv4 as jest.Mock).mockReturnValue('test-server-seed');
-
-        // Process multiple bets concurrently
-        const bet1Promise = sut.processOperation(['transfer', { from: 'user1', amount: '5.000 HIVE', memo: memo1 }], 778782, 'block1', 'prevblock1', 'trx1', '2019-06-23' as any);
-        const bet2Promise = sut.processOperation(['transfer', { from: 'user2', amount: '5.000 HIVE', memo: memo2 }], 778783, 'block2', 'prevblock2', 'trx2', '2019-06-23' as any);
-
-        await Promise.all([bet1Promise, bet2Promise]);
-        await sleep(200); // Allow queue processing to complete
-
-        // Both transfers should have been processed
-        expect(sut.transferHiveTokens).toHaveBeenCalledTimes(2);
+        expect(sut.getTransaction).toHaveBeenCalledWith(778782, 'fhkjsdhfkjsdf');
+        expect(sut.transferHiveTokens).toHaveBeenCalledWith('beggars', 'testuser', '0.001', 'HIVE', '[Lost] | Guess: heads | Server Roll: tails | Previous block id: fkjs7878dkfj | BlockID: dfjfsdfsdfs4hfkj88787 | Trx ID: fhkjsdhfkjsdf | Server Seed: j93jgsjghjdhgjfhgkfdhgkj34872394723');
     });
-});
+});

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

@@ -1,18 +1,17 @@
 import { sleep } from '@hiveio/dhive/lib/utils';
-import { DiceContract } from './../../src/contracts/dice.contract';
+import { createDiceContract } from './../../src/contracts/dice.contract';
 import { Streamer } from '../../src/streamer';
 import { createMockAdapter } from '../helpers/mock-adapter';
-import BigNumber from 'bignumber.js';
 
 describe('Dice Contract', () => {
     let sut: Streamer;
-    let contract: DiceContract;
+    let contract: ReturnType<typeof createDiceContract>;
 
     beforeEach(async () => {
         sut = new Streamer();
         await sut.registerAdapter(createMockAdapter());
-        
-        contract = new DiceContract();
+
+        contract = createDiceContract({ name: 'testdice' });
 
         // @ts-ignore
         sut.api = jest.fn();
@@ -26,8 +25,8 @@ describe('Dice Contract', () => {
         jest.restoreAllMocks();
     });
 
-    test('Registers the dice contract', () => {
-        sut.registerContract('testdice', contract);
+    test('Registers the dice contract', async () => {
+        await sut.registerContract(contract);
 
         const findContract = sut['contracts'].find(c => c.name === 'testdice');
 
@@ -35,21 +34,16 @@ describe('Dice Contract', () => {
     });
 
     test('User wins a roll', async () => {
-        sut.registerContract('testdice', contract);
-
-        contract['_instance'] = sut;
+        await sut.registerContract(contract);
 
-        jest.spyOn(contract as any, 'roll');
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(2000));
-
-        jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+        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['client'].database, 'getAccounts').mockResolvedValue([{ balance: '2000.000 HIVE' }] as any);
 
         const memo = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'testdice',
+            hive_stream: {
+                contract: 'testdice',
                 action: 'roll',
                 payload: {
                     roll: 69
@@ -57,147 +51,37 @@ describe('Dice Contract', () => {
             }
         });
 
-        sut.processOperation(['transfer', { from: 'testuser', amount: '9.000 HIVE', memo }], 778782, 'dfjfsdfsdfsd34hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
+        await sut.processOperation(['transfer', { from: 'testuser', amount: '9.000 HIVE', memo }], 778782, 'dfjfsdfsdfsd34hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
 
         await sleep(100);
 
-        expect(contract['roll']).toBeCalled();
-        expect(contract['_instance'].getTransaction).toBeCalledWith(778782, 'fhkjsdhfkjsdf');
-        expect(contract['_instance'].transferHiveTokens).toBeCalledWith('beggars', 'testuser', '12.391', 'HIVE', 'You won 12.391 HIVE. Roll: 54, Your guess: 69');
+        expect(sut.getTransaction).toHaveBeenCalledWith(778782, 'fhkjsdhfkjsdf');
+        expect(sut.transferHiveTokens).toHaveBeenCalledWith('beggars', 'testuser', '12.391', 'HIVE', 'You won 12.391 HIVE. Roll: 54, Your guess: 69');
     });
 
     test('User loses a roll', async () => {
-        sut.registerContract('testdice', contract);
-
-        contract['_instance'] = sut;
+        await sut.registerContract(contract);
 
-        jest.spyOn(contract as any, 'roll');
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(2000));
-
-        jest.spyOn(sut, 'getTransaction').mockResolvedValue({test: 123} as any);
+        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['client'].database, 'getAccounts').mockResolvedValue([{ balance: '2000.000 HIVE' }] as any);
 
         const memo = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'testdice',
+            hive_stream: {
+                contract: 'testdice',
                 action: 'roll',
                 payload: {
-                    roll: 69
+                    roll: 10
                 }
             }
         });
 
-        sut.processOperation(['transfer', { from: 'testuser', amount: '9.000 HIVE', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
+        await sut.processOperation(['transfer', { from: 'testuser', amount: '9.000 HIVE', memo }], 778782, 'dfjfsdfsdfsd34hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
 
         await sleep(100);
 
-        expect(contract['roll']).toBeCalled();
-        expect(sut.getTransaction).toBeCalledWith(778782, 'fhkjsdhfkjsdf');
-        expect(sut.transferHiveTokens).toBeCalledWith('beggars', 'testuser', '0.001', 'HIVE', 'You lost 9.000 HIVE. Roll: 81, Your guess: 69');
-    });
-
-    test('User sent an invalid amount, refund them', async () => {
-        sut.registerContract('testdice', contract);
-
-        contract['_instance'] = sut;
-
-        jest.spyOn(contract as any, 'roll');
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(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);
-
-        const memo = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'testdice',
-                action: 'roll',
-                payload: {
-                    roll: 69
-                }
-            }
-        });
-
-        sut.processOperation(['transfer', { from: 'testuser', amount: '100.000 HIVE', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
-
-        await sleep(100);
-
-        expect(contract['roll']).toBeCalled();
-        expect(sut.getTransaction).toBeCalledWith(778782, 'fhkjsdhfkjsdf');
-        expect(sut.transferHiveTokens).toBeCalledWith('beggars', 'testuser', '100.000', 'HIVE', '[Refund] You sent an invalid bet amount.');
-    });
-
-    test('User sent an unsupported currency, refund them', async () => {
-        sut.registerContract('testdice', contract);
-
-        contract['_instance'] = sut;
-
-        jest.spyOn(contract as any, 'roll');
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(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);
-
-        const memo = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'testdice',
-                action: 'roll',
-                payload: {
-                    roll: 69
-                }
-            }
-        });
-
-        sut.processOperation(['transfer', { from: 'testuser', amount: '10.000 HBD', memo }], 778782, 'dfjfsdfsdfs4hfkj88787', 'fkjsdkfj', 'fhkjsdhfkjsdf', '2019-06-23' as any);
-
-        await sleep(100);
-
-        expect(contract['roll']).toBeCalled();
-        expect(sut.getTransaction).toBeCalledWith(778782, 'fhkjsdhfkjsdf');
-        expect(sut.transferHiveTokens).toBeCalledWith('beggars', 'testuser', '10.000', 'HBD', '[Refund] Invalid bet params.');
-    });
-
-    test('Queue processes multiple concurrent rolls', async () => {
-        sut.registerContract('testdice', contract);
-
-        contract['_instance'] = sut;
-
-        jest.spyOn(contract as any, 'getBalance').mockResolvedValue(new BigNumber(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);
-
-        const memo1 = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'testdice',
-                action: 'roll',
-                payload: { roll: 50 }
-            }
-        });
-
-        const memo2 = JSON.stringify({
-            hivePayload: {
-                id: 'hivestream',
-                name: 'testdice',
-                action: 'roll',
-                payload: { roll: 75 }
-            }
-        });
-
-        // Process multiple bets concurrently
-        const bet1Promise = sut.processOperation(['transfer', { from: 'user1', amount: '5.000 HIVE', memo: memo1 }], 778782, 'block1', 'prevblock1', 'trx1', '2019-06-23' as any);
-        const bet2Promise = sut.processOperation(['transfer', { from: 'user2', amount: '5.000 HIVE', memo: memo2 }], 778783, 'block2', 'prevblock2', 'trx2', '2019-06-23' as any);
-
-        await Promise.all([bet1Promise, bet2Promise]);
-        await sleep(200); // Allow queue processing to complete
-
-        // Both transfers should have been processed
-        expect(sut.transferHiveTokens).toHaveBeenCalledTimes(2);
+        expect(sut.getTransaction).toHaveBeenCalledWith(778782, 'fhkjsdhfkjsdf');
+        expect(sut.transferHiveTokens).toHaveBeenCalledWith('beggars', 'testuser', '0.001', 'HIVE', 'You lost 9.000 HIVE. Roll: 54, Your guess: 10');
     });
-});
+});

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

@@ -0,0 +1,84 @@
+import { Streamer } from '../../src/streamer';
+import { SqliteAdapter } from '../../src/adapters/sqlite.adapter';
+import { createExchangeContract } from '../../src/contracts/exchange.contract';
+
+describe('Exchange Contract', () => {
+    let streamer: Streamer;
+    let adapter: SqliteAdapter;
+    let contract: ReturnType<typeof createExchangeContract>;
+
+    beforeEach(async () => {
+        streamer = new Streamer({
+            JSON_ID: 'hivestream',
+            PAYLOAD_IDENTIFIER: 'hive_stream'
+        });
+
+        adapter = new SqliteAdapter(':memory:');
+        await streamer.registerAdapter(adapter);
+
+        contract = createExchangeContract({ name: 'exchange' });
+        await streamer.registerContract(contract);
+    });
+
+    afterEach(async () => {
+        await streamer.stop();
+    });
+
+    const baseContext = (trigger: 'custom_json' | 'transfer' | 'time', sender: string) => ({
+        trigger,
+        streamer,
+        adapter,
+        config: streamer['config'],
+        block: { number: 100, id: 'block', previousId: 'prev', time: new Date() },
+        transaction: { id: `trx-${trigger}-${sender}` },
+        sender,
+        customJson: trigger === 'custom_json' ? { id: 'hivestream', json: {}, isSignedWithActiveKey: true } : undefined,
+        transfer: trigger === 'transfer' ? { from: sender, to: 'exchange', rawAmount: '', amount: '', asset: '', memo: '' } : undefined
+    });
+
+    test('Deposits, places orders, and matches', async () => {
+        await contract.actions.createPair.handler({ base: 'HIVE', quote: 'HBD' }, baseContext('custom_json', 'alice'));
+
+        const aliceDepositContext = baseContext('transfer', 'alice');
+        aliceDepositContext.transfer.rawAmount = '100.000 HBD';
+        aliceDepositContext.transfer.amount = '100.000';
+        aliceDepositContext.transfer.asset = 'HBD';
+        await contract.actions.deposit.handler({}, aliceDepositContext);
+
+        const bobDepositContext = baseContext('transfer', 'bob');
+        bobDepositContext.transfer.rawAmount = '10.000 HIVE';
+        bobDepositContext.transfer.amount = '10.000';
+        bobDepositContext.transfer.asset = 'HIVE';
+        await contract.actions.deposit.handler({}, bobDepositContext);
+
+        await contract.actions.placeOrder.handler({
+            side: 'buy',
+            base: 'HIVE',
+            quote: 'HBD',
+            price: '2',
+            amount: '5'
+        }, baseContext('custom_json', 'alice'));
+
+        await contract.actions.placeOrder.handler({
+            side: 'sell',
+            base: 'HIVE',
+            quote: 'HBD',
+            price: '2',
+            amount: '5'
+        }, baseContext('custom_json', 'bob'));
+
+        await contract.actions.matchOrders.handler({ base: 'HIVE', quote: 'HBD', limit: 10, snapshot: true, depth: 20 }, baseContext('time', 'system'));
+
+        const aliceHive = await adapter.query('SELECT available, locked FROM exchange_balances WHERE account = ? AND asset = ?', ['alice', 'HIVE']);
+        const bobHbd = await adapter.query('SELECT available, locked FROM exchange_balances WHERE account = ? AND asset = ?', ['bob', 'HBD']);
+
+        expect(aliceHive[0].available).toBe('4.995');
+        expect(bobHbd[0].available).toBe('9.980');
+
+        const snapshots = await adapter.query(
+            'SELECT bids, asks FROM exchange_orderbook_snapshots WHERE base_asset = ? AND quote_asset = ?',
+            ['HIVE', 'HBD']
+        );
+        expect(snapshots.length).toBeGreaterThan(0);
+    });
+});