@ercworldio/blockchain-shared 1.0.0-dev.4

package/build/services/TimerManager.d.ts

@@ -0,0 +1,44 @@
+import { BlockchainType } from "../interfaces";
+import { AlchemyWebhookEnvironment } from "./types/alchemy";
+import { IConfig } from "../interfaces/config";
+import Redis from "./Redis";
+import { IWallet } from "./types/wallet_manager";
+import { IDatabasePool } from "../interfaces/database";
+declare class TimerManager {
+    static instance: TimerManager;
+    private config;
+    private dbPool;
+    private timers;
+    private key_prefix;
+    private custodial_clear_key_prefix;
+    private custodial_clear_key_data_prefix;
+    redis: Redis;
+    private initialized;
+    private expired_keys_set;
+    private last_updated_set;
+    private clear_expired_keys_set_duration;
+    private logger;
+    constructor(config: IConfig, dbPool: IDatabasePool, _prefix?: string);
+    static getInstance(config: IConfig, dbPool: IDatabasePool): TimerManager;
+    initialize(): Promise<void>;
+    private handleTimerExpiry;
+    onTriggerClearAddressCache: (data_key: string, userId: number, blockchain: BlockchainType, address: string, on_trigger: (env: AlchemyWebhookEnvironment, addr: string, wallet: IWallet) => Promise<void>) => Promise<void>;
+    onAddressClear: (subscription: AlchemyWebhookEnvironment, address: string, wallet: IWallet) => Promise<void>;
+    private add_to_set;
+    private getTimerKey;
+    get_active_timers(): {
+        userId: number;
+        blockchain: BlockchainType;
+        expiresAt: Date;
+    }[];
+    exists_timer(userId: number, blockchain: BlockchainType): Promise<boolean>;
+    create_if_not_exists(wallet: IWallet, timeout_ms: number, subscription: AlchemyWebhookEnvironment, bonus_code?: string): Promise<boolean>;
+    private set_clear_address_data;
+    create_timer(wallet: IWallet, timeout_ms: number, subscription: AlchemyWebhookEnvironment, bonus_code?: string): Promise<boolean>;
+    private _create_timer;
+    delete_timer(userId: number, blockchain: BlockchainType): Promise<boolean>;
+    clear_timer(userId: number, blockchain: BlockchainType): Promise<boolean>;
+    has_active_timer(userId: number, blockchain: BlockchainType): Promise<boolean>;
+}
+export default TimerManager;
+//# sourceMappingURL=TimerManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TimerManager.d.ts","sourceRoot":"","sources":["../../src/services/TimerManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAE5D,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,KAAK,MAAM,SAAS,CAAC;AAE5B,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAoBvD,cAAM,YAAY;IACd,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC;IAC9B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,0BAA0B,CAAS;IAC3C,OAAO,CAAC,+BAA+B,CAAS;IACzC,KAAK,EAAE,KAAK,CAAC;IACpB,OAAO,CAAC,WAAW,CAAU;IAC7B,OAAO,CAAC,gBAAgB,CAAc;IACtC,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,+BAA+B,CAAkB;IACzD,OAAO,CAAC,MAAM,CAAS;gBACX,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,MAAM;IAcpE,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;IAQ5C,UAAU;YAOT,iBAAiB;IA2BxB,0BAA0B,GAAU,UAAU,MAAM,EAAE,QAAQ,MAAM,EAAE,YAAY,cAAc,EAAE,SAAS,MAAM,EAAE,YAAY,CAAC,GAAG,EAAE,yBAAyB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,mBAkBrN;IAEM,cAAc,GAAU,cAAc,yBAAyB,EAAE,SAAS,MAAM,EAAE,QAAQ,OAAO,mBA6BvG;IAED,OAAO,CAAC,UAAU;IAiBlB,OAAO,CAAC,WAAW;IAIZ,iBAAiB,IAAI;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,cAAc,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,EAAE;IAQhF,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc;IAOvD,oBAAoB,CAC7B,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,yBAAyB,EACvC,UAAU,GAAE,MAAW,GACxB,OAAO,CAAC,OAAO,CAAC;YAUL,sBAAsB;IAYvB,YAAY,CACrB,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,yBAAyB,EACvC,UAAU,GAAE,MAAW,GACxB,OAAO,CAAC,OAAO,CAAC;YAeL,aAAa;IAwBd,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAM1E,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAUzE,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;CAM9F;AAED,eAAe,YAAY,CAAC"}

