@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/AlchemyService.js

@@ -0,0 +1,239 @@
+"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 alchemy_1 = require("./utils/alchemy");
+const AlchemyErrors_1 = __importDefault(require("../errors/AlchemyErrors"));
+const ChainManager_1 = __importDefault(require("./ChainManager"));
+const Logger_1 = require("../utils/Logger");
+class AlchemyService {
+    constructor(config) {
+        this.access_token = (subscription) => {
+            if (subscription === 'prod')
+                return this.config.config.alchemyAccessToken;
+            if (subscription === 'local')
+                return this.config.config.alchemyAccessTokenDev;
+        };
+        this.get_all_webhooks = (env) => __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.call(env, 'team-webhooks', "GET");
+            return res.data;
+        });
+        this.get_all_addresses_for_webhook = (env, payload) => __awaiter(this, void 0, void 0, function* () {
+            if (!payload.webhook_id) {
+                throw new Error(this.errors.RequireParameter("webhook_id"));
+            }
+            const endpoint = `webhook-addresses/?webhook_id=${payload.webhook_id}&limit=${payload.limit ? payload.limit : 100}&pageKey=${payload.pageKey ? payload.pageKey : 0}${payload.after ? `&after=${payload.after ? payload.after : ""}` : ""}`;
+            const res = yield this.call(env, endpoint, "GET");
+            if (!res) {
+                throw new Error(this.errors.FailedGetWebhookAddresses(env, payload.webhook_id));
+            }
+            return res;
+        });
+        this.add_remove_addresses_all_webhooks = (subscription, blockchain, addresses_to_add, addresses_to_remove) => __awaiter(this, void 0, void 0, function* () {
+            this.logger.info(`Adding ${addresses_to_add.length} and removing ${addresses_to_remove.length} addresses from ${blockchain} webhook`);
+            const all_webhooks = (yield this.get_all_webhooks(subscription)).filter((result) => (0, alchemy_1.get_blockchain_type)(result.network) === blockchain);
+            if (!all_webhooks) {
+                throw new Error(this.errors.NoWebhooks(subscription));
+            }
+            this.logger.info(`${all_webhooks.length} webhooks available in subscription: ${subscription}`);
+            // const address_activity_webhooks = all_webhooks.filter(w => w.webhook_type === "ADDRESS_ACTIVITY" && w.webhook_url.includes(`${subscription}/address-activity`))
+            const address_activity_webhooks = all_webhooks.filter(w => w.webhook_type === "ADDRESS_ACTIVITY" && w.webhook_url.includes(`address-activity`) && w.webhook_url.includes(subscription));
+            this.logger.info(`Found ${address_activity_webhooks.length} ADDRESS_ACTIVITY webhooks`);
+            this.logger.info(`ADDRESS_ACTIVITY webhooks`, { address_activity_webhooks });
+            const webhook_ids = address_activity_webhooks.map((webhook) => webhook.id);
+            const promises = yield Promise.allSettled(webhook_ids.map((id) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const payload = {
+                        webhook_id: id,
+                        addresses_to_add: addresses_to_add && Array.isArray(addresses_to_add) ? addresses_to_add : [],
+                        addresses_to_remove: addresses_to_remove && Array.isArray(addresses_to_remove) ? addresses_to_remove : [],
+                    };
+                    const is_added_removed = yield this.add_remove_addresses(subscription, payload);
+                    if (!is_added_removed)
+                        this.logger.info(`Failed to add/remove addresses.`, { data: { webhook_ids, add: payload.addresses_to_add, remove: payload.addresses_to_remove } });
+                    this.logger.info(`Added/removed:`, { added: payload.addresses_to_add, remove: payload.addresses_to_remove });
+                    return {
+                        status: is_added_removed,
+                        webhook_id: id
+                    };
+                }
+                catch (error) {
+                    return {
+                        status: false,
+                        webhook_id: id
+                    };
+                }
+            })));
+            const failed = promises
+                .filter((result) => result.status === "fulfilled")
+                .map((result) => result.value)
+                .filter((result) => result.status === false);
+            const success = promises
+                .filter((result) => result.status === "fulfilled")
+                .map((result) => result.value)
+                .filter((result) => result.status === true);
+            this.logger.info(`Added/removed ${success.length} addresses. Failed ${failed.length} `);
+            return { success: success, failed: failed, expected_success: webhook_ids.length };
+        });
+        this.add_remove_addresses_all = (subscription, addresses_to_add, addresses_to_remove) => __awaiter(this, void 0, void 0, function* () {
+            const chainManager = ChainManager_1.default.getInstance(this.config);
+            const chains = chainManager.chainsRequireAlchemyAddressActivity;
+            const all_webhooks = yield this.get_all_webhooks(subscription);
+            const promises = yield Promise.allSettled(chains.map((chainId) => __awaiter(this, void 0, void 0, function* () {
+                const webhook_matches = yield this.find_webhooks(subscription, chainId, all_webhooks);
+                // Check if webhook was found for this chain
+                if (!webhook_matches || webhook_matches.length === 0) {
+                    throw new Error(`No webhook found for chain ${chainId}`);
+                }
+                const payload = {
+                    webhook_id: webhook_matches[0].webhook.id,
+                    addresses_to_add: addresses_to_add,
+                    addresses_to_remove: addresses_to_remove
+                };
+                const is_added = yield this.add_remove_addresses(subscription, payload);
+                return { webhook: webhook_matches[0].webhook, is_added };
+            })));
+            // Check for any failures (rejected promises or successful operations that returned false)
+            const failed_operations = promises.filter(result => result.status === "rejected" ||
+                (result.status === "fulfilled" && result.value.is_added === false));
+            if (failed_operations.length > 0) {
+                this.logger.info(`Failed to add addresses to webhooks: `, failed_operations);
+            }
+            return failed_operations.length === 0;
+        });
+        this.find_webhooks = (env, chainId, all_webhooks) => __awaiter(this, void 0, void 0, function* () {
+            const network = (0, alchemy_1.get_alchemy_chain_name)(chainId);
+            const relevant_webhooks = all_webhooks.filter((webhook) => webhook.network === network);
+            const addresses_resolve = yield Promise.allSettled(relevant_webhooks.map((webhook) => __awaiter(this, void 0, void 0, function* () {
+                const payload = {
+                    webhook_id: webhook.id
+                };
+                const addresses = yield this.get_all_addresses_for_webhook(env, payload);
+                return { webhook, total_addresses: addresses.pagination.total_count };
+            })));
+            // Extract numbers from fulfilled promises
+            const webhooks = addresses_resolve
+                .filter(result => result.status === 'fulfilled')
+                .map(result => result.value)
+                .filter(result => result.total_addresses < 100000);
+            return webhooks;
+        });
+        this.create_webhook = (subscription, payload) => __awaiter(this, void 0, void 0, function* () {
+            if (!payload.network || !payload.webhook_type || !payload.webhook_url) {
+                throw new Error(this.errors.RequireParameter('payload.network, payload.webhook_type, payload.webhook_url'));
+            }
+            this.logger.info(`Creating ${payload.webhook_type} webhook on ${payload.network}`);
+            const endpoint = `create-webhook`;
+            const res = yield this.call(subscription, endpoint, "POST", payload);
+            if (!(res === null || res === void 0 ? void 0 : res.data)) {
+                throw new Error(`Failed to create webhook.`);
+            }
+            this.logger.info(`Webhook created: ${res.data.id}. Webhook url: ${res.data.webhook_url}`);
+            return res.data;
+        });
+        this.replace_addresses = (subscription, payload) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const endpoint = `update-webhook-addresses`;
+            yield this.call(subscription, endpoint, "PUT", payload);
+            this.logger.info(`Addresses replaced. Added ${(_a = payload.addresses) === null || _a === void 0 ? void 0 : _a.length} addresses.`);
+            return true;
+        });
+        this.add_remove_addresses = (subscription, payload) => __awaiter(this, void 0, void 0, function* () {
+            const endpoint = `update-webhook-addresses`;
+            yield this.call(subscription, endpoint, "PATCH", payload);
+            return true;
+        });
+        this.update_webhook_status = (subscription, payload) => __awaiter(this, void 0, void 0, function* () {
+            const endpoint = `update-webhook`;
+            const res = yield this.call(subscription, endpoint, "PUT", payload);
+            return res.data;
+        });
+        this.delete_webhook = (subscription, payload) => __awaiter(this, void 0, void 0, function* () {
+            const endpoint = `delete-webhook/?webhook_id=${payload.webhook_id}`;
+            yield this.call(subscription, endpoint, "DELETE");
+            return true;
+        });
+        this.call = (subscription, endpoint, method, data) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let access_token = this.access_token(subscription);
+            if (!access_token) {
+                if (!this.config.config.alchemyApiKey) {
+                    throw new Error(`Alchemy API key not set.`);
+                }
+                // this.set_access_tokens();
+                access_token = this.access_token(subscription);
+                if (!access_token) {
+                    throw new Error(`Cannot set alchemy access token`);
+                }
+            }
+            try {
+                const url = `${this.base_url}/${endpoint}`;
+                const headers = {
+                    'X-Alchemy-Token': access_token
+                };
+                if (method === 'POST' || method === 'PUT' || method === "PATCH") {
+                    headers["Content-Type"] = 'application/json';
+                }
+                const requestOptions = {
+                    headers: headers,
+                    method: method,
+                    body: data ? JSON.stringify(data) : undefined,
+                };
+                const response = yield fetch(url, requestOptions);
+                if (!response.ok) {
+                    const errorObj = JSON.parse(yield response.text());
+                    this.logger.warn(`HTTP Call Error: ${response.status}: `, { data: { error: errorObj } });
+                    throw {
+                        name: errorObj.name ? errorObj.name === 'ServerError' && ((_a = errorObj.message) === null || _a === void 0 ? void 0 : _a.includes("Internal server error")) ? "AlchemyServerError" : errorObj.name : "Alchemy API Error",
+                        status: response.status,
+                        message: errorObj.error ? errorObj.error.message : errorObj.message
+                    };
+                }
+                const resData = yield response.json();
+                return resData;
+            }
+            catch (error) {
+                this.logger.error(`Error in Alchemy API Call`, { data: { error } });
+                throw error;
+            }
+        });
+        this.base_url = "https://dashboard.alchemy.com/api";
+        this.errors = new AlchemyErrors_1.default();
+        this.config = config;
+        this.logger = (0, Logger_1.createLogger)(`AlchemyService`, this.config.pipelineConfig.azureAppName);
+    }
+    static getInstance(config) {
+        if (!this.instance) {
+            this.instance = new AlchemyService(config);
+        }
+        return this.instance;
+    }
+    delete_all_webhooks(subscription) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const all_webhooks = yield this.get_all_webhooks(subscription);
+            if (!all_webhooks) {
+                return { delete_count: 0, expected_count: 0 };
+            }
+            const webhook_ids = all_webhooks.map((webhook) => webhook.id);
+            const promises = yield Promise.allSettled(webhook_ids.map((id) => __awaiter(this, void 0, void 0, function* () {
+                yield this.delete_webhook(subscription, { webhook_id: id });
+                return id;
+            })));
+            let success = promises
+                .filter(promise => promise.status === "fulfilled")
+                .map(promise => promise.value);
+            return { delete_count: success.length, expected_count: all_webhooks.length, success_webhooks: success };
+        });
+    }
+}
+exports.default = AlchemyService;

