hive-stream 2.0.5 → 3.0.0

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

@@ -0,0 +1,334 @@
+import { TokenContract } from '../../src/contracts/token.contract';
+import { MockAdapter } from '../helpers/mock-adapter';
+
+describe('TokenContract', () => {
+    let tokenContract: TokenContract;
+    let mockAdapter: MockAdapter;
+    let mockStreamer: any;
+
+    beforeEach(() => {
+        mockAdapter = new MockAdapter();
+        mockStreamer = {
+            getAdapter: () => mockAdapter
+        };
+
+        tokenContract = new TokenContract();
+        tokenContract._instance = mockStreamer;
+        tokenContract.updateBlockInfo(12345, 'block123', 'prevblock123', 'txn123');
+    });
+
+    describe('createToken', () => {
+        it('should create a new token successfully', async () => {
+            mockAdapter.reset();
+            tokenContract.create();
+            mockAdapter.setQueryResult([]); // No existing token with same symbol
+
+            const payload = {
+                symbol: 'TEST',
+                name: 'Test Token',
+                precision: 3,
+                maxSupply: '1000000'
+            };
+
+            await (tokenContract as any).createToken(payload, { sender: 'alice' });
+
+            const insertQuery = mockAdapter.queries.find(q => q.includes('INSERT INTO tokens'));
+            expect(insertQuery).toBeDefined();
+            expect(mockAdapter.events.length).toBe(1);
+            expect(mockAdapter.events[0].action).toBe('createToken');
+        });
+
+        it('should reject invalid token symbol', async () => {
+            const payload = {
+                symbol: 'invalid-symbol',
+                name: 'Test Token',
+                maxSupply: '1000000'
+            };
+
+            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
+                .rejects.toThrow('Symbol must be 1-10 uppercase alphanumeric characters');
+        });
+
+        it('should reject invalid max supply', async () => {
+            const payload = {
+                symbol: 'TEST',
+                name: 'Test Token',
+                maxSupply: '0'
+            };
+
+            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
+                .rejects.toThrow('Maximum supply must be between 1 and 9007199254740991');
+        });
+
+        it('should reject max supply too large', async () => {
+            const payload = {
+                symbol: 'TEST',
+                name: 'Test Token',
+                maxSupply: '9007199254740992'
+            };
+
+            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
+                .rejects.toThrow('Maximum supply must be between 1 and 9007199254740991');
+        });
+
+        it('should reject invalid precision', async () => {
+            const payload = {
+                symbol: 'TEST',
+                name: 'Test Token',
+                precision: 9,
+                maxSupply: '1000000'
+            };
+
+            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
+                .rejects.toThrow('Precision must be between 0 and 8');
+        });
+
+        it('should create token with URL', async () => {
+            mockAdapter.reset();
+            tokenContract.create();
+            mockAdapter.setQueryResult([]); // No existing token with same symbol
+
+            const payload = {
+                symbol: 'TEST',
+                name: 'Test Token',
+                url: 'https://example.com/token',
+                precision: 3,
+                maxSupply: '1000000'
+            };
+
+            await (tokenContract as any).createToken(payload, { sender: 'alice' });
+
+            const insertQuery = mockAdapter.queries.find(q => q.includes('INSERT INTO tokens'));
+            expect(insertQuery).toBeDefined();
+            expect(mockAdapter.events.length).toBe(1);
+            expect(mockAdapter.events[0].action).toBe('createToken');
+        });
+
+        it('should reject URL too long', async () => {
+            const longUrl = 'https://example.com/' + 'a'.repeat(250);
+            const payload = {
+                symbol: 'TEST',
+                name: 'Test Token',
+                url: longUrl,
+                maxSupply: '1000000'
+            };
+
+            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
+                .rejects.toThrow('URL must be 256 characters or less');
+        });
+    });
+
+    describe('issueTokens', () => {
+        it('should issue tokens successfully', async () => {
+            mockAdapter.reset();
+            mockAdapter.setTestContext({ noExistingBalance: true });
+            tokenContract.create();
+            
+            mockAdapter.setQueryResult([{
+                symbol: 'TEST',
+                name: 'Test Token',
+                creator: 'alice',
+                precision: 3,
+                current_supply: '0',
+                max_supply: '1000000'
+            }]);
+
+            const payload = {
+                symbol: 'TEST',
+                to: 'bob',
+                amount: '100',
+                memo: 'Initial distribution'
+            };
+
+            await (tokenContract as any).issueTokens(payload, { sender: 'alice' });
+
+            const updateQuery = mockAdapter.queries.find(q => q.includes('UPDATE tokens SET current_supply'));
+            const insertQuery = mockAdapter.queries.find(q => q.includes('INSERT INTO token_balances'));
+            expect(updateQuery).toBeDefined();
+            expect(insertQuery).toBeDefined();
+            expect(mockAdapter.events.length).toBe(1);
+            expect(mockAdapter.events[0].action).toBe('issueTokens');
+        });
+
+        it('should reject issuance by non-creator', async () => {
+            mockAdapter.reset();
+            tokenContract.create();
+            
+            mockAdapter.setQueryResult([{
+                symbol: 'TEST',
+                name: 'Test Token',
+                creator: 'alice',
+                precision: 3,
+                current_supply: '0',
+                max_supply: '1000000'
+            }]);
+
+            const payload = {
+                symbol: 'TEST',
+                to: 'bob',
+                amount: '100'
+            };
+
+            await expect((tokenContract as any).issueTokens(payload, { sender: 'charlie' }))
+                .rejects.toThrow('Only the token creator can issue new tokens');
+        });
+
+        it('should reject issuance exceeding max supply', async () => {
+            mockAdapter.reset();
+            mockAdapter.setTestContext({ maxSupplyExceeded: true });
+            tokenContract.create();
+            
+            mockAdapter.setQueryResult([{
+                symbol: 'TEST',
+                name: 'Test Token',
+                creator: 'alice',
+                precision: 3,
+                current_supply: '999999',
+                max_supply: '1000000'
+            }]);
+
+            const payload = {
+                symbol: 'TEST',
+                to: 'bob',
+                amount: '100'
+            };
+
+            await expect((tokenContract as any).issueTokens(payload, { sender: 'alice' }))
+                .rejects.toThrow('Cannot issue tokens: would exceed maximum supply');
+        });
+    });
+
+    describe('transferTokens', () => {
+        it('should transfer tokens successfully', async () => {
+            mockAdapter.reset();
+            tokenContract.create();
+
+            const payload = {
+                symbol: 'TEST',
+                to: 'bob',
+                amount: '100',
+                memo: 'Payment'
+            };
+
+            await (tokenContract as any).transferTokens(payload, { sender: 'alice' });
+
+            const updateQuery = mockAdapter.queries.find(q => q.includes('UPDATE token_balances SET balance'));
+            const insertQuery = mockAdapter.queries.find(q => q.includes('INSERT INTO token_transfers'));
+            expect(updateQuery).toBeDefined();
+            expect(insertQuery).toBeDefined();
+            expect(mockAdapter.events.length).toBe(1);
+            expect(mockAdapter.events[0].action).toBe('transferTokens');
+        });
+
+        it('should reject transfer with insufficient balance', async () => {
+            mockAdapter.reset();
+            mockAdapter.setTestContext({ insufficientBalance: true });
+            tokenContract.create();
+
+            const payload = {
+                symbol: 'TEST',
+                to: 'bob',
+                amount: '100'
+            };
+
+            await expect((tokenContract as any).transferTokens(payload, { sender: 'alice' }))
+                .rejects.toThrow('Insufficient balance');
+        });
+
+        it('should reject transfer of non-existent token', async () => {
+            mockAdapter.reset();
+            mockAdapter.setTestContext({ nonExistentToken: 'NONEXISTENT' });
+            tokenContract.create();
+
+            const payload = {
+                symbol: 'NONEXISTENT',
+                to: 'bob',
+                amount: '100'
+            };
+
+            await expect((tokenContract as any).transferTokens(payload, { sender: 'alice' }))
+                .rejects.toThrow('Token NONEXISTENT does not exist');
+        });
+    });
+
+    describe('getBalance', () => {
+        it('should return balance for existing account', async () => {
+            mockAdapter.reset();
+            tokenContract.create();
+            
+            mockAdapter.setQueryResult([{ balance: '500' }]);
+
+            const payload = {
+                account: 'alice',
+                symbol: 'TEST'
+            };
+
+            await (tokenContract as any).getBalance(payload, { sender: 'bob' });
+
+            const selectQuery = mockAdapter.queries.find(q => q.includes('SELECT balance FROM token_balances'));
+            expect(selectQuery).toBeDefined();
+            expect(mockAdapter.events.length).toBe(1);
+            expect(mockAdapter.events[0].action).toBe('getBalance');
+        });
+
+        it('should return zero balance for non-existent account', async () => {
+            mockAdapter.reset();
+            mockAdapter.setTestContext({ zeroBalance: true });
+            tokenContract.create();
+
+            const payload = {
+                account: 'alice',
+                symbol: 'TEST'
+            };
+
+            await (tokenContract as any).getBalance(payload, { sender: 'bob' });
+
+            expect(mockAdapter.events[0].data.data.balance).toBe('0');
+        });
+    });
+
+    describe('getTokenInfo', () => {
+        it('should return token information', async () => {
+            mockAdapter.reset();
+            tokenContract.create();
+            
+            const tokenData = {
+                symbol: 'TEST',
+                name: 'Test Token',
+                url: 'https://example.com/token',
+                precision: 3,
+                max_supply: '1000000',
+                current_supply: '500000',
+                creator: 'alice',
+                created_at: new Date()
+            };
+
+            mockAdapter.setQueryResult([tokenData]);
+
+            const payload = {
+                symbol: 'TEST'
+            };
+
+            await (tokenContract as any).getTokenInfo(payload, { sender: 'bob' });
+
+            const selectQuery = mockAdapter.queries.find(q => q.includes('SELECT * FROM tokens'));
+            expect(selectQuery).toBeDefined();
+            expect(mockAdapter.events.length).toBe(1);
+            expect(mockAdapter.events[0].action).toBe('getTokenInfo');
+            expect(mockAdapter.events[0].data.data.token_info).toEqual(tokenData);
+        });
+
+        it('should reject request for non-existent token', async () => {
+            mockAdapter.reset();
+            mockAdapter.setTestContext({ nonExistentToken: 'NONEXISTENT' });
+            tokenContract.create();
+
+            const payload = {
+                symbol: 'NONEXISTENT'
+            };
+
+            await expect((tokenContract as any).getTokenInfo(payload, { sender: 'bob' }))
+                .rejects.toThrow('Token NONEXISTENT does not exist');
+        });
+    });
+});

