@ercworldio/blockchain-shared 1.0.0-dev.9 → 1.0.1-dev.0

package/build/services/quicknode-notifications/QnWebhookAddressManager.js

@@ -0,0 +1,265 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ChainManager_1 = __importDefault(require("../ChainManager"));
+const QnNotificationsApi_1 = __importDefault(require("./QnNotificationsApi"));
+const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+class QnWebhookAddressManager {
+    constructor(config, rlc) {
+        this.cache = new Map();
+        this.config = config;
+        this.api = QnNotificationsApi_1.default.getInstance(config, rlc);
+    }
+    static getInstance(config, rlc) {
+        if (!this.instance) {
+            this.instance = new QnWebhookAddressManager(config, rlc);
+        }
+        return this.instance;
+    }
+    get_blockchain_for_chain(chain_id) {
+        var _a, _b;
+        const cfg = (_a = ChainManager_1.default.getInstance(this.config).contractsMap) === null || _a === void 0 ? void 0 : _a[chain_id.toString()];
+        return (_b = cfg === null || cfg === void 0 ? void 0 : cfg.blockchainType) !== null && _b !== void 0 ? _b : null;
+    }
+    /** Returns the { name, network } pairs for the notification configs of a given chain. */
+    get_webhook_keys_for_chain(chain_id) {
+        var _a, _b, _c;
+        const cfg = (_a = ChainManager_1.default.getInstance(this.config).contractsMap) === null || _a === void 0 ? void 0 : _a[chain_id.toString()];
+        return (_c = (_b = cfg === null || cfg === void 0 ? void 0 : cfg.quicknodeNotificationConfig) === null || _b === void 0 ? void 0 : _b.map(n => ({
+            name: n.name.toLowerCase(),
+            network: n.network.toLowerCase(),
+        }))) !== null && _c !== void 0 ? _c : [];
+    }
+    get_notif_configs(blockchain) {
+        const chain_manager = ChainManager_1.default.getInstance(this.config);
+        if (!chain_manager.contractsMap)
+            return [];
+        return Object.entries(chain_manager.contractsMap)
+            .filter(([_, cfg]) => {
+            var _a;
+            return cfg.blockchainType === blockchain &&
+                ((_a = cfg.quicknodeNotificationConfig) === null || _a === void 0 ? void 0 : _a.length) > 0;
+        })
+            .flatMap(([_, cfg]) => cfg.quicknodeNotificationConfig.map(n => (Object.assign(Object.assign({}, n), { blockchain: cfg.blockchainType }))))
+            .filter((n, i, arr) => arr.findIndex(x => x.name === n.name) === i);
+    }
+    is_stale(blockchain) {
+        const cached = this.cache.get(blockchain);
+        if (!cached)
+            return true;
+        return Date.now() - cached.loaded_at > CACHE_TTL_MS;
+    }
+    load(blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const notif_configs = this.get_notif_configs(blockchain);
+            if (notif_configs.length === 0)
+                return;
+            let all_webhooks = [];
+            try {
+                const res = yield this.api.get_all_webhooks();
+                all_webhooks = res.data || [];
+            }
+            catch (error) {
+                console.error(`QnWebhookAddressManager: Failed to fetch webhooks for blockchain=${blockchain}`, error);
+                return;
+            }
+            const entries = [];
+            for (const notif_config of notif_configs) {
+                const existing = all_webhooks.find(w => {
+                    var _a, _b;
+                    return ((_a = w.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === notif_config.name.toLowerCase() &&
+                        ((_b = w.network) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === notif_config.network.toLowerCase();
+                });
+                if (!existing) {
+                    console.warn(`QnWebhookAddressManager: No webhook found for config=${notif_config.name} network=${notif_config.network}`);
+                    continue;
+                }
+                const arg_key = notif_config.template === 'solanaWalletFilter' ? 'accounts' : 'wallets';
+                const addresses = ((_a = existing.templateArgs) === null || _a === void 0 ? void 0 : _a[arg_key]) || [];
+                entries.push({
+                    webhook_id: existing.id,
+                    name: notif_config.name.toLowerCase(),
+                    template: notif_config.template,
+                    network: notif_config.network.toLowerCase(),
+                    address_set: new Set(addresses),
+                });
+            }
+            this.cache.set(blockchain, { entries, loaded_at: Date.now() });
+        });
+    }
+    ensure_loaded(blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.is_stale(blockchain)) {
+                yield this.load(blockchain);
+            }
+            return ((_a = this.cache.get(blockchain)) === null || _a === void 0 ? void 0 : _a.entries) || [];
+        });
+    }
+    matches_key(entry, key) {
+        return entry.name === key.name && entry.network === key.network;
+    }
+    add_address(blockchain, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = yield this.ensure_loaded(blockchain);
+            for (const entry of entries) {
+                if (entry.address_set.has(address))
+                    continue;
+                entry.address_set.add(address);
+                try {
+                    yield this.api.update_webhook_addresses(entry.webhook_id, entry.template, Array.from(entry.address_set));
+                    console.log(`QnWebhookAddressManager: Added ${address} to ${entry.name} webhook`);
+                }
+                catch (error) {
+                    entry.address_set.delete(address);
+                    console.error(`QnWebhookAddressManager: Failed to add ${address} to ${entry.name}`, error);
+                    throw error;
+                }
+            }
+            return true;
+        });
+    }
+    remove_address(blockchain, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = yield this.ensure_loaded(blockchain);
+            for (const entry of entries) {
+                if (!entry.address_set.has(address))
+                    continue;
+                entry.address_set.delete(address);
+                try {
+                    yield this.api.update_webhook_addresses(entry.webhook_id, entry.template, Array.from(entry.address_set));
+                    console.log(`QnWebhookAddressManager: Removed ${address} from ${entry.name} webhook`);
+                }
+                catch (error) {
+                    entry.address_set.add(address);
+                    console.error(`QnWebhookAddressManager: Failed to remove ${address} from ${entry.name}`, error);
+                    throw error;
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * Add an address to the webhook(s) for a single chain only.
+     * Matches by both name and network to avoid cross-service contamination.
+     * Use this for the immediate await before responding to the caller.
+     */
+    add_address_to_chain(chain_id, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blockchain = this.get_blockchain_for_chain(chain_id);
+            if (!blockchain)
+                return false;
+            const keys = this.get_webhook_keys_for_chain(chain_id);
+            const entries = (yield this.ensure_loaded(blockchain))
+                .filter(e => keys.some(k => this.matches_key(e, k)));
+            for (const entry of entries) {
+                if (entry.address_set.has(address))
+                    continue;
+                entry.address_set.add(address);
+                try {
+                    yield this.api.update_webhook_addresses(entry.webhook_id, entry.template, Array.from(entry.address_set));
+                    console.log(`QnWebhookAddressManager: Added ${address} to ${entry.name} webhook (chain ${chain_id})`);
+                }
+                catch (error) {
+                    entry.address_set.delete(address);
+                    console.error(`QnWebhookAddressManager: Failed to add ${address} to ${entry.name}`, error);
+                    throw error;
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * Remove an address from the webhook(s) for a single chain only.
+     * Matches by both name and network to avoid cross-service contamination.
+     * Use this for the immediate await before responding to the caller.
+     */
+    remove_address_from_chain(chain_id, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blockchain = this.get_blockchain_for_chain(chain_id);
+            if (!blockchain)
+                return false;
+            const keys = this.get_webhook_keys_for_chain(chain_id);
+            const entries = (yield this.ensure_loaded(blockchain))
+                .filter(e => keys.some(k => this.matches_key(e, k)));
+            for (const entry of entries) {
+                if (!entry.address_set.has(address))
+                    continue;
+                entry.address_set.delete(address);
+                try {
+                    yield this.api.update_webhook_addresses(entry.webhook_id, entry.template, Array.from(entry.address_set));
+                    console.log(`QnWebhookAddressManager: Removed ${address} from ${entry.name} webhook (chain ${chain_id})`);
+                }
+                catch (error) {
+                    entry.address_set.add(address);
+                    console.error(`QnWebhookAddressManager: Failed to remove ${address} from ${entry.name}`, error);
+                    throw error;
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * Add an address to all webhooks for a blockchain except the already-updated chain.
+     * Excludes by both name and network so only the exact webhooks for that chain are skipped.
+     * Call this fire-and-forget after responding to the caller.
+     */
+    sync_add_to_remaining(blockchain, address, exclude_chain_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exclude_keys = this.get_webhook_keys_for_chain(exclude_chain_id);
+            const entries = (yield this.ensure_loaded(blockchain))
+                .filter(e => !exclude_keys.some(k => this.matches_key(e, k)));
+            for (const entry of entries) {
+                if (entry.address_set.has(address))
+                    continue;
+                entry.address_set.add(address);
+                try {
+                    yield this.api.update_webhook_addresses(entry.webhook_id, entry.template, Array.from(entry.address_set));
+                    console.log(`QnWebhookAddressManager: Synced add ${address} to ${entry.name} webhook`);
+                }
+                catch (error) {
+                    entry.address_set.delete(address);
+                    console.error(`QnWebhookAddressManager: Sync add failed for ${entry.name}`, error);
+                }
+            }
+        });
+    }
+    /**
+     * Remove an address from all webhooks for a blockchain except the already-updated chain.
+     * Excludes by both name and network so only the exact webhooks for that chain are skipped.
+     * Call this fire-and-forget after responding to the caller.
+     */
+    sync_remove_from_remaining(blockchain, address, exclude_chain_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exclude_keys = this.get_webhook_keys_for_chain(exclude_chain_id);
+            const entries = (yield this.ensure_loaded(blockchain))
+                .filter(e => !exclude_keys.some(k => this.matches_key(e, k)));
+            for (const entry of entries) {
+                if (!entry.address_set.has(address))
+                    continue;
+                entry.address_set.delete(address);
+                try {
+                    yield this.api.update_webhook_addresses(entry.webhook_id, entry.template, Array.from(entry.address_set));
+                    console.log(`QnWebhookAddressManager: Synced remove ${address} from ${entry.name} webhook`);
+                }
+                catch (error) {
+                    entry.address_set.add(address);
+                    console.error(`QnWebhookAddressManager: Sync remove failed for ${entry.name}`, error);
+                }
+            }
+        });
+    }
+}
+exports.default = QnWebhookAddressManager;

package/build/services/quicknode-notifications/SetupNotifications.d.ts

@@ -0,0 +1,40 @@
+import BaseErrors from "../../errors/errors";
+import { BlockchainType } from "../../interfaces";
+import { IConfig } from "../../interfaces/config";
+import { IDatabasePool } from "../../interfaces/database";
+import { RateLimiterOptions } from "../../utils/AsyncRateLimiter";
+export interface NotificationWebhookEntry {
+    webhook_id: string;
+    template: string;
+    network: string;
+    blockchain: BlockchainType;
+    address_set: Set<string>;
+}
+declare class SetupNotifications extends BaseErrors {
+    private static instance;
+    private api;
+    private webhook_map;
+    private by_blockchain;
+    private pending_configs;
+    private config;
+    private db;
+    private constructor();
+    static getInstance(config: IConfig, db: IDatabasePool, rlc: RateLimiterOptions): SetupNotifications;
+    get_all_webhook_ids(): string[];
+    get_entry_by_webhook_id(id: string): NotificationWebhookEntry | undefined;
+    /**
+     * Fetch all deposit addresses for a blockchain from the DB (paginated).
+     * The `blockchain` filter value in DepositAddressService is the string stored
+     * in the DB — e.g. "solana", "evm", "ethereum", etc.
+     */
+    private fetch_all_db_addresses;
+    /**
+     * Register a newly-created webhook entry in the internal maps.
+     */
+    private register_entry;
+    initialize(): Promise<void>;
+    add_address(blockchain: BlockchainType, address: string): Promise<void>;
+    remove_address(blockchain: BlockchainType, address: string): Promise<void>;
+}
+export default SetupNotifications;
+//# sourceMappingURL=SetupNotifications.d.ts.map

package/build/services/quicknode-notifications/SetupNotifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SetupNotifications.d.ts","sourceRoot":"","sources":["../../../src/services/quicknode-notifications/SetupNotifications.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAiB,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAQlE,MAAM,WAAW,wBAAwB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,cAAc,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC5B;AAWD,cAAM,kBAAmB,SAAQ,UAAU;IACvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAqB;IAC5C,OAAO,CAAC,GAAG,CAAqB;IAEhC,OAAO,CAAC,WAAW,CAAoD;IAEvE,OAAO,CAAC,aAAa,CAA8D;IAEnF,OAAO,CAAC,eAAe,CAAqD;IAC5E,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,EAAE,CAAgB;IAC1B,OAAO;IAOP,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,aAAa,EAAE,GAAG,EAAE,kBAAkB,GAAG,kBAAkB;IAO5F,mBAAmB,IAAI,MAAM,EAAE;IAI/B,uBAAuB,CAAC,EAAE,EAAE,MAAM,GAAG,wBAAwB,GAAG,SAAS;IAOhF;;;;OAIG;YACW,sBAAsB;IAuBpC;;OAEG;IACH,OAAO,CAAC,cAAc;IAOT,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAwH3B,WAAW,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyDvE,cAAc,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAe1F;AAED,eAAe,kBAAkB,CAAC"}

package/build/services/quicknode-notifications/SetupNotifications.js

@@ -0,0 +1,253 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = __importDefault(require("../../errors/errors"));
+const ChainManager_1 = __importDefault(require("../ChainManager"));
+const DepositAddressService_1 = __importDefault(require("../DepositAddressService"));
+const QuicknodeWebhookSignature_1 = __importDefault(require("../QuicknodeWebhookSignature"));
+const QnNotificationsApi_1 = __importDefault(require("./QnNotificationsApi"));
+const ADDRESS_SYNC_BATCH_SIZE = 500;
+const ADDRESS_LOG_THRESHOLD = 1000;
+class SetupNotifications extends errors_1.default {
+    constructor(config, db, rlc) {
+        super();
+        // keyed by notification config name (unique per network)
+        this.webhook_map = new Map();
+        // keyed by blockchain type → list of notification entries for that blockchain
+        this.by_blockchain = new Map();
+        // configs deferred because no addresses existed at startup
+        this.pending_configs = new Map();
+        this.config = config;
+        this.db = db;
+        this.api = QnNotificationsApi_1.default.getInstance(config, rlc);
+    }
+    static getInstance(config, db, rlc) {
+        if (!this.instance) {
+            this.instance = new SetupNotifications(config, db, rlc);
+        }
+        return this.instance;
+    }
+    get_all_webhook_ids() {
+        return Array.from(this.webhook_map.values()).map(e => e.webhook_id);
+    }
+    get_entry_by_webhook_id(id) {
+        for (const entry of this.webhook_map.values()) {
+            if (entry.webhook_id === id)
+                return entry;
+        }
+        return undefined;
+    }
+    /**
+     * Fetch all deposit addresses for a blockchain from the DB (paginated).
+     * The `blockchain` filter value in DepositAddressService is the string stored
+     * in the DB — e.g. "solana", "evm", "ethereum", etc.
+     */
+    fetch_all_db_addresses(blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const service = new DepositAddressService_1.default(this.db);
+            const addresses = [];
+            let page = 1;
+            const page_size = ADDRESS_SYNC_BATCH_SIZE;
+            while (true) {
+                const result = yield service.getDepositAddressesPaginated(page, page_size, { blockchain });
+                for (const item of result.items) {
+                    addresses.push(item.address);
+                }
+                if (!result.has_next)
+                    break;
+                page++;
+            }
+            if (addresses.length > ADDRESS_LOG_THRESHOLD) {
+                console.warn(`SetupNotifications: ${addresses.length} addresses fetched for blockchain=${blockchain} — ensure QN webhook limit is sufficient`);
+            }
+            return addresses;
+        });
+    }
+    /**
+     * Register a newly-created webhook entry in the internal maps.
+     */
+    register_entry(config_name, entry) {
+        this.webhook_map.set(config_name, entry);
+        const existing_by_bc = this.by_blockchain.get(entry.blockchain) || [];
+        existing_by_bc.push(entry);
+        this.by_blockchain.set(entry.blockchain, existing_by_bc);
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const chain_manager = ChainManager_1.default.getInstance(this.config);
+                if (!chain_manager.contractsMap)
+                    return;
+                // Collect all required notification configs from chain config
+                const required_notifications = Object.entries(chain_manager.contractsMap)
+                    .filter(([_, cfg]) => { var _a; return ((_a = cfg.quicknodeNotificationConfig) === null || _a === void 0 ? void 0 : _a.length) > 0; })
+                    .flatMap(([_, cfg]) => cfg.quicknodeNotificationConfig.map(n => (Object.assign(Object.assign({}, n), { blockchain: cfg.blockchainType }))));
+                if (required_notifications.length === 0) {
+                    console.log(`SetupNotifications: No quicknodeNotifications config found. Skipping.`);
+                    return;
+                }
+                // Deduplicate by name (multiple chains may share the same notification config name)
+                const unique_notifications = required_notifications.filter((n, i, arr) => arr.findIndex(x => x.name === n.name) === i);
+                // Fetch existing webhooks
+                let existing_webhooks = [];
+                try {
+                    const res = yield this.api.get_all_webhooks();
+                    existing_webhooks = res.data || [];
+                }
+                catch (error) {
+                    console.error(`SetupNotifications: Failed to fetch existing webhooks`, error);
+                }
+                const host = this.config.config.useTunnel ? this.config.config.tunnel : this.config.config.host;
+                const webhook_url = `${host}/webhook/quicknode/notifications`;
+                for (const notif_config of unique_notifications) {
+                    const existing = existing_webhooks.find(w => {
+                        var _a, _b;
+                        return ((_a = w.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === notif_config.name.toLowerCase() &&
+                            ((_b = w.network) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === notif_config.network.toLowerCase();
+                    });
+                    // Fetch current addresses from the DB for this blockchain
+                    const db_addresses = yield this.fetch_all_db_addresses(notif_config.blockchain);
+                    console.log(`SetupNotifications: ${db_addresses.length} DB addresses for blockchain=${notif_config.blockchain}`);
+                    let webhook_id;
+                    if (existing) {
+                        webhook_id = existing.id;
+                        console.log(`SetupNotifications: Found existing webhook for ${notif_config.name} (id: ${webhook_id})`);
+                        // Sync the webhook with the full DB address list to fix any drift
+                        if (db_addresses.length > 0) {
+                            try {
+                                yield this.api.update_webhook_addresses(webhook_id, notif_config.template, db_addresses);
+                                console.log(`SetupNotifications: Synced ${db_addresses.length} addresses to existing webhook ${notif_config.name}`);
+                            }
+                            catch (err) {
+                                console.error(`SetupNotifications: Failed to sync addresses to webhook ${notif_config.name}`, err);
+                            }
+                        }
+                        const entry = {
+                            webhook_id,
+                            template: notif_config.template,
+                            network: notif_config.network,
+                            blockchain: notif_config.blockchain,
+                            address_set: new Set(db_addresses),
+                        };
+                        this.register_entry(notif_config.name, entry);
+                    }
+                    else if (db_addresses.length === 0) {
+                        // QN requires at least one address to create a webhook — defer until first address arrives
+                        console.log(`SetupNotifications: No addresses for ${notif_config.name} — deferring webhook creation until first address is added`);
+                        this.pending_configs.set(notif_config.name, { notif_config, webhook_url });
+                    }
+                    else {
+                        // Create webhook with DB addresses as the initial set
+                        console.log(`SetupNotifications: Creating webhook for ${notif_config.name} on ${notif_config.network} with ${db_addresses.length} initial addresses`);
+                        try {
+                            const res = yield this.api.create_webhook(notif_config.template, notif_config.name, notif_config.network, webhook_url, db_addresses);
+                            webhook_id = res.id;
+                            if ((_a = res.destination_attributes) === null || _a === void 0 ? void 0 : _a.security_token) {
+                                yield QuicknodeWebhookSignature_1.default.getInstance().createSigningKey(this.config.config.keyVaultName, webhook_id, res.destination_attributes.security_token);
+                                console.log(`SetupNotifications: Stored signing key for webhook ${webhook_id}`);
+                            }
+                            console.log(`SetupNotifications: Created webhook ${notif_config.name} (id: ${webhook_id})`);
+                            const entry = {
+                                webhook_id,
+                                template: notif_config.template,
+                                network: notif_config.network,
+                                blockchain: notif_config.blockchain,
+                                address_set: new Set(db_addresses),
+                            };
+                            this.register_entry(notif_config.name, entry);
+                        }
+                        catch (err) {
+                            console.error(`SetupNotifications: Failed to create webhook for ${notif_config.name}`, err);
+                        }
+                    }
+                }
+                console.log(`SetupNotifications: Initialized ${this.webhook_map.size} notification webhooks, ${this.pending_configs.size} deferred.`);
+            }
+            catch (error) {
+                console.error(`SetupNotifications: Error during initialization`, error);
+                throw error;
+            }
+        });
+    }
+    add_address(blockchain, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // If any pending configs exist for this blockchain, create the webhook now
+            for (const [config_name, pending] of this.pending_configs.entries()) {
+                if (pending.notif_config.blockchain !== blockchain)
+                    continue;
+                console.log(`SetupNotifications: Lazily creating deferred webhook ${config_name} for first address ${address}`);
+                try {
+                    const res = yield this.api.create_webhook(pending.notif_config.template, pending.notif_config.name, pending.notif_config.network, pending.webhook_url, [address]);
+                    if ((_a = res.destination_attributes) === null || _a === void 0 ? void 0 : _a.security_token) {
+                        yield QuicknodeWebhookSignature_1.default.getInstance().createSigningKey(this.config.config.keyVaultName, res.id, res.destination_attributes.security_token);
+                    }
+                    const entry = {
+                        webhook_id: res.id,
+                        template: pending.notif_config.template,
+                        network: pending.notif_config.network,
+                        blockchain: pending.notif_config.blockchain,
+                        address_set: new Set([address]),
+                    };
+                    this.register_entry(config_name, entry);
+                    this.pending_configs.delete(config_name);
+                    console.log(`SetupNotifications: Lazily created webhook ${config_name} (id: ${res.id})`);
+                }
+                catch (err) {
+                    console.error(`SetupNotifications: Failed to lazily create webhook ${config_name}`, err);
+                    throw err;
+                }
+                // After lazy creation the address is already in the entry — continue to next pending
+                // but skip the update_webhook_addresses call below for this entry since it's already set
+                return;
+            }
+            const entries = this.by_blockchain.get(blockchain) || [];
+            for (const entry of entries) {
+                if (entry.address_set.has(address))
+                    continue;
+                entry.address_set.add(address);
+                try {
+                    yield this.api.update_webhook_addresses(entry.webhook_id, entry.template, Array.from(entry.address_set));
+                    console.log(`SetupNotifications: Added ${address} to ${entry.network} webhook`);
+                }
+                catch (error) {
+                    entry.address_set.delete(address); // rollback on failure
+                    console.error(`SetupNotifications: Failed to add ${address} to ${entry.network}`, error);
+                    throw error;
+                }
+            }
+        });
+    }
+    remove_address(blockchain, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = this.by_blockchain.get(blockchain) || [];
+            for (const entry of entries) {
+                if (!entry.address_set.has(address))
+                    continue;
+                entry.address_set.delete(address);
+                try {
+                    yield this.api.update_webhook_addresses(entry.webhook_id, entry.template, Array.from(entry.address_set));
+                    console.log(`SetupNotifications: Removed ${address} from ${entry.network} webhook`);
+                }
+                catch (error) {
+                    entry.address_set.add(address); // rollback on failure
+                    console.error(`SetupNotifications: Failed to remove ${address} from ${entry.network}`, error);
+                    throw error;
+                }
+            }
+        });
+    }
+}
+exports.default = SetupNotifications;

package/build/services/quicknode-notifications/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./notification_types";
+//# sourceMappingURL=index.d.ts.map

package/build/services/quicknode-notifications/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/quicknode-notifications/types/index.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAC"}

package/build/services/quicknode-notifications/types/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./notification_types"), exports);