@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/AlchemyWebhooks.js

@@ -0,0 +1,406 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AlchemyErrors_1 = __importDefault(require("../errors/AlchemyErrors"));
+const ChainManager_1 = __importDefault(require("./ChainManager"));
+const AlchemyService_1 = __importDefault(require("./AlchemyService"));
+const alchemy_1 = require("./utils/alchemy");
+const graphql_1 = require("./utils/graphql");
+const EscrowService = __importStar(require("./solana/escrow/services/EscrowService"));
+const Wallets_1 = require("../utils/Wallets");
+const web3_js_1 = require("@solana/web3.js");
+const Logger_1 = require("../utils/Logger");
+class AlchemyWebhooks {
+    constructor(config, dbPool) {
+        this.initialize = (env, server_host, networks) => __awaiter(this, void 0, void 0, function* () {
+            if (!env)
+                env = "prod";
+            const report = yield this.validate_setup(env);
+            let new_webhooks = [];
+            // create missing webhook
+            if (report.failed.length) {
+                this.logger.info(`Creating ${report.failed.length} missing ADDRESS_ACTIVITY webhooks`);
+                const is_created = yield this.create_webhooks(env, report.failed, server_host);
+                if (is_created.length > 0) {
+                    new_webhooks.push(...is_created);
+                    this.logger.info(`Successfully created ${report.failed.length} missing ADDRESS_ACTIVITY webhooks.`);
+                }
+            }
+            // // Create missing graphql webhooks
+            if (report.failed_graphql.length) {
+                this.logger.info(`Creating ${report.failed_graphql.length} missing GRAPHQL webhooks`);
+                const is_created = yield this.create_webhooks(env, report.failed_graphql, server_host);
+                if (is_created.length > 0) {
+                    new_webhooks.push(...is_created);
+                    this.logger.info(`Successfully created ${report.failed.length} missing GRAPHQL webhooks.`);
+                }
+            }
+            if (this.config.config.useTunnel) {
+                this.logger.info(`Validating local setup.`);
+                const report_dev = yield this.validate_setup("local");
+                if (report_dev.failed.length) {
+                    this.logger.info(`LOCAL: Creating ${report_dev.failed.length} missing ADDRESS_ACTIVITY webhooks`);
+                    const is_created = yield this.create_webhooks("local", report_dev.failed);
+                    if (is_created.length > 0) {
+                        new_webhooks.push(...is_created);
+                        this.logger.info(`LOCAL: Successfully created ${report_dev.failed.length} missing ADDRESS_ACTIVITY webhooks.`);
+                    }
+                }
+                if (report_dev.failed_graphql.length) {
+                    this.logger.info(`LOCAL: Creating ${report_dev.failed_graphql.length} missing GRAPHQL webhooks`);
+                    const is_created = yield this.create_webhooks("local", report_dev.failed_graphql);
+                    if (is_created.length > 0) {
+                        new_webhooks.push(...is_created);
+                        this.logger.info(`LOCLA: Successfully created ${report_dev.failed_graphql.length} missing GRAPHQL webhooks.`);
+                    }
+                }
+            }
+            this.logger.info(`Validated and initialized Alchemy webhooks.`);
+            return { new_webhooks, prod: [...report.success, ...report.success_graphql], dev: [...report.success, ...report.success_graphql] };
+        });
+        // TODO: Get requirements from config file
+        this.validate_setup = (env) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const alchemyService = AlchemyService_1.default.getInstance(this.config);
+                const required_custodial_webhooks = this.get_required_webhook_count_per_network(env);
+                const requiredAlchemyNetworks = required_custodial_webhooks.map(c => c.chainId);
+                const webhooks = yield alchemyService.get_all_webhooks(env);
+                const alchemyNetworks = requiredAlchemyNetworks
+                    .map((chainId) => (0, alchemy_1.get_alchemy_chain_name)(chainId)).filter((network) => network !== null);
+                let success_ = [];
+                let failed_ = [];
+                let success_graphql_webhooks = [];
+                let failed_graphql_webhooks = [];
+                // Validate "Address activity" webhook type
+                for (const network of alchemyNetworks) {
+                    // Find webhooks matching required chains
+                    const matching_webhooks = webhooks
+                        .filter((webhook) => webhook.network === network && webhook.webhook_type === "ADDRESS_ACTIVITY");
+                    // Get network settings 
+                    const settings = required_custodial_webhooks.find((setting) => setting.network === network);
+                    if (!settings) {
+                        throw new Error(`Settings not found for network ${network}`);
+                    }
+                    // Calculate estimated webhook count for given total wallet address count
+                    let total_wallet_count = (settings === null || settings === void 0 ? void 0 : settings.total_wallet_count) || 0;
+                    let required_webhook_count = Math.floor(total_wallet_count / 100000) + 1;
+                    // Identify missing webhooks
+                    if (matching_webhooks.length < required_webhook_count) {
+                        failed_.push({
+                            network: network,
+                            required: required_webhook_count,
+                            available: matching_webhooks.length,
+                            networkSymbol: settings.network_symbol,
+                            chainId: settings.chainId,
+                            targetWebhookType: "ADDRESS_ACTIVITY",
+                            endpoint: settings.endpoint,
+                            source: settings.source
+                        });
+                        continue;
+                    }
+                    success_.push({
+                        network,
+                        required: required_webhook_count,
+                        available: matching_webhooks.length,
+                        networkSymbol: settings.network_symbol,
+                        chainId: settings.chainId,
+                        targetWebhookType: "ADDRESS_ACTIVITY",
+                        endpoint: settings.endpoint,
+                        source: settings.source
+                    });
+                }
+                const required_escrow_config = this.get_required_esrow_webhook_config(env);
+                for (const chain of required_escrow_config) {
+                    // Try to find existing webhook
+                    const matching_webhooks = webhooks
+                        .filter((webhook) => webhook.network === chain.network &&
+                        webhook.webhook_type === chain.type
+                        && webhook.webhook_url.includes("escrow-events") // this will match the webhooks configured for contract listening
+                    );
+                    // Fetch the configured settings for current network
+                    const settings = required_custodial_webhooks.find((setting) => setting.network === chain.network);
+                    if (!settings) {
+                        throw new Error(`Settings not found for network ${chain.network}`);
+                    }
+                    // Only need 1 webhook for each escrow contract
+                    const required_webhook_count = 1;
+                    if (matching_webhooks.length < required_webhook_count) {
+                        failed_graphql_webhooks.push({
+                            network: chain.network,
+                            required: required_webhook_count,
+                            available: matching_webhooks.length,
+                            networkSymbol: chain.network_symbol,
+                            chainId: chain.chainId,
+                            targetWebhookType: chain.type,
+                            endpoint: chain.endpoint,
+                            source: chain.source
+                        });
+                        continue;
+                    }
+                    // Push to successful list if webhook exists
+                    success_graphql_webhooks.push({
+                        network: chain.network,
+                        required: 1,
+                        available: matching_webhooks.length,
+                        networkSymbol: settings.network_symbol,
+                        chainId: settings.chainId,
+                        targetWebhookType: chain.type,
+                        endpoint: chain.endpoint,
+                        source: settings.source
+                    });
+                }
+                // Log missing webhooks 
+                if (failed_.length > 0 || failed_graphql_webhooks.length > 0) {
+                    this.logger.info(`Some webhhooks are not set up properly.`, { data: { failed_address_activity: failed_, failed_graphql: failed_graphql_webhooks } });
+                }
+                return { success: success_, failed: failed_, success_graphql: success_graphql_webhooks, failed_graphql: failed_graphql_webhooks };
+            }
+            catch (error) {
+                this.logger.error(`[AlchemyWebhooks] Error validating webhook setup.`, { data: { subscription: env } });
+                throw error;
+            }
+        });
+        this.create_webhooks = (subscription, webhooks, receiver_host) => __awaiter(this, void 0, void 0, function* () {
+            const promises = yield Promise.allSettled(webhooks.map((webhook) => __awaiter(this, void 0, void 0, function* () {
+                const base_url = receiver_host ? receiver_host : `${this.base_webhook_host(subscription)}`;
+                const full_webhook_url = `${base_url}/${webhook.endpoint}`;
+                const alchemy_service = AlchemyService_1.default.getInstance(this.config);
+                // Get network name compatible for Alchemy network names
+                const network_name = (0, alchemy_1.get_alchemy_chain_name)(webhook.chainId);
+                if (!network_name) {
+                    throw new Error(this.errors.UnsupportedAlchemyNetwork(webhook.chainId));
+                }
+                // Find escrow contract address
+                let contract_address = null;
+                if (webhook.targetWebhookType === "GRAPHQL") {
+                    const chain_manager = ChainManager_1.default.getInstance(this.config);
+                    const escrow_config = yield chain_manager.getEscrowContractForChain(parseInt(webhook.chainId));
+                    contract_address = escrow_config.addresses[0];
+                }
+                // Construct payload
+                const payload = {
+                    network: webhook.network,
+                    webhook_type: webhook.targetWebhookType,
+                    webhook_url: full_webhook_url,
+                    addresses: [],
+                };
+                // Add the graphql query to the payload
+                if (webhook.targetWebhookType === "GRAPHQL" && contract_address) {
+                    if (!contract_address)
+                        throw new Error(this.errors.NotFound("escrow contract address"));
+                    payload.graphql_query = {
+                        query: (0, graphql_1.all_contract_events_query)(contract_address),
+                        skip_empty_messages: true
+                    };
+                }
+                // TODO replace hardcoded route with config
+                // Add the vault ATA address to webhook
+                if (webhook.targetWebhookType === "ADDRESS_ACTIVITY" &&
+                    (webhook.network === "SOLANA_DEVNET" || webhook.network === "SOLANA_MAINNET") &&
+                    webhook.source === "contract" &&
+                    webhook.endpoint.includes(`/solana/escrow-events/${subscription}`) // TODO replace hardcoded route with config
+                ) {
+                    const chain_manager = ChainManager_1.default.getInstance(this.config);
+                    const escrow_config = yield chain_manager.getEscrowContractForChain(parseInt(webhook.chainId));
+                    const escrow_program_pubkey = new web3_js_1.PublicKey((0, Wallets_1.normalizeAddress)(escrow_config.addresses[0], "solana"));
+                    const vault_ata = EscrowService.findVaultAuthorityPda(escrow_program_pubkey);
+                    payload.addresses = [vault_ata.toString()];
+                }
+                // Create webhook
+                console.log(`Payload :`, payload);
+                const new_webhook = yield alchemy_service.create_webhook(subscription, payload);
+                return { webhook_id: new_webhook.id, signing_key: new_webhook.signing_key };
+            })));
+            const resolved = promises
+                .filter(r => r.status === 'fulfilled')
+                .map(r => r.value);
+            return resolved;
+        });
+        // Get the configuraiton for listening to escrow contracts
+        this.get_required_esrow_webhook_config = (env) => {
+            const escrow_webhook_config = ChainManager_1.default.getInstance(this.config).escrowAlchemyWebhooks;
+            const configured_webhook_config = escrow_webhook_config.map(c => (Object.assign(Object.assign({}, c), { endpoint: `${c.endpoint}/${env}` })));
+            return configured_webhook_config;
+        };
+        // TODO fix this to get real wallet count from db
+        this.get_required_webhook_count_per_network = (env) => {
+            const custodial_webhook_config = ChainManager_1.default.getInstance(this.config).custodialAlchemyWebhooks;
+            if (!custodial_webhook_config.length)
+                return [];
+            // Get wallet counts for each chain id and override here
+            const configured_custodial_webhook_config = custodial_webhook_config.map(c => (Object.assign(Object.assign({}, c), { endpoint: `${c.endpoint}/${env}` })));
+            return configured_custodial_webhook_config;
+        };
+        this.config = config;
+        this.dbPool = dbPool;
+        this.base_webhook_endpoint = (env, type = "ADDRESS_ACTIVITY") => {
+            if (type === "ADDRESS_ACTIVITY")
+                return `webhook/alchemy/${env}/address-activity`;
+            else if (type === "GRAPHQL")
+                return `webhook/alchemy/${env}/escrow-events`;
+            throw new Error(this.errors.UnsupportedResource("Webhook type"));
+        };
+        this.base_webhook_host = (env) => { return env === 'prod' ? this.config.config.host : this.config.config.tunnel; };
+        this.errors = new AlchemyErrors_1.default();
+        this.logger = (0, Logger_1.createLogger)(`AlchemyWebhooks`, this.config.pipelineConfig.azureAppName);
+    }
+    static getInstance(config, dbPool) {
+        if (!this.instance) {
+            this.instance = new AlchemyWebhooks(config, dbPool);
+        }
+        return this.instance;
+    }
+    get_network_symbol_for_alchemy_network_name(network, env) {
+        const required_webhook_count_per_network = this.get_required_webhook_count_per_network(env);
+        const settings = required_webhook_count_per_network.find((setting) => setting.network === network);
+        if (!settings) {
+            throw new Error(`Settings not found for network ${network}`);
+        }
+        return settings.network_symbol;
+    }
+    sync_all_addresses_to_webhooks(subscription) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // TODO: Get those blockchains from chains config
+                const blockchains = ["evm", "solana"];
+                const promises = yield Promise.allSettled(blockchains.map((blockchain) => __awaiter(this, void 0, void 0, function* () {
+                    const result = yield this.syncDepositAddressesToWebhooks(subscription, blockchain);
+                    if (!result.status) {
+                        return { blockchain, status: false, count: 0 };
+                    }
+                    return { blockchain, status: true, count: result };
+                })));
+                const resolved = promises
+                    .filter(result => result.status === 'fulfilled')
+                    .map(result => result.value);
+                const success = resolved
+                    .filter(result => result.status === true);
+                const failed = resolved
+                    .filter(result => result.status === false);
+                if (resolved.length !== blockchains.length) {
+                    throw new Error(`Failed to add deposit addresses to some blockchains: `);
+                }
+                return { resolved, failed, success, expected_success: blockchains.length };
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    syncDepositAddressesToWebhooks(env, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logger.info(`=== Starting Deposit Address Sync to Webhooks ===`);
+                const BATCH_SIZE = 1000; // Process 1000 addresses at a time
+                const depositAddressRepo = this.dbPool.accountsRepo;
+                if (!depositAddressRepo) {
+                    throw new Error(this.errors.NotInitializedOrmRepo("DepositAddress"));
+                }
+                // Get total count of EVM addresses
+                const totalAddresses = yield depositAddressRepo.count({
+                    where: {
+                        blockchain: blockchain // Fetch relevant wallet addresses by blockchain type
+                    }
+                });
+                const alchemy_service = AlchemyService_1.default.getInstance(this.config);
+                const all_webhooks = (yield alchemy_service.get_all_webhooks(env)).filter((result) => (0, alchemy_1.get_blockchain_type)(result.network) === blockchain);
+                if (!all_webhooks) {
+                    throw new Error(this.errors.NoWebhooks(env));
+                }
+                let failed = [];
+                let success_count = 0;
+                let failed_count = 0;
+                let action_success_count = 0;
+                let action_failed_count = 0;
+                // Process in batches
+                for (let skip = 0; skip < totalAddresses; skip += BATCH_SIZE) {
+                    // Get batch of addresses
+                    const addresses = yield depositAddressRepo.find({
+                        where: {
+                            blockchain: blockchain
+                        },
+                        select: ['address'], // Only select the address field
+                        skip: skip,
+                        take: BATCH_SIZE
+                    });
+                    const addressList = addresses.map(addr => addr.address);
+                    // Add addresses to all webhooks
+                    try {
+                        const alchemyService = AlchemyService_1.default.getInstance(this.config);
+                        yield alchemyService.add_remove_addresses_all_webhooks(env, blockchain, addressList, []);
+                        success_count++;
+                        action_success_count += addressList.length;
+                    }
+                    catch (error) {
+                        // TODO: Handle log with elastic search
+                        // Continue with next batch
+                        action_failed_count += addressList.length;
+                        this.logger.error(`Failed to add batch starting at ${skip}:`, { data: { error } });
+                        failed.push({ start: skip, batchSize: BATCH_SIZE, addresses: addressList });
+                    }
+                    // Add a small delay to prevent rate limiting
+                    yield new Promise(resolve => setTimeout(resolve, 300));
+                }
+                this.logger.info(`=== Completed Deposit Address Sync to Webhooks ===`);
+                return {
+                    status: true,
+                    count: totalAddresses,
+                    success_count: success_count,
+                    failed_count,
+                    failed_address_count: action_failed_count,
+                    success_address_count: action_success_count,
+                    failed
+                };
+            }
+            catch (error) {
+                this.logger.error(`[AlchemyWebhooks] Error syncing deposit addresses to webhooks:`, { data: { error } });
+                throw error;
+            }
+        });
+    }
+}
+exports.default = AlchemyWebhooks;