package/build/services/TimerManager.js

@@ -0,0 +1,231 @@
+"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 SweepJobService_1 = __importDefault(require("./SweepJobService"));
+const AlchemyService_1 = __importDefault(require("./AlchemyService"));
+const Redis_1 = __importDefault(require("./Redis"));
+const Utility_1 = require("../utils/Utility");
+const constants_1 = require("../constants");
+const RedisPubSub_1 = require("./types/RedisPubSub");
+const Logger_1 = require("../utils/Logger");
+class TimerManager {
+    constructor(config, dbPool, _prefix) {
+        this.clear_expired_keys_set_duration = 2 * 60;
+        this.onTriggerClearAddressCache = (data_key, userId, blockchain, address, on_trigger) => __awaiter(this, void 0, void 0, function* () {
+            if (address && blockchain && userId !== undefined && userId !== null) {
+                try {
+                    const key = this.getTimerKey(userId, blockchain);
+                    const on_clear_key = `${this.custodial_clear_key_data_prefix}-${key}`;
+                    const on_clear_data = yield this.redis.get_object(data_key);
+                    yield on_trigger(on_clear_data.subscription, on_clear_data.address, Object.assign({}, on_clear_data));
+                }
+                catch (error) {
+                    this.logger.error(`Timer callback failed for user ${userId}:`, { data: { error, data_key, userId, blockchain, address } });
+                }
+                finally {
+                }
+            }
+            else {
+                this.logger.warn(`Failed to process clear address cache`, { data: { data_key, userId, blockchain, address } });
+            }
+        });
+        this.onAddressClear = (subscription, address, wallet) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (wallet.blockchain !== constants_1.BLOCKCHAINS.TRON) {
+                    // 1. Remove address from all Alchemy webhooks
+                    const alchemyService = AlchemyService_1.default.getInstance(this.config);
+                    yield alchemyService.add_remove_addresses_all_webhooks(subscription, wallet.blockchain, [], // no addresses to add
+                    [address] // address to remove
+                    );
+                }
+                // const dbPool = DatabasePool.getInstance(this.config);
+                // 2. Dispatch sweep job to ensure any remaining funds are swept
+                const sweep_job_service = new SweepJobService_1.default(this.dbPool, this.config);
+                yield sweep_job_service.dispatchAddSweepJobWithBalanceCheck(wallet.id, wallet.blockchain, wallet.userId, address, wallet.parentIndex, wallet.childIndex, true // force sweep due to expiry
+                );
+                this.logger.info(`Dispatched final sweep job for expired address ${address}`);
+            }
+            catch (error) {
+                this.logger.error(`Failed to handle address expiry for ${address}:`, { data: { error, subscription, address } });
+            }
+        });
+        this.config = config;
+        this.dbPool = dbPool;
+        this.key_prefix = _prefix ? _prefix : "TimerManager-timers";
+        this.custodial_clear_key_prefix = "custodialaddress";
+        this.custodial_clear_key_data_prefix = "cleardata";
+        this.timers = new Map();
+        this.redis = Redis_1.default.getInstance(config);
+        this.initialized = false;
+        this.expired_keys_set = new Set();
+        this.last_updated_set = Math.floor(new Date().getTime() / 1000);
+        this.logger = (0, Logger_1.createLogger)(`TimerManager`, config.pipelineConfig.azureAppName);
+    }
+    static getInstance(config, dbPool) {
+        if (!this.instance) {
+            this.instance = new TimerManager(config, dbPool);
+        }
+        return this.instance;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.initialized)
+                return;
+            yield this.redis.initialize();
+            yield this.redis.subscribeToExpiry((expired_key, value) => this.handleTimerExpiry(expired_key));
+            this.initialized = true;
+        });
+    }
+    handleTimerExpiry(expired_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const split_key = expired_key.split('-');
+                const keyprefix = this.key_prefix;
+                if (expired_key.endsWith('-cleardata'))
+                    return;
+                if (expired_key.startsWith(keyprefix)) {
+                    // Process address clear
+                    if (split_key[2] === this.custodial_clear_key_prefix) {
+                        const data_key = `${expired_key}-${this.custodial_clear_key_data_prefix}`;
+                        const data = yield this.redis.get_object(data_key);
+                        this.logger.info(`Timer expired for user ${data.userId} on ${data.blockchain}`);
+                        this.logger.info(`Expiring key-value: `, { userId: data.userId, blockchain: data.blockchain, address: data.address });
+                        // Prevent processing same event
+                        if (!this.add_to_set(expired_key)) {
+                            return;
+                        }
+                        yield this.onTriggerClearAddressCache(data_key, data.userId, data.blockchain, data.address, this.onAddressClear);
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error handling timer expiry for key ${expired_key}:`, { data: { error, expired_key } });
+            }
+        });
+    }
+    add_to_set(expiredKey) {
+        // Ensure key is not processed in the set
+        if (this.expired_keys_set.has(expiredKey))
+            return false;
+        const now = Math.floor(new Date().getTime() / 1000);
+        // Clear set if all contents are stale
+        if (now - this.last_updated_set >= this.clear_expired_keys_set_duration) {
+            this.expired_keys_set.clear();
+        }
+        // Add the new key
+        this.expired_keys_set.add(expiredKey);
+        // Set update time
+        this.last_updated_set = Math.floor(new Date().getTime() / 1000);
+        return true;
+    }
+    getTimerKey(userId, blockchain) {
+        return `${this.key_prefix}-${this.custodial_clear_key_prefix}-${userId}-${blockchain}`;
+    }
+    get_active_timers() {
+        return Array.from(this.timers.values()).map(({ userId, blockchain, expiresAt }) => ({
+            userId,
+            blockchain,
+            expiresAt
+        }));
+    }
+    exists_timer(userId, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.getTimerKey(userId, blockchain);
+            const timer = yield this.redis.get(key);
+            if (!timer)
+                return false;
+            return true;
+        });
+    }
+    create_if_not_exists(wallet_1, timeout_ms_1, subscription_1) {
+        return __awaiter(this, arguments, void 0, function* (wallet, timeout_ms, subscription, bonus_code = "") {
+            if (!this.initialized)
+                yield this.initialize();
+            const exists = yield this.exists_timer(wallet.userId, wallet.blockchain);
+            if (exists)
+                return true;
+            yield this.create_timer(wallet, timeout_ms, subscription, bonus_code);
+            return true;
+        });
+    }
+    set_clear_address_data(wallet, subscription, timeout_ms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.getTimerKey(wallet.userId, wallet.blockchain);
+            const clear_data_key = `${key}-${this.custodial_clear_key_data_prefix}`;
+            // Calculate expiration date
+            const { expires_at, expires_at_timestamp_s, duration_s } = (0, Utility_1.get_expiry_time)(Math.floor(timeout_ms / 1000));
+            yield this.redis.set_object(clear_data_key, Object.assign(Object.assign({}, wallet), { subscription }), { expires_at: expires_at_timestamp_s, ttl: duration_s });
+        });
+    }
+    create_timer(wallet_1, timeout_ms_1, subscription_1) {
+        return __awaiter(this, arguments, void 0, function* (wallet, timeout_ms, subscription, bonus_code = "") {
+            try {
+                const key = this.getTimerKey(wallet.userId, wallet.blockchain);
+                // Clear existing timer if any
+                yield this.clear_timer(wallet.userId, wallet.blockchain);
+                yield this.set_clear_address_data(wallet, subscription, timeout_ms + 100000);
+                yield this._create_timer(wallet, timeout_ms, bonus_code);
+                return true;
+            }
+            catch (error) {
+                this.logger.warn(`Failed to create timer for user ${wallet.userId}:`, { data: { error, address: wallet.address, bonus_code } });
+                return false;
+            }
+        });
+    }
+    _create_timer(wallet_1, timeout_ms_1) {
+        return __awaiter(this, arguments, void 0, function* (wallet, timeout_ms, bonus_code = "") {
+            const key = this.getTimerKey(wallet.userId, wallet.blockchain);
+            // Calculate expiration date
+            const { expires_at, expires_at_timestamp_s, duration_s } = (0, Utility_1.get_expiry_time)(Math.floor(timeout_ms / 1000));
+            // set timer info
+            yield this.redis.set_object(key, {
+                userId: wallet.userId,
+                blockchain: wallet.blockchain,
+                address: wallet.address,
+                expiresAt: expires_at,
+                bonusCode: bonus_code
+            }, { expires_at: expires_at_timestamp_s, ttl: duration_s, publish: { name: RedisPubSub_1.RedisPublishNames.NEW_CUSTODIAL_ADDRESS } });
+        });
+    }
+    delete_timer(userId, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.getTimerKey(userId, blockchain);
+            yield this.redis.delete(key);
+            return true;
+        });
+    }
+    clear_timer(userId, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.delete_timer(userId, blockchain);
+                return true;
+            }
+            catch (error) {
+                this.logger.error(`Failed to clear timer for user ${userId}:`, { data: { error, userId, blockchain } });
+                return false;
+            }
+        });
+    }
+    has_active_timer(userId, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.getTimerKey(userId, blockchain);
+            const val = yield this.redis.get(key);
+            if (val)
+                return true;
+            return false;
+        });
+    }
+}
+exports.default = TimerManager;

package/build/services/WalletIndexService.d.ts

@@ -0,0 +1,11 @@
+import { WalletIndex } from "../entities/WalletIndex";
+import { IDatabasePool } from "../interfaces/database";
+declare class WalletIndexService {
+    private dbPool;
+    constructor(dbPool: IDatabasePool);
+    createIndex(blockchain: string): Promise<WalletIndex>;
+    getNextAvailableIndex(blockchain: string): Promise<number>;
+    getAndIncrementNextAvailableIndex(blockchain: string): Promise<number>;
+}
+export default WalletIndexService;
+//# sourceMappingURL=WalletIndexService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WalletIndexService.d.ts","sourceRoot":"","sources":["../../src/services/WalletIndexService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,cAAM,kBAAkB;IACpB,OAAO,CAAC,MAAM,CAAgB;gBAClB,MAAM,EAAE,aAAa;IAIpB,WAAW,CAAC,UAAU,EAAE,MAAM;IAa9B,qBAAqB,CAAC,UAAU,EAAE,MAAM;IAmBxC,iCAAiC,CAAC,UAAU,EAAE,MAAM;CA4BpE;AAED,eAAe,kBAAkB,CAAC"}

package/build/services/WalletIndexService.js

@@ -0,0 +1,73 @@
+"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 });
+// import DatabasePool from "../database/DatabasePool";
+const WalletIndex_1 = require("../entities/WalletIndex");
+class WalletIndexService {
+    constructor(dbPool) {
+        this.dbPool = dbPool;
+    }
+    createIndex(blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbDriver = this.dbPool;
+            if (!dbDriver.walletIndexRepo) {
+                throw new Error(`App data source not initialized.`);
+            }
+            const index = new WalletIndex_1.WalletIndex();
+            index.blockchain = blockchain;
+            index.next_available_index = 0;
+            return yield dbDriver.walletIndexRepo.save(index);
+        });
+    }
+    getNextAvailableIndex(blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const dbDriver = this.dbPool;
+            if (!dbDriver.walletIndexRepo) {
+                throw new Error(`App data source not initialized.`);
+            }
+            const repo = (_a = dbDriver.customerAppDataSource) === null || _a === void 0 ? void 0 : _a.getRepository(WalletIndex_1.WalletIndex);
+            if (!repo)
+                throw new Error(`Database not initialized.`);
+            const entity = yield repo.findOne({
+                where: { blockchain }
+            });
+            if (!entity) {
+                yield this.createIndex(blockchain);
+                return 0;
+            }
+            return entity.next_available_index;
+        });
+    }
+    getAndIncrementNextAvailableIndex(blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentIndex = yield this.getNextAvailableIndex(blockchain);
+            const dbDriver = this.dbPool;
+            if (!dbDriver.walletIndexRepo || !dbDriver.customerAppDataSource) {
+                throw new Error(`Db Driver appDataSource not initialized.`);
+            }
+            // Wrap the pessimistic lock operation in a transaction
+            return yield dbDriver.customerAppDataSource.transaction((manager) => __awaiter(this, void 0, void 0, function* () {
+                // Find and update in a single query to prevent race conditions
+                const entity = yield manager.findOneOrFail(WalletIndex_1.WalletIndex, {
+                    where: { blockchain },
+                    lock: { mode: "pessimistic_write" }
+                });
+                const index = entity.next_available_index;
+                // Increment the next available index
+                entity.next_available_index += 1;
+                yield manager.save(entity);
+                return index;
+            }));
+        });
+    }
+}
+exports.default = WalletIndexService;

package/build/services/WalletManager.d.ts

@@ -0,0 +1,42 @@
+import { ethers } from "ethers";
+import { Keypair } from "@solana/web3.js";
+import { BlockchainType, ChainId } from "../interfaces";
+import { TransactionType } from "../utils/custodial";
+import { IConfig } from "../interfaces/config";
+import { IDatabasePool } from "../interfaces/database";
+import { BtcWallet, IWallet, TronNodeWallet } from "./types/wallet_manager";
+import { AlchemyWebhookEnvironment } from "./types/alchemy";
+import BaseErrors from "../errors/errors";
+declare class WalletManager extends BaseErrors {
+    static instance: WalletManager;
+    private config;
+    private dbPool;
+    default_address_expiry_s: number;
+    default_min_time_force_renew_s: number;
+    min_fund_wallet_amount_usd: number;
+    private logger;
+    constructor(config: IConfig, dbPool: IDatabasePool);
+    static getInstance(config: IConfig, dbPool: IDatabasePool): WalletManager;
+    getWallet: (userId: number, blockchain: BlockchainType) => Promise<IWallet | null>;
+    getEscrowFundsManagerWallet: (blockchain: BlockchainType) => ethers.Wallet | Keypair | TronNodeWallet;
+    fund_wallets_evm: (chainId: ChainId, wallets: string[], estimation_type: TransactionType) => Promise<string>;
+    private get_wallet_service_mnemonic;
+    createWallet: (userId: number, blockchain: BlockchainType) => Promise<IWallet>;
+    isAddressExpired(blockchain: BlockchainType, address: string): Promise<boolean>;
+    calculate_expiry(wallet: IWallet): {
+        is_expired: boolean;
+        expiry_date: Date;
+        default_expiry: number;
+        address_expiry_timestamp: number;
+        time_remaining: number;
+    };
+    deleteWallet: (userId: number, blockchain: BlockchainType) => Promise<{
+        status: boolean;
+        address: string;
+    }>;
+    renewWallet: (subscription: AlchemyWebhookEnvironment, userId: number, blockchain: BlockchainType, expired_address: string) => Promise<IWallet>;
+    handleRenewWallet: (subscription: AlchemyWebhookEnvironment, blockchain: BlockchainType, old_wallet: IWallet, new_wallet: IWallet) => Promise<IWallet>;
+    deriveWallet: (parentIndex: number, childIndex: number, blockchain: BlockchainType, _mnemonic?: string) => BtcWallet;
+}
+export default WalletManager;
+//# sourceMappingURL=WalletManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WalletManager.d.ts","sourceRoot":"","sources":["../../src/services/WalletManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAoC,MAAM,QAAQ,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAM1C,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAIxD,OAAO,EAAe,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAe,OAAO,EAAgB,cAAc,EAAc,MAAM,wBAAwB,CAAC;AACnH,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAO5D,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAK1C,cAAM,aAAc,SAAQ,UAAU;IAClC,MAAM,CAAC,QAAQ,EAAE,aAAa,CAAC;IAC/B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,MAAM,CAAgB;IACvB,wBAAwB,EAAE,MAAM,CAAC;IACjC,8BAA8B,EAAE,MAAM,CAAC;IACvC,0BAA0B,EAAE,MAAM,CAAC;IAC1C,OAAO,CAAC,MAAM,CAAS;gBACX,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;IAelD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;IAOlD,SAAS,GAAU,QAAQ,MAAM,EAAE,YAAY,cAAc,KAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAqB7F;IAEM,2BAA2B,GAAI,YAAY,cAAc,8CAoC/D;IAGM,gBAAgB,GAAU,SAAS,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,iBAAiB,eAAe,qBAiBrG;IAED,OAAO,CAAC,2BAA2B;IAa5B,YAAY,GAAU,QAAQ,MAAM,EAAE,YAAY,cAAc,KAAG,OAAO,CAAC,OAAO,CAAC,CA2BzF;IAEY,gBAAgB,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM;IAsBlE,gBAAgB,CAAC,MAAM,EAAE,OAAO;;;;;;;IAoBhC,YAAY,GAAU,QAAQ,MAAM,EAAE,YAAY,cAAc;;;OAGtE;IAGM,WAAW,GAAU,cAAc,yBAAyB,EAAE,QAAQ,MAAM,EAAE,YAAY,cAAc,EAAE,iBAAiB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,CAsC1J;IAEM,iBAAiB,GAAU,cAAc,yBAAyB,EAAE,YAAY,cAAc,EAAE,YAAY,OAAO,EAAE,YAAY,OAAO,sBAuB9I;IAIM,YAAY,GAAI,aAAa,MAAM,EAAE,YAAY,MAAM,EAAE,YAAY,cAAc,EAAE,YAAY,MAAM,eA4E7G;CAIJ;AAED,eAAe,aAAa,CAAC"}