package/build/services/AlchemyWebhookSignature.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Validate alchemy webhook event payload against the webhook's secret signing key
+ */
+declare class AlchemyWebhookSignature {
+    static instance: AlchemyWebhookSignature;
+    private signing_keys;
+    private constructor();
+    static getInstance(): AlchemyWebhookSignature;
+    validateWebhookEvent(keyVaultName: string, webhook_id: string, stringified_body: string, signature: string): Promise<boolean>;
+    private getSigningKey;
+    createSigningKey(keyVaultName: string, webhook_id: string, value: string): Promise<boolean>;
+    deleteSigningKey(keyVaultName: string, webhook_id: string): Promise<boolean>;
+    private isValidSignatureForStringBody;
+}
+export default AlchemyWebhookSignature;
+//# sourceMappingURL=AlchemyWebhookSignature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlchemyWebhookSignature.d.ts","sourceRoot":"","sources":["../../src/services/AlchemyWebhookSignature.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,cAAM,uBAAuB;IACzB,MAAM,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IACzC,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO;IAEP,MAAM,CAAC,WAAW;IAQL,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;YAMzG,aAAa;IAqBd,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAYxE,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAatE,OAAO,CAAC,6BAA6B;CAUxC;AAED,eAAe,uBAAuB,CAAC"}