package/build/services/AsyncTTLCache.d.ts

@@ -0,0 +1,12 @@
+declare class AsyncTTLCache {
+    static instance: AsyncTTLCache;
+    private inflight;
+    stale_time_ms: number;
+    private cache;
+    private constructor();
+    static getInstance(): AsyncTTLCache;
+    private resolve_inflight;
+    get_value<K, V>(key: string, data: K, fetch_task: (data: K) => Promise<V>): Promise<any>;
+}
+export default AsyncTTLCache;
+//# sourceMappingURL=AsyncTTLCache.d.ts.map

package/build/services/AsyncTTLCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncTTLCache.d.ts","sourceRoot":"","sources":["../../src/services/AsyncTTLCache.ts"],"names":[],"mappings":"AAOA,cAAM,aAAa;IACf,MAAM,CAAC,QAAQ,EAAE,aAAa,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAwC;IAEjD,aAAa,EAAE,MAAM,CAAC;IAE7B,OAAO,CAAC,KAAK,CAAmB;IAEhC,OAAO;IAKP,MAAM,CAAC,WAAW;YAYJ,gBAAgB;IAUjB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;CA+BzF;AAED,eAAe,aAAa,CAAC"}

package/build/services/AsyncTTLCache.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+class AsyncTTLCache {
+    constructor(stale_time_in_ms = 60000) {
+        this.inflight = new Map(); // Track requests in process of fetching price
+        this.stale_time_ms = stale_time_in_ms + Math.random() * 5000;
+        this.cache = new Map();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new AsyncTTLCache();
+        }
+        return this.instance;
+    }
+    // Handle error from external price provider (fetch task)
+    // Returns stale price on error 
+    // Throws error if no stale price in memory and provider threw an exception
+    resolve_inflight(key, existing_price) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolved = yield this.inflight.get(key);
+            if (resolved === undefined || resolved === null) {
+                if (!existing_price)
+                    throw new Error(`AsyncTTLCache: Error fetching fresh price from DB for key: ${key}`);
+                return existing_price.value;
+            }
+            return resolved;
+        });
+    }
+    get_value(key, data, fetch_task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let existing_entry = this.cache.get(key);
+            let now = new Date().getTime();
+            // Return cached value
+            if (existing_entry && now - existing_entry.last_update <= this.stale_time_ms) {
+                return existing_entry.value;
+            }
+            if (!existing_entry || now - existing_entry.last_update > this.stale_time_ms) {
+                if (this.inflight.has(key)) {
+                    return yield this.resolve_inflight(key, existing_entry);
+                }
+                const promise = fetch_task(data);
+                this.inflight.set(key, promise);
+                try {
+                    const updated = yield promise;
+                    this.inflight.delete(key);
+                    this.cache.set(key, { key, value: updated, last_update: now });
+                    return updated;
+                }
+                finally {
+                    this.inflight.delete(key);
+                }
+            }
+            return existing_entry.value;
+        });
+    }
+}
+exports.default = AsyncTTLCache;

