hive-stream 3.0.2 → 3.0.3

package/tests/helpers/mock-adapter.ts

@@ -1,214 +0,0 @@
-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/helpers/mock-fetch.ts

@@ -1,165 +0,0 @@
-/**
- * Test utilities for mocking fetch and external APIs
- */
-
-import { jest } from '@jest/globals';
-
-// Mock Response class that properly implements the Response interface
-export class MockResponse {
-    public readonly status: number;
-    public readonly statusText: string;
-    public readonly ok: boolean;
-    public readonly headers: Headers;
-    public readonly redirected: boolean = false;
-    public readonly type: ResponseType = 'default';
-    public readonly url: string = '';
-    public readonly body: ReadableStream<Uint8Array> | null = null;
-    public readonly bodyUsed: boolean = false;
-
-    private data: any;
-
-    constructor(data: any, options: { status?: number; statusText?: string; headers?: HeadersInit } = {}) {
-        this.data = data;
-        this.status = options.status || 200;
-        this.statusText = options.statusText || 'OK';
-        this.ok = this.status >= 200 && this.status < 300;
-        this.headers = new Headers(options.headers);
-    }
-
-    async json(): Promise<any> {
-        return this.data;
-    }
-
-    async text(): Promise<string> {
-        return typeof this.data === 'string' ? this.data : JSON.stringify(this.data);
-    }
-
-    async arrayBuffer(): Promise<ArrayBuffer> {
-        throw new Error('arrayBuffer not implemented in mock');
-    }
-
-    async blob(): Promise<Blob> {
-        throw new Error('blob not implemented in mock');
-    }
-
-    async formData(): Promise<FormData> {
-        throw new Error('formData not implemented in mock');
-    }
-
-    async bytes(): Promise<Uint8Array> {
-        throw new Error('bytes not implemented in mock');
-    }
-
-    clone(): MockResponse {
-        return new MockResponse(this.data, {
-            status: this.status,
-            statusText: this.statusText,
-            headers: this.headers
-        });
-    }
-}
-
-/**
- * Create a mock fetch function with predefined responses
- */
-export function createMockFetch(responses: { [url: string]: any } = {}) {
-    return jest.fn().mockImplementation((...args: any[]) => {
-        const url = args[0] as string;
-        
-        // Handle URL patterns
-        if (url.includes('coingecko.com')) {
-            return Promise.resolve(new MockResponse({
-                hive: { usd: 0.25 },
-                'hive_dollar': { usd: 1.00 }
-            }));
-        }
-
-        if (url.includes('fawazahmed0.github.io') && url.includes('/latest/currencies/usd.json')) {
-            return Promise.resolve(new MockResponse({
-                usd: {
-                    eur: 0.85,
-                    gbp: 0.73,
-                    jpy: 110.0,
-                    cad: 1.25,
-                    aud: 1.35
-                }
-            }));
-        }
-
-        // Handle specific URLs from responses object
-        if (responses[url]) {
-            return Promise.resolve(new MockResponse(responses[url]));
-        }
-
-        // Default error response
-        return Promise.reject(new Error(`Unmocked URL: ${url}`));
-    });
-}
-
-/**
- * Mock successful API responses for all endpoints
- */
-export function mockSuccessfulApis() {
-    const mockFetch = createMockFetch();
-    global.fetch = mockFetch as any;
-    return mockFetch;
-}
-
-/**
- * Mock network errors for testing error handling
- */
-export function mockNetworkErrors() {
-    const mockFetch = jest.fn().mockImplementation(() => 
-        Promise.reject(new Error('Network error'))
-    );
-    global.fetch = mockFetch as any;
-    return mockFetch;
-}
-
-/**
- * Mock timeout errors
- */
-export function mockTimeoutErrors() {
-    const mockFetch = jest.fn().mockImplementation(() => 
-        new Promise((_, reject) => {
-            setTimeout(() => reject(new Error('Request timeout')), 100);
-        })
-    );
-    global.fetch = mockFetch as any;
-    return mockFetch;
-}
-
-/**
- * Mock invalid JSON responses
- */
-export function mockInvalidResponses() {
-    const mockFetch = jest.fn().mockImplementation(() => 
-        Promise.resolve(new MockResponse('invalid json', { status: 200 }))
-    );
-    global.fetch = mockFetch as any;
-    return mockFetch;
-}
-
-/**
- * Mock HTTP error responses
- */
-export function mockHttpErrors(status: number = 500) {
-    const mockFetch = jest.fn().mockImplementation(() => 
-        Promise.resolve(
-            new MockResponse({ error: 'Server error' }, { status, statusText: 'Internal Server Error' })
-        )
-    );
-    global.fetch = mockFetch as any;
-    return mockFetch;
-}
-
-/**
- * Clean up mocks after tests
- */
-export function cleanupMocks() {
-    jest.clearAllMocks();
-    // Reset fetch to original if needed
-    if (global.fetch && 'mockRestore' in global.fetch) {
-        (global.fetch as any).mockRestore();
-    }
-}