package/build/services/AlchemyWebhookSignature.js

@@ -0,0 +1,119 @@
+"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 crypto = __importStar(require("crypto"));
+const KeyVaultService_1 = __importDefault(require("./KeyVaultService"));
+/**
+ * Validate alchemy webhook event payload against the webhook's secret signing key
+ */
+class AlchemyWebhookSignature {
+    constructor() {
+        this.signing_keys = new Map();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new AlchemyWebhookSignature();
+        }
+        return this.instance;
+    }
+    validateWebhookEvent(keyVaultName, webhook_id, stringified_body, signature) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signingKey = yield this.getSigningKey(keyVaultName, webhook_id);
+            return this.isValidSignatureForStringBody(stringified_body, signature, signingKey);
+        });
+    }
+    getSigningKey(keyVaultName, webhook_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vaultHandler = new KeyVaultService_1.default(keyVaultName);
+            if (!vaultHandler.client) {
+                vaultHandler.initializeKeyVaultService();
+            }
+            const key = `alchemy-webhook-signing-key-${webhook_id.replace(/_/g, "-")}`;
+            const existing = this.signing_keys.get(key);
+            if (!existing) {
+                const signingKey = yield vaultHandler.getSecretValue(key);
+                if (!signingKey)
+                    throw new Error(`Alchemy webhook signing key: ${key} is not set in key vault`);
+                this.signing_keys.set(key, signingKey);
+                return signingKey;
+            }
+            return existing;
+        });
+    }
+    createSigningKey(keyVaultName, webhook_id, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vaultHandler = new KeyVaultService_1.default(keyVaultName);
+            if (!vaultHandler.client) {
+                vaultHandler.initializeKeyVaultService();
+            }
+            const key = `alchemy-webhook-signing-key-${webhook_id.replace(/_/g, "-")}`;
+            yield vaultHandler.store(key, value);
+            return true;
+        });
+    }
+    deleteSigningKey(keyVaultName, webhook_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const vaultHandler = new KeyVaultService_1.default(keyVaultName);
+            if (!vaultHandler.client) {
+                vaultHandler.initializeKeyVaultService();
+            }
+            const key = `alchemy-webhook-signing-key-${webhook_id.replace(/_/g, "-")}`;
+            const is_deleted = yield vaultHandler.delete(key);
+            this.signing_keys.delete(key);
+            return is_deleted;
+        });
+    }
+    isValidSignatureForStringBody(body, // raw string body
+    signature, // "X-Alchemy-Signature"
+    signingKey) {
+        const hmac = crypto.createHmac("sha256", signingKey); // Create a HMAC SHA256 hash using the signing key
+        hmac.update(body, "utf8"); // Update the token hash with the request body using utf8
+        const digest = hmac.digest("hex");
+        return signature === digest;
+    }
+}
+exports.default = AlchemyWebhookSignature;