package/build/services/AzureEventHubHandler.d.ts

@@ -0,0 +1,32 @@
+import { EventHubProducerClient } from '@azure/event-hubs';
+import { EventHubNames, EventModel, EventObject } from '../interfaces';
+import { IConfig } from '../interfaces/config';
+import { ActiveEventNames } from './types';
+export default class AzureEventHubHandler {
+    eventHubClients: Map<any, any>;
+    private config;
+    events_notificationsHubNames: EventHubNames[];
+    event_name_to_event_hub_name: Record<keyof ActiveEventNames, EventHubNames>;
+    private logger;
+    constructor(_config: IConfig);
+    private initializeEventHubClients;
+    getEventHubNames(): {
+        names: string[];
+        clients: any[];
+    };
+    /**
+     * Send event object via `EventHubProducerClient` using the respective event hub name as in `eventData.eventName` property
+     * @param eventData Event object to be produced
+     * @returns Promise resolving to a `boolean` status
+     */
+    sendEvent(eventData: EventModel): Promise<boolean>;
+    sendEventBatch(eventData: EventObject[], client: EventHubProducerClient): Promise<boolean>;
+    /**
+     * Gets the respective event hub client instance
+     * _Deprecated. Use `new EventHubProducerClient` directly instead._
+     * @param eventName
+     * @returns Event hub producer client object
+     */
+    getEventHubClient(eventName: keyof ActiveEventNames): Promise<any>;
+}
+//# sourceMappingURL=AzureEventHubHandler.d.ts.map

