@ercworldio/blockchain-shared 1.0.0-dev.4

package/build/services/WalletManager.js

@@ -0,0 +1,359 @@
+"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 ethers_1 = require("ethers");
+const web3_js_1 = require("@solana/web3.js");
+const bip39 = __importStar(require("bip39"));
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const ed25519 = __importStar(require("ed25519-hd-key"));
+const WalletIndexService_1 = __importDefault(require("./WalletIndexService"));
+const DepositAddressService_1 = __importDefault(require("./DepositAddressService"));
+const ProviderManager_1 = __importDefault(require("./ProviderManager"));
+const Escrow_1 = __importDefault(require("../contracts/Escrow"));
+const ChainManager_1 = __importDefault(require("./ChainManager"));
+const custodial_1 = require("../utils/custodial");
+const BalanceService_1 = __importDefault(require("./BalanceService"));
+const TimerManager_1 = __importDefault(require("./TimerManager"));
+const AlchemyService_1 = __importDefault(require("./AlchemyService"));
+const SweepJobService_1 = __importDefault(require("./SweepJobService"));
+const constants_1 = require("../constants");
+const tronweb_1 = require("tronweb");
+const errors_1 = __importDefault(require("../errors/errors"));
+const Logger_1 = require("../utils/Logger");
+class WalletManager extends errors_1.default {
+    constructor(config, dbPool) {
+        super();
+        this.getWallet = (userId, blockchain) => __awaiter(this, void 0, void 0, function* () {
+            const depositAddressService = new DepositAddressService_1.default(this.dbPool);
+            // Return null for non existing wallet
+            try {
+                const existingWallet = yield depositAddressService.getDepositAddress(userId, blockchain);
+                return {
+                    id: existingWallet.id,
+                    userId: existingWallet.user_id,
+                    address: existingWallet.address,
+                    parentIndex: existingWallet.parent_index,
+                    childIndex: existingWallet.child_index,
+                    transactionCount: existingWallet.transaction_count,
+                    blockchain: existingWallet.blockchain,
+                    updatedAt: existingWallet.updated_at,
+                    createdAt: existingWallet.created_at
+                };
+            }
+            catch (error) {
+                return null;
+            }
+        });
+        this.getEscrowFundsManagerWallet = (blockchain) => {
+            if (blockchain === constants_1.BLOCKCHAINS.EVM) {
+                const privKey = this.config.config.escrowFundingWalletPrivateKeyEvm;
+                if (!privKey)
+                    throw new Error(`Missing EVM funding wallet private key`);
+                const wallet = new ethers_1.Wallet(privKey);
+                return wallet;
+            }
+            else if (blockchain === constants_1.BLOCKCHAINS.SOLANA) {
+                const privKey = this.config.config.escrowFundingWalletPrivateKeySol;
+                if (!privKey)
+                    throw new Error(`Missing Solana funding wallet private key`);
+                // const secret = bs58.decode(privKey);
+                const secret = Buffer.from(privKey, "base64");
+                return web3_js_1.Keypair.fromSecretKey(secret);
+            }
+            else if (blockchain === constants_1.BLOCKCHAINS.TRON) {
+                const privKey = this.config.config.escrowFundingWalletPrivateKeyTron;
+                if (!privKey)
+                    throw new Error(`Missing Tron funding wallet private key`);
+                // Create TRON account
+                const hostUrl = this.config.config.environment === 'dev' || this.config.config.environment === 'local' ? "https://nile.trongrid.io" : "https://api.trongrid.io";
+                const tronWeb = new tronweb_1.TronWeb({ fullHost: hostUrl });
+                const address = tronWeb.address.fromPrivateKey(privKey);
+                if (!address)
+                    throw new Error(this.UnexpectedError("Failed to derive wallet address from private key on tron network"));
+                const tronWallet = {
+                    wallet: {
+                        address,
+                        publicKey: address,
+                        privateKey: privKey,
+                        sign: (tx) => tronWeb.trx.sign(tx, privKey),
+                    },
+                    address: address
+                };
+                return tronWallet.wallet;
+            }
+            else {
+                throw new Error(`Unsupported blockchain type ${blockchain}`);
+            }
+            ;
+        };
+        this.fund_wallets_evm = (chainId, wallets, estimation_type) => __awaiter(this, void 0, void 0, function* () {
+            const providerManager = ProviderManager_1.default.getInstance(this.config);
+            const provider = providerManager.getNewProvider(chainId).provider;
+            const funds_manager = this.getEscrowFundsManagerWallet("evm").connect(provider);
+            const balance = yield provider.getBalance(funds_manager);
+            const gas_cost = yield (0, custodial_1.estimateGas)(provider, ethers_1.ethers.ZeroAddress, null, (0, ethers_1.parseEther)("0.000001"), funds_manager.address, parseInt(chainId), estimation_type);
+            if (balance <= gas_cost)
+                throw new Error(`Insufficient funds in funds manager wallet. Please transfer ether tokens to the address ${funds_manager.address}`);
+            const funding_amount = gas_cost;
+            const chain_manager = ChainManager_1.default.getInstance(this.config);
+            const escrow_config = yield chain_manager.getEscrowContractForChain(parseInt(chainId));
+            let connected_funds_manager = funds_manager.connect(provider);
+            const escrowManager = new Escrow_1.default(escrow_config.addresses[0], provider, connected_funds_manager);
+            const response = yield escrowManager.fundWallets({ wallets, amount: funding_amount });
+            if (!response.transactionHash)
+                throw new Error("Failed to fund wallets.");
+            return response.transactionHash;
+        });
+        this.createWallet = (userId, blockchain) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // User main wallet mnemonic
+                const mnemonic = this.get_wallet_service_mnemonic(blockchain);
+                if (!mnemonic) {
+                    throw new Error(`Wallet service mnemonic not configured`);
+                }
+                // Get the next available parent index for this user
+                const walletIndexService = new WalletIndexService_1.default(this.dbPool);
+                const parentIndex = yield walletIndexService.getAndIncrementNextAvailableIndex(blockchain);
+                // Derive wallet using parent index and first account address
+                const depositAddressService = new DepositAddressService_1.default(this.dbPool);
+                const derivedWallet = this.deriveWallet(parentIndex, 0, blockchain);
+                if (!derivedWallet) {
+                    throw new Error(`Failed to derive child wallet.`);
+                }
+                // Create new entity in db
+                const newEntity = yield depositAddressService.createDepositAddress(userId, blockchain, parentIndex, derivedWallet.address);
+                return newEntity;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.deleteWallet = (userId, blockchain) => __awaiter(this, void 0, void 0, function* () {
+            const depositAddressService = new DepositAddressService_1.default(this.dbPool);
+            return yield depositAddressService.deleteDepositAddress(userId, blockchain);
+        });
+        this.renewWallet = (subscription, userId, blockchain, expired_address) => __awaiter(this, void 0, void 0, function* () {
+            const wallet = yield this.getWallet(userId, blockchain);
+            if (!wallet) {
+                throw new Error(`Wallet not found`);
+            }
+            // Choose next address_index in account
+            const newChildIndex = wallet.childIndex + 1;
+            // Derive new child
+            const newWallet = this.deriveWallet(wallet.parentIndex, newChildIndex, blockchain);
+            if (!newWallet) {
+                throw new Error("Failed to derive new wallet.");
+            }
+            const depositAddressService = new DepositAddressService_1.default(this.dbPool);
+            const updatedWallet = yield depositAddressService.updateDepositAddress(userId, {
+                parentIndex: wallet.parentIndex,
+                childIndex: newChildIndex,
+                blockchain,
+                address: newWallet.address,
+            });
+            const balanceService = new BalanceService_1.default(this.dbPool, this.config);
+            const deleteBalancesAndDispatchSweep = yield balanceService.removeWalletBalances(updatedWallet.id, blockchain);
+            if (!deleteBalancesAndDispatchSweep)
+                throw new Error(`Failed to remove wallet balances for expired address ${wallet.address}`);
+            const updatedBalance = yield balanceService.initializeWalletBalances(updatedWallet.id, blockchain);
+            if (!updatedBalance)
+                throw new Error(`Failed to initialize wallet balances for address ${updatedWallet.address}`);
+            const timerManager = TimerManager_1.default.getInstance(this.config, this.dbPool);
+            yield timerManager.delete_timer(userId, blockchain);
+            return updatedWallet;
+        });
+        this.handleRenewWallet = (subscription, blockchain, old_wallet, new_wallet) => __awaiter(this, void 0, void 0, function* () {
+            const wallet_manager = WalletManager.getInstance(this.config, this.dbPool);
+            const alchemy_service = AlchemyService_1.default.getInstance(this.config);
+            // Dispatch insert sweep job handler
+            const sweep_job_service = new SweepJobService_1.default(this.dbPool, this.config);
+            yield sweep_job_service.dispatchAddSweepJobWithBalanceCheck(old_wallet.id, old_wallet.blockchain, old_wallet.userId, old_wallet.address, old_wallet.parentIndex, old_wallet.childIndex, true // full sweep for expired wallet
+            );
+            // Add new address and remove expired address
+            const is_added_removed = yield alchemy_service.add_remove_addresses_all_webhooks(subscription, blockchain, [new_wallet.address], [old_wallet.address]);
+            if (!is_added_removed) {
+                throw new Error(`Failed to add new wallet to address activity monitor.`);
+            }
+            return new_wallet;
+        });
+        // TODO: revisit solana and btc wallet creation and return
+        this.deriveWallet = (parentIndex, childIndex, blockchain, _mnemonic) => {
+            try {
+                let mnemonic = _mnemonic;
+                if (!mnemonic) {
+                    mnemonic = this.get_wallet_service_mnemonic(blockchain);
+                }
+                if (!mnemonic) {
+                    throw new Error("Wallet service mnemonic not configured");
+                }
+                // Construct derivation path using parent id and child index based on blockchain type
+                let path = "";
+                switch (blockchain) {
+                    case constants_1.BLOCKCHAINS.TRON:
+                        path = `m/44'/195'/${parentIndex}'/0/${childIndex}`;
+                        // Derive private key
+                        const hdNode = ethers_1.ethers.HDNodeWallet.fromPhrase(mnemonic, "", path);
+                        const privateKey = hdNode.privateKey.replace("0x", "");
+                        // Create TRON account
+                        const hostUrl = this.config.config.environment === 'dev' || this.config.config.environment === 'local' ? "https://nile.trongrid.io" : "https://api.trongrid.io";
+                        const tronWeb = new tronweb_1.TronWeb({ fullHost: hostUrl });
+                        const address = tronWeb.address.fromPrivateKey(privateKey);
+                        if (!address)
+                            throw new Error(this.UnexpectedError("Failed to derive wallet address from private key on tron network"));
+                        const tronWallet = {
+                            wallet: {
+                                address,
+                                publicKey: address,
+                                privateKey: privateKey,
+                                sign: (tx) => tronWeb.trx.sign(tx, privateKey),
+                            },
+                            address: address
+                        };
+                        return tronWallet;
+                    case "evm":
+                        // Use Ethereum path standard
+                        path = `m/44'/60'/${parentIndex}'/0/${childIndex}`;
+                        // Just derive wallet from mnemonic and custom path
+                        const derivedWallet = ethers_1.ethers.HDNodeWallet.fromPhrase(mnemonic, "", path);
+                        return { wallet: derivedWallet, address: derivedWallet.address };
+                    case "solana":
+                        // Use Solana path standard
+                        path = `m/44'/501'/${parentIndex}'/${childIndex}'`;
+                        // Convert the mnemonic to a seed
+                        const seed = bip39.mnemonicToSeedSync(mnemonic);
+                        // Derive a seed from the given path
+                        const derivedSeed = ed25519.derivePath(path, seed.toString('hex')).key;
+                        // Generate a keypair from the derived seed
+                        const derivedUint8Keypair = tweetnacl_1.default.sign.keyPair.fromSeed(new Uint8Array(derivedSeed));
+                        // Convert to Solana web3.js Keypair object
+                        const customPathKeypair = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(derivedUint8Keypair.secretKey));
+                        return { address: customPathKeypair.publicKey.toBase58(), wallet: customPathKeypair };
+                    case "btc":
+                        // Use BTC path standard
+                        path = `m/44'/0'/${parentIndex}'/0/${childIndex}`;
+                        return {
+                            address: "",
+                            wallet: {}
+                        };
+                    default:
+                        throw new Error(`Unsupported blockchain: ${blockchain}.`);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error deriving wallet: `, { data: { error } });
+                throw error;
+            }
+        };
+        this.dbPool = dbPool;
+        this.config = config;
+        this.logger = (0, Logger_1.createLogger)(`WalletManager`, this.config.pipelineConfig.azureAppName);
+        if (!this.config.serverConfig) {
+            throw new Error("Server config not found");
+        }
+        this.default_address_expiry_s = this.config.serverConfig.custodialAddressDefaultExpiryInSeconds;
+        this.default_min_time_force_renew_s = this.config.serverConfig.custodialAddressDefaultMinDurationRefreshInSeconds;
+        this.min_fund_wallet_amount_usd = this.config.serverConfig.custodialMinFundingAmountInUsd;
+    }
+    static getInstance(config, dbPool) {
+        if (!WalletManager.instance) {
+            WalletManager.instance = new WalletManager(config, dbPool);
+        }
+        return WalletManager.instance;
+    }
+    get_wallet_service_mnemonic(blockchain) {
+        switch (blockchain) {
+            case constants_1.BLOCKCHAINS.EVM:
+                return this.config.config.walletServiceMnemonicEvm;
+            case constants_1.BLOCKCHAINS.SOLANA:
+                return this.config.config.walletServiceMnemonicSolana;
+            case constants_1.BLOCKCHAINS.TRON:
+                return this.config.config.walletServiceMnemonicTron;
+            default:
+                throw new Error(`No wallet service mnemonic for blockchain: ${blockchain}`);
+        }
+    }
+    isAddressExpired(blockchain, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const depositAddressService = new DepositAddressService_1.default(this.dbPool);
+                const wallet = yield depositAddressService.getDepositAddressByAddress(blockchain, address);
+                if (!wallet) {
+                    // If wallet not found, consider it expired
+                    return true;
+                }
+                const expiryTime = new Date(wallet.updated_at.getTime() + (this.default_address_expiry_s * 1000));
+                const now = new Date();
+                return now > expiryTime;
+            }
+            catch (error) {
+                this.logger.error(`Error checking address expiry: `, { data: { error } });
+                // If there's an error checking expiry, consider it expired for safety
+                return true;
+            }
+        });
+    }
+    calculate_expiry(wallet) {
+        const duration = new Date().getTime() - new Date(wallet.updatedAt).getTime();
+        if (duration < 0) {
+            throw new Error("Update date cannot be in the future.");
+        }
+        ;
+        // Calculate time remaining until expiry
+        const time_remaining = (this.default_address_expiry_s * 1000) - duration;
+        const default_expiry = WalletManager.getInstance(this.config, this.dbPool).default_address_expiry_s;
+        const address_expiry_timestamp = Math.floor(new Date(wallet.updatedAt).getTime()) + default_expiry * 1000;
+        const expiry_date = new Date(address_expiry_timestamp);
+        return {
+            is_expired: time_remaining <= 0,
+            expiry_date,
+            default_expiry,
+            address_expiry_timestamp,
+            time_remaining
+        };
+    }
+}
+exports.default = WalletManager;

package/build/services/WithdrawalManager.d.ts

@@ -0,0 +1,51 @@
+import Errors from "../errors/TransactionsErrors";
+import { BlockchainType, ChainId } from "../interfaces";
+import { ClaimJobs } from "../entities/ClaimJob";
+import { WithdrawRequestDetails } from "./types/claim";
+import { IDatabasePool } from "../interfaces/database";
+import { IConfig } from "../interfaces/config";
+import { ClaimJobsWithFee, WithdrawFeeEstimation } from "./types/withdrawal_manager";
+declare class WithdrawalManager extends Errors {
+    private claim_jobs_service;
+    private config;
+    private dbPool;
+    constructor(dbPool: IDatabasePool, config: IConfig);
+    private handle_get_withdraw_request;
+    get_withdraw_request: (id: number) => Promise<WithdrawRequestDetails>;
+    is_source_address: (user_id: number, address: string, blockchain: BlockchainType) => Promise<boolean>;
+    is_available_request_id: (request_id: number, chain_id: ChainId) => Promise<boolean>;
+    estimate_batch_withdraw_cost: (blockchain: BlockchainType, chain_id: ChainId, queue: ClaimJobs[]) => Promise<{
+        estimation_map: Map<number, WithdrawFeeEstimation>;
+        updated_queue: ClaimJobsWithFee[];
+    }>;
+    estimate_cost_for_user: (blockchain: BlockchainType, chain_id: ChainId, receiver: string, token: string, display_currency: string, user_id: number) => Promise<{
+        estimate_units: number;
+        estimate_in_decimals: number;
+        estimate_in_usdt: number;
+        estimate_in_usdt_decimals: number;
+        token_price: number;
+        estimate_in_usdt_precision: number;
+    } | {
+        estimate_units: number;
+        estimate_in_decimals: number;
+        estimate_in_usdt: bigint;
+        estimate_in_usdt_decimals: number;
+        token_price: any;
+        estimate_in_usdt_precision: number;
+    }>;
+    get_estimate_for_batch: (blockchain: BlockchainType, chain_id: ChainId, queue: ClaimJobs[], extra_config?: {
+        token?: string;
+        receiver?: string;
+        user_id?: number;
+    }) => Promise<{
+        estimate: bigint;
+        estimate_decimals: number;
+        tx_count: number;
+    }>;
+    private calculate_cost_per_job;
+    private calculate_estimate_for_user;
+    private parse_cost_stable_coin;
+    private calculate_estimate_for_user_deprecated;
+}
+export default WithdrawalManager;
+//# sourceMappingURL=WithdrawalManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WithdrawalManager.d.ts","sourceRoot":"","sources":["../../src/services/WithdrawalManager.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,MAAM,8BAA8B,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAYxD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAIrF,cAAM,iBAAkB,SAAQ,MAAM;IAClC,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,MAAM,CAAgB;gBAClB,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO;IAQlD,OAAO,CAAC,2BAA2B,CAGlC;IAGM,oBAAoB,GAAU,IAAI,MAAM,KAAG,OAAO,CAAC,sBAAsB,CAAC,CAIhF;IAIM,iBAAiB,GAAU,SAAS,MAAM,EAAE,SAAS,MAAM,EAAE,YAAY,cAAc,KAAG,OAAO,CAAC,OAAO,CAAC,CAIhH;IAGM,uBAAuB,GAAU,YAAY,MAAM,EAAE,UAAU,OAAO,sBAU5E;IAEM,4BAA4B,GAAU,YAAY,cAAc,EAAE,UAAU,OAAO,EAAE,OAAO,SAAS,EAAE;;;OAoB7G;IAMM,sBAAsB,GAAU,YAAY,cAAc,EAAE,UAAU,OAAO,EAAE,UAAU,MAAM,EAAE,OAAO,MAAM,EAAE,kBAAkB,MAAM,EAAE,SAAS,MAAM;;;;;;;;;;;;;;OA2E/J;IAIM,sBAAsB,GAAU,YAAY,cAAc,EAAE,UAAU,OAAO,EAAE,OAAO,SAAS,EAAE,EAAE,eAAe;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;;;;OAmD/K;IAKD,OAAO,CAAC,sBAAsB,CAoC7B;IAOD,OAAO,CAAC,2BAA2B,CAwDlC;IAED,OAAO,CAAC,sBAAsB,CAuB7B;IAED,OAAO,CAAC,sCAAsC,CAiG7C;CAGJ;AAED,eAAe,iBAAiB,CAAC"}