package/build/services/AlchemyWebhooks.d.ts

@@ -0,0 +1,87 @@
+import { BlockchainType, ChainId } from "../interfaces";
+import { AlchemyWebhookEnvironment, AlchemyWebhookNetwork, AlchemyWebhookType } from "./types/alchemy";
+import { IConfig } from "../interfaces/config";
+import { IDatabasePool } from "../interfaces/database";
+type ListeningSource = "contract" | "wallet";
+export interface FailedSyncBatchProcessReport {
+    batchSize: number;
+    start: number;
+    addresses: string[];
+}
+interface WebhookReport {
+    network: AlchemyWebhookNetwork;
+    networkSymbol: string;
+    chainId: ChainId;
+    required: number;
+    available: number;
+    targetWebhookType: AlchemyWebhookType;
+    endpoint: string;
+    source: ListeningSource;
+}
+declare class AlchemyWebhooks {
+    static instance: AlchemyWebhooks;
+    private config;
+    private dbPool;
+    base_webhook_endpoint: (env: AlchemyWebhookEnvironment, type: AlchemyWebhookType) => string;
+    base_webhook_host: (env: AlchemyWebhookEnvironment) => string;
+    private errors;
+    private logger;
+    constructor(config: IConfig, dbPool: IDatabasePool);
+    static getInstance(config: IConfig, dbPool: IDatabasePool): AlchemyWebhooks;
+    initialize: (env?: AlchemyWebhookEnvironment, server_host?: string, networks?: AlchemyWebhookNetwork[]) => Promise<{
+        new_webhooks: {
+            webhook_id: string;
+            signing_key: string;
+        }[];
+        prod: WebhookReport[];
+        dev: WebhookReport[];
+    }>;
+    get_network_symbol_for_alchemy_network_name(network: AlchemyWebhookNetwork, env: AlchemyWebhookEnvironment): string;
+    private validate_setup;
+    private create_webhooks;
+    get_required_esrow_webhook_config: (env: AlchemyWebhookEnvironment) => {
+        endpoint: string;
+        chainId: ChainId;
+        network_symbol: string;
+        network: AlchemyWebhookNetwork;
+        type: "GRAPHQL" | "ADDRESS_ACTIVITY";
+        source: "contract" | "wallet";
+    }[];
+    get_required_webhook_count_per_network: (env: AlchemyWebhookEnvironment) => {
+        endpoint: string;
+        chainId: ChainId;
+        network_symbol: string;
+        network: AlchemyWebhookNetwork;
+        total_wallet_count: number;
+        source: "contract" | "wallet";
+    }[];
+    sync_all_addresses_to_webhooks(subscription: AlchemyWebhookEnvironment): Promise<{
+        resolved: {
+            blockchain: BlockchainType;
+            status: boolean;
+            count: number;
+        }[];
+        failed: {
+            blockchain: BlockchainType;
+            status: boolean;
+            count: number;
+        }[];
+        success: {
+            blockchain: BlockchainType;
+            status: boolean;
+            count: number;
+        }[];
+        expected_success: number;
+    }>;
+    syncDepositAddressesToWebhooks(env: AlchemyWebhookEnvironment, blockchain: BlockchainType): Promise<{
+        status: boolean;
+        count: number;
+        success_count: number;
+        failed_count: number;
+        failed_address_count: number;
+        success_address_count: number;
+        failed: FailedSyncBatchProcessReport[];
+    }>;
+}
+export default AlchemyWebhooks;
+//# sourceMappingURL=AlchemyWebhooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AlchemyWebhooks.d.ts","sourceRoot":"","sources":["../../src/services/AlchemyWebhooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAS,OAAO,EAAE,MAAM,eAAe,CAAC;AAK/D,OAAO,EAA6B,yBAAyB,EAAE,qBAAqB,EAAE,kBAAkB,EAAqC,MAAM,iBAAiB,CAAC;AACrK,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAOvD,KAAK,eAAe,GAAG,UAAU,GAAG,QAAQ,CAAC;AAC7C,MAAM,WAAW,4BAA4B;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,EAAE,CAAC;CACvB;AAQD,UAAU,aAAa;IACnB,OAAO,EAAE,qBAAqB,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,eAAe,CAAC;CAC3B;AAGD,cAAM,eAAe;IACjB,OAAc,QAAQ,EAAE,eAAe,CAAC;IACxC,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,MAAM,CAAgB;IACvB,qBAAqB,EAAE,CAAC,GAAG,EAAE,yBAAyB,EAAE,IAAI,EAAE,kBAAkB,KAAK,MAAM,CAAC;IAC5F,iBAAiB,EAAE,CAAC,GAAG,EAAE,yBAAyB,KAAK,MAAM,CAAC;IACrE,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;IAgBlD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;IAQlD,UAAU,GAAU,MAAM,yBAAyB,EAAE,cAAc,MAAM,EAAE,WAAW,qBAAqB,EAAE;;;;;;;OAoDnH;IAEM,2CAA2C,CAAC,OAAO,EAAE,qBAAqB,EAAE,GAAG,EAAE,yBAAyB;IAYjH,OAAO,CAAC,cAAc,CAmHrB;IAED,OAAO,CAAC,eAAe,CAiEtB;IAGM,iCAAiC,GAAI,KAAK,yBAAyB;;;;;;;QAIzE;IAIM,sCAAsC,GAAI,KAAK,yBAAyB;;;;;;;QAO9E;IAGY,8BAA8B,CAAC,YAAY,EAAE,yBAAyB;;wBAcR,cAAc;oBAAU,OAAO;mBAAS,MAAM;;;wBAA9C,cAAc;oBAAU,OAAO;mBAAS,MAAM;;;wBAA9C,cAAc;oBAAU,OAAO;mBAAS,MAAM;;;;IAgB5G,8BAA8B,CAAC,GAAG,EAAE,yBAAyB,EAAE,UAAU,EAAE,cAAc;;;;;;;;;CAyEzG;AAED,eAAe,eAAe,CAAC"}