package/tests/hive-chain-features.spec.ts

@@ -1,319 +0,0 @@
-import { PrivateKey } from '@hiveio/dhive';
-import { Streamer } from '../src/streamer';
-import { Utils } from '../src/utils';
-import { action, defineContract } from '../src/contracts/contract';
-import { createMockAdapter } from './helpers/mock-adapter';
-
-describe('Hive chain features', () => {
-    const activeKey = PrivateKey.fromSeed('hive-stream-active').toString();
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    describe('Utils multisig + escrow helpers', () => {
-        test('broadcastMultiSigOperations signs with multiple keys', async () => {
-            const keyOne = PrivateKey.fromSeed('key-one').toString();
-            const keyTwo = PrivateKey.fromSeed('key-two').toString();
-            const sendOperations = jest.fn().mockResolvedValue({ id: 'tx-id' });
-            const client = {
-                broadcast: {
-                    sendOperations
-                },
-                database: {
-                    getAccounts: jest.fn().mockResolvedValue([{
-                        memo_key: 'STMmemo',
-                        json_metadata: '{}',
-                        posting_json_metadata: '{}'
-                    }])
-                }
-            } as any;
-
-            await Utils.broadcastMultiSigOperations(client, [['vote', { voter: 'alice' }]], [keyOne, keyTwo]);
-
-            const passedKeys = sendOperations.mock.calls[0][1];
-            expect(Array.isArray(passedKeys)).toBe(true);
-            expect(passedKeys).toHaveLength(2);
-        });
-
-        test('updateAccountAuthorities uses account_update2 when posting JSON metadata is provided', async () => {
-            const sendOperations = jest.fn().mockResolvedValue({ id: 'tx-id' });
-            const client = {
-                broadcast: {
-                    sendOperations
-                },
-                database: {
-                    getAccounts: jest.fn().mockResolvedValue([{
-                        memo_key: 'STMmemo',
-                        json_metadata: '{}',
-                        posting_json_metadata: '{}'
-                    }])
-                }
-            } as any;
-
-            await Utils.updateAccountAuthorities(client, { ACTIVE_KEY: activeKey }, 'alice', {
-                active: Utils.createAuthority([[`STM${'1'.repeat(50)}`, 1]], [], 1),
-                posting_json_metadata: '{}'
-            });
-
-            const operation = sendOperations.mock.calls[0][0][0];
-            expect(operation[0]).toBe('account_update2');
-        });
-
-        test('escrowTransfer builds and broadcasts escrow_transfer operation', async () => {
-            const sendOperations = jest.fn().mockResolvedValue({ id: 'tx-id' });
-            const client = {
-                broadcast: {
-                    sendOperations
-                }
-            } as any;
-
-            await Utils.escrowTransfer(client, { ACTIVE_KEY: activeKey }, {
-                from: 'alice',
-                to: 'bob',
-                agent: 'escrow.agent',
-                escrow_id: 42,
-                hive_amount: '1.000 HIVE',
-                hbd_amount: '0.000 HBD',
-                fee: '0.001 HIVE',
-                ratification_deadline: new Date('2025-01-01T00:00:00.000Z'),
-                escrow_expiration: new Date('2025-01-02T00:00:00.000Z'),
-                json_meta: { test: true }
-            });
-
-            const operation = sendOperations.mock.calls[0][0][0];
-            expect(operation[0]).toBe('escrow_transfer');
-            expect(operation[1].escrow_id).toBe(42);
-            expect(operation[1].json_meta).toBe(JSON.stringify({ test: true }));
-            expect(operation[1].ratification_deadline).toBe('2025-01-01T00:00:00');
-            expect(operation[1].escrow_expiration).toBe('2025-01-02T00:00:00');
-        });
-    });
-
-    describe('Streamer operation behavior', () => {
-        let streamer: Streamer;
-
-        beforeEach(async () => {
-            streamer = new Streamer({
-                ACTIVE_KEY: activeKey,
-                JSON_ID: 'testing',
-                PAYLOAD_IDENTIFIER: 'hive_stream',
-                DEBUG_MODE: false
-            });
-
-            await streamer.registerAdapter(createMockAdapter());
-        });
-
-        afterEach(async () => {
-            await streamer.stop();
-        });
-
-        test('transferHiveEngineTokens forwards quantity and symbol in correct order', () => {
-            const spy = jest.spyOn(Utils, 'transferHiveEngineTokens').mockResolvedValue({} as any);
-
-            streamer.transferHiveEngineTokens('alice', 'bob', 'TEST', '1.500', 'memo');
-
-            expect(spy).toHaveBeenCalledWith(
-                expect.anything(),
-                expect.anything(),
-                'alice',
-                'bob',
-                '1.500',
-                'TEST',
-                'memo'
-            );
-        });
-
-        test('onCustomJsonId only fires callbacks for the matching id', async () => {
-            const matching = jest.fn();
-            const nonMatching = jest.fn();
-
-            streamer.onCustomJsonId(matching, 'target-id');
-            streamer.onCustomJsonId(nonMatching, 'other-id');
-
-            await streamer.processOperation([
-                'custom_json',
-                {
-                    id: 'target-id',
-                    json: '{}',
-                    required_auths: ['alice'],
-                    required_posting_auths: []
-                }
-            ], 10, 'block-id', 'prev-id', 'trx-id', new Date());
-
-            expect(matching).toHaveBeenCalledTimes(1);
-            expect(nonMatching).not.toHaveBeenCalled();
-        });
-
-        test('onHiveEngine still fires when tx verification lookup fails', async () => {
-            const handler = jest.fn();
-            const consoleError = jest.spyOn(console, 'error').mockImplementation(() => undefined);
-            const getTransactionInfo = jest.spyOn(streamer['hive'], 'getTransactionInfo')
-                .mockRejectedValue(new Error('temporary hive engine outage'));
-
-            streamer.onHiveEngine(handler);
-
-            await streamer.processOperation([
-                'custom_json',
-                {
-                    id: 'ssc-mainnet-hive',
-                    json: JSON.stringify({
-                        contractName: 'tokens',
-                        contractAction: 'transfer',
-                        contractPayload: {
-                            symbol: 'TEST',
-                            to: 'target',
-                            quantity: '1.000',
-                            memo: 'memo'
-                        }
-                    }),
-                    required_auths: ['alice'],
-                    required_posting_auths: []
-                }
-            ], 20, 'block-20', 'block-19', 'trx-20', new Date('2025-01-01T00:00:00.000Z'));
-
-            expect(getTransactionInfo).toHaveBeenCalledWith('trx-20');
-            expect(handler).toHaveBeenCalledWith(
-                'tokens',
-                'transfer',
-                {
-                    symbol: 'TEST',
-                    to: 'target',
-                    quantity: '1.000',
-                    memo: 'memo'
-                },
-                'alice',
-                expect.objectContaining({ id: 'ssc-mainnet-hive' }),
-                20,
-                'block-20',
-                'block-19',
-                'trx-20',
-                expect.any(Date)
-            );
-
-            consoleError.mockRestore();
-        });
-
-        test('onHiveEngine does not fire when tx verification reports contract errors', async () => {
-            const handler = jest.fn();
-            jest.spyOn(streamer['hive'], 'getTransactionInfo').mockResolvedValue({
-                logs: JSON.stringify({
-                    errors: ['boom']
-                })
-            } as any);
-
-            streamer.onHiveEngine(handler);
-
-            await streamer.processOperation([
-                'custom_json',
-                {
-                    id: 'ssc-mainnet-hive',
-                    json: JSON.stringify({
-                        contractName: 'tokens',
-                        contractAction: 'transfer',
-                        contractPayload: {
-                            symbol: 'TEST',
-                            to: 'target',
-                            quantity: '1.000',
-                            memo: 'memo'
-                        }
-                    }),
-                    required_auths: ['alice'],
-                    required_posting_auths: []
-                }
-            ], 21, 'block-21', 'block-20', 'trx-21', new Date('2025-01-01T00:00:00.000Z'));
-
-            expect(handler).not.toHaveBeenCalled();
-        });
-
-        test('processTransfer forwards block metadata into adapter', async () => {
-            const adapter = createMockAdapter();
-            const processTransferSpy = jest.spyOn(adapter, 'processTransfer');
-            await streamer.registerAdapter(adapter);
-            await streamer.registerContract(defineContract({
-                name: 'sample',
-                actions: {
-                    pay: action(jest.fn(), { trigger: 'transfer' })
-                }
-            }));
-
-            await streamer.processOperation([
-                'transfer',
-                {
-                    from: 'alice',
-                    to: 'bob',
-                    amount: '1.000 HIVE',
-                    memo: JSON.stringify({
-                        hive_stream: {
-                            contract: 'sample',
-                            action: 'pay',
-                            payload: { value: 1 }
-                        }
-                    })
-                }
-            ], 55, 'block-55', 'block-54', 'trx-55', new Date('2025-01-01T00:00:00.000Z'));
-
-            expect(processTransferSpy).toHaveBeenCalledWith(
-                expect.anything(),
-                expect.anything(),
-                expect.objectContaining({
-                    blockNumber: 55,
-                    blockId: 'block-55',
-                    previousBlockId: 'block-54',
-                    transactionId: 'trx-55'
-                })
-            );
-        });
-
-        test('escrow transfer can trigger a contract action via json_meta payload', async () => {
-            const handler = jest.fn();
-            const escrowSub = jest.fn();
-
-            await streamer.registerContract(defineContract({
-                name: 'escrowcontract',
-                actions: {
-                    create: action(handler, { trigger: 'escrow_transfer' })
-                }
-            }));
-
-            streamer.onEscrowTransfer(escrowSub);
-
-            await streamer.processOperation([
-                'escrow_transfer',
-                {
-                    from: 'alice',
-                    to: 'bob',
-                    agent: 'escrow.agent',
-                    escrow_id: 99,
-                    hive_amount: '1.000 HIVE',
-                    hbd_amount: '0.000 HBD',
-                    fee: '0.001 HIVE',
-                    ratification_deadline: '2025-01-01T00:00:00',
-                    escrow_expiration: '2025-01-02T00:00:00',
-                    json_meta: JSON.stringify({
-                        hive_stream: {
-                            contract: 'escrowcontract',
-                            action: 'create',
-                            payload: {
-                                orderId: 'A-1'
-                            }
-                        }
-                    })
-                }
-            ], 100, 'block-100', 'block-99', 'trx-100', new Date('2025-01-01T00:00:00.000Z'));
-
-            expect(handler).toHaveBeenCalledWith(
-                { orderId: 'A-1' },
-                expect.objectContaining({
-                    trigger: 'escrow_transfer',
-                    sender: 'alice',
-                    escrow: expect.objectContaining({
-                        type: 'escrow_transfer',
-                        escrowId: 99
-                    })
-                })
-            );
-            expect(escrowSub).toHaveBeenCalledTimes(1);
-        });
-    });
-});