package/build/services/AzureEventHubHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AzureEventHubHandler.d.ts","sourceRoot":"","sources":["../../src/services/AzureEventHubHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,oBAAoB;IAC9B,eAAe,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IACrC,OAAO,CAAC,MAAM,CAAU;IACjB,4BAA4B,EAAE,aAAa,EAAE,CAAC;IAC9C,4BAA4B,EAAE,MAAM,CAAC,MAAM,gBAAgB,EAAE,aAAa,CAAC,CAAC;IACnF,OAAO,CAAC,MAAM,CAAS;gBAGX,OAAO,EAAE,OAAO;IAiC5B,OAAO,CAAC,yBAAyB;IAajC,gBAAgB;;;;IAchB;;;;OAIG;IACG,SAAS,CAAC,SAAS,EAAE,UAAU;IAwC/B,cAAc,CAAC,SAAS,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,sBAAsB;IAwB7E;;;;;OAKG;IACG,iBAAiB,CAAC,SAAS,EAAE,MAAM,gBAAgB;CAU5D"}

package/build/services/AzureEventHubHandler.js

@@ -0,0 +1,139 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_hubs_1 = require("@azure/event-hubs");
+const Logger_1 = require("../utils/Logger");
+class AzureEventHubHandler {
+    // Initialize clients
+    constructor(_config) {
+        this.config = _config;
+        this.eventHubClients = new Map();
+        // TODO: Either remove or use the resulting this.eventHubClients in `sendEvent`
+        this.events_notificationsHubNames = [
+            this.config.config.depositEventHubName,
+            this.config.config.withdrawalEventHubName,
+            this.config.config.transferLogsRawEventHubName
+        ];
+        if (!this.config.config.depositEventHubName
+            || !this.config.config.withdrawalEventHubName
+            || !this.config.config.transferLogsRawEventHubName)
+            throw new Error(`Event hub names not initialized in config`);
+        // Event hub names
+        this.event_name_to_event_hub_name = {
+            Deposit: this.config.config.depositEventHubName,
+            Withdrawal: this.config.config.withdrawalEventHubName,
+            LowReserves: 'eventsstream',
+            CoverageInfo: 'eventsstream',
+            RoleGranted: this.config.config.rolesEventHubName,
+            RoleRevoked: this.config.config.rolesEventHubName,
+            TransferLogsRaw: this.config.config.transferLogsRawEventHubName,
+        };
+        this.logger = (0, Logger_1.createLogger)("AzureEventHubHandler", this.config.pipelineConfig.azureAppName);
+        this.initializeEventHubClients();
+    }
+    // Must deprecate this implementation since `EventHubProducerClient` is used directly where needed
+    initializeEventHubClients() {
+        for (let eventHubName of this.events_notificationsHubNames) {
+            try {
+                const client = new event_hubs_1.EventHubProducerClient(this.config.config.azureConnectionStringNotifications, eventHubName, { retryOptions: { retryDelayInMs: 10000 } });
+                this.eventHubClients.set(eventHubName, client);
+            }
+            catch (error) {
+                this.logger.error(`Failed to initialize client for: ${eventHubName}`, { data: { error } });
+            }
+        }
+    }
+    //Gets all event hub names and clients
+    getEventHubNames() {
+        let names = [];
+        let clients = [];
+        for (let eventHubName of this.events_notificationsHubNames) {
+            let key = eventHubName;
+            names.push(key);
+            clients.push(this.eventHubClients.get(key));
+        }
+        return { names, clients };
+    }
+    /**
+     * Send event object via `EventHubProducerClient` using the respective event hub name as in `eventData.eventName` property
+     * @param eventData Event object to be produced
+     * @returns Promise resolving to a `boolean` status
+     */
+    sendEvent(eventData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const eventHubName = this.event_name_to_event_hub_name[eventData.eventName];
+            if (!eventHubName) {
+                this.logger.info(`[AzureEventHubHandler]: Event hub name not found for ${eventData.eventName} event. Skipping...`);
+                return false;
+            }
+            const clientDefault = new event_hubs_1.EventHubProducerClient(this.config.config.azureConnectionStringNotifications, eventHubName, { retryOptions: { retryDelayInMs: 10000 } });
+            const eventDataBatch = yield clientDefault.createBatch();
+            const eventDataBatchStatus = eventDataBatch.tryAdd({ body: eventData });
+            let status = false;
+            try {
+                yield clientDefault.sendBatch(eventDataBatch);
+                this.logger.info(`Event sent to Azure Hub Successfully: ${eventData.eventName} ${eventData.txHash ? eventData.txHash : ""}`);
+                status = true;
+            }
+            catch (err) {
+                this.logger.error(`Error sending event: ${eventData}`, { data: { error: err, eventData } });
+            }
+            try {
+                yield clientDefault.close();
+            }
+            catch (error) {
+                this.logger.error(`Error closing azure client.`, { data: { error, eventData } });
+                return false;
+            }
+            if (!status) {
+                return false;
+            }
+            return true;
+        });
+    }
+    sendEventBatch(eventData, client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const eventDataBatch = yield client.createBatch();
+            for (let event of eventData) {
+                eventDataBatch.tryAdd({ body: event });
+            }
+            this.logger.info(`Added ${eventData.length} events to batch`);
+            try {
+                // Send batch to event hub
+                yield client.sendBatch(eventDataBatch);
+                this.logger.info(`Event sent to Azure Hub Successfully.`);
+            }
+            catch (err) {
+                this.logger.error(`Error sending event: ${eventData}`, { data: { error: err } });
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Gets the respective event hub client instance
+     * _Deprecated. Use `new EventHubProducerClient` directly instead._
+     * @param eventName
+     * @returns Event hub producer client object
+     */
+    getEventHubClient(eventName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.eventHubClients.get(this.event_name_to_event_hub_name[eventName]);
+            }
+            catch (error) {
+                this.logger.error(`Error retrieving eventHubClient ${error}.`, { data: { error } });
+                throw error;
+            }
+        });
+    }
+}
+exports.default = AzureEventHubHandler;