package/tests/helpers/mock-adapter.ts

@@ -0,0 +1,214 @@
+import { AdapterBase } from '../../src/adapters/base.adapter';
+
+export class MockAdapter extends AdapterBase {
+    public queries: string[] = [];
+    public events: any[] = [];
+    private queryResults: any[][] = [];
+    private currentQueryIndex = 0;
+    private testContext: any = {};
+    public async create(): Promise<boolean> {
+        return true;
+    }
+
+    public async destroy(): Promise<boolean> {
+        return true;
+    }
+
+    public async loadActions() {
+        return [];
+    }
+
+    public async loadState() {
+        return { lastBlockNumber: 0, actions: [] };
+    }
+
+    public async saveState(data: any): Promise<boolean> {
+        return true;
+    }
+
+    public async processBlock(block: any): Promise<any> {
+        return true;
+    }
+
+    public async processOperation(op: any, blockNumber: number, blockId: string, prevBlockId: string, trxId: string, blockTime: Date): Promise<any> {
+        return true;
+    }
+
+    public async processTransfer(operation: any, payload: any, metadata: any): Promise<boolean> {
+        return true;
+    }
+
+    public async processCustomJson(operation: any, payload: any, metadata: any): Promise<boolean> {
+        return true;
+    }
+
+    public async find(table: string, queryObject: Record<string, any>): Promise<any> {
+        return [];
+    }
+
+    public async findOne(table: string, queryObject: Record<string, any>): Promise<any> {
+        return null;
+    }
+
+    public async insert(table: string, data: any): Promise<any> {
+        return true;
+    }
+
+    public async replace(table: string, queryObject: Record<string, any>, data: any): Promise<any> {
+        return data;
+    }
+
+    public async addEvent(date: string | Date, contract: string, action: string, payload: any, data: any): Promise<boolean> {
+        this.events.push({ date, contract, action, payload, data });
+        return true;
+    }
+
+    public async query(sql: string, params?: any[]): Promise<any[]> {
+        this.queries.push(sql);
+        
+        // Handle specific queries with predetermined responses
+        if (sql.includes('CREATE TABLE')) {
+            return [];
+        }
+        
+        if (sql.includes('SELECT precision FROM tokens WHERE symbol = ?')) {
+            const symbol = params?.[0];
+            if (this.testContext.nonExistentToken === symbol) {
+                return [];
+            }
+            return [{ precision: 3 }];
+        }
+        
+        if (sql.includes('SELECT balance FROM token_balances WHERE account = ? AND symbol = ?')) {
+            const account = params?.[0];
+            const symbol = params?.[1];
+            
+            // Handle test scenarios
+            if (this.testContext.insufficientBalance && account === 'alice') {
+                return [{ balance: '50' }];
+            }
+            if (this.testContext.zeroBalance && account === 'alice') {
+                return [];
+            }
+            if (this.testContext.noExistingBalance) {
+                return [];
+            }
+            
+            // Default balances
+            if (account === 'alice') {
+                return [{ balance: '1000' }];
+            } else if (account === 'bob') {
+                return [{ balance: '50' }];
+            }
+            return [];
+        }
+        
+        if (sql.includes('SELECT * FROM tokens WHERE symbol = ?')) {
+            const symbol = params?.[0];
+            if (this.testContext.nonExistentToken === symbol) {
+                return [];
+            }
+            
+            // Handle max supply exceeded test
+            if (this.testContext.maxSupplyExceeded) {
+                return [{
+                    symbol: 'TEST',
+                    name: 'Test Token',
+                    creator: 'alice',
+                    precision: 3,
+                    max_supply: '1000000',
+                    current_supply: '999999'
+                }];
+            }
+            
+            // Return token info for existing tokens
+            return [{
+                symbol: 'TEST',
+                name: 'Test Token',
+                url: 'https://example.com/token',
+                precision: 3,
+                max_supply: '1000000',
+                current_supply: '500000',
+                creator: 'alice',
+                created_at: new Date()
+            }];
+        }
+        
+        if (sql.includes('SELECT symbol FROM tokens WHERE symbol = ?')) {
+            const symbol = params?.[0];
+            if (this.testContext.existingToken === symbol) {
+                return [{ symbol }];
+            }
+            return [];
+        }
+        
+        // Use sequential results for other queries
+        if (this.queryResults.length > this.currentQueryIndex) {
+            return this.queryResults[this.currentQueryIndex++];
+        }
+        return [];
+    }
+
+    public setQueryResult(result: any[], index?: number): void {
+        if (index !== undefined) {
+            this.queryResults[index] = result;
+        } else {
+            this.queryResults.push(result);
+        }
+    }
+
+    public setQueryResults(results: any[][]): void {
+        this.queryResults = results;
+        this.currentQueryIndex = 0;
+    }
+
+    public reset(): void {
+        this.queries = [];
+        this.events = [];
+        this.queryResults = [];
+        this.currentQueryIndex = 0;
+        this.testContext = {};
+    }
+
+    public setTestContext(context: any): void {
+        this.testContext = context;
+    }
+
+    public async getTransfers() {
+        return [];
+    }
+
+    public async getEvents() {
+        return [];
+    }
+
+    public async getJson() {
+        return [];
+    }
+
+    public async getTransfersByContract(contract: string) {
+        return [];
+    }
+
+    public async getTransfersByAccount(account: string) {
+        return [];
+    }
+
+    public async getTransfersByBlockid(blockId: any) {
+        return [];
+    }
+
+    public async getJsonByContract(contract: string) {
+        return [];
+    }
+
+    public async getJsonByAccount(account: string) {
+        return [];
+    }
+
+    public async getJsonByBlockid(blockId: any) {
+        return [];
+    }
+}
+
+export const createMockAdapter = () => new MockAdapter();

package/tests/setup.ts

@@ -1,19 +1,30 @@
-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...
+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 fetchMock = require('jest-fetch-mock');
+const customGlobal: GlobalWithFetchMock = global as unknown as GlobalWithFetchMock;
+
+// Safely assign fetch mock
+if (!customGlobal.fetch) {
+    customGlobal.fetch = fetchMock;
+} else {
+    Object.defineProperty(customGlobal, 'fetch', {
+        value: fetchMock,
+        writable: true,
+        configurable: true
+    });
+}
+customGlobal.fetchMock = customGlobal.fetch;
+
+process.on('unhandledRejection', (error) => {
+  throw error; // Or whatever you like...
 });