@render-foundation/utils 0.0.188 → 0.0.189

package/lib/cjs/backfiller.js

@@ -0,0 +1,932 @@
+"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 });
+exports.Backfiller = exports.heliusClient = exports.solscanProClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const v2Client_1 = require("./client/pg/v2Client");
+const emission_distributor_sdk_1 = require("@render-foundation/emission-distributor-sdk");
+const helius_sdk_1 = require("helius-sdk");
+const solscanProClient = (apiKey) => {
+    const headers = {
+        token: apiKey,
+    };
+    const baseUrl = "https://pro-api.solscan.io/v2.0";
+    return {
+        getSignaturesForAddress(addr, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const allSignatures = [];
+                let before = options === null || options === void 0 ? void 0 : options.before;
+                const limit = Math.min((options === null || options === void 0 ? void 0 : options.limit) || 40, 40);
+                while (true) {
+                    const params = new URLSearchParams({
+                        address: addr.toString(),
+                        limit: limit.toString(),
+                    });
+                    if (before) {
+                        params.append("before", before);
+                    }
+                    const endpoint = `${baseUrl}/account/transactions?${params}`;
+                    const response = yield fetch(endpoint, { headers });
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch signatures: ${response.statusText}`);
+                    }
+                    const data = yield response.json();
+                    const signatures = data.data || [];
+                    const transformedSigs = signatures.map((tx) => ({
+                        signature: tx.txHash || tx.signature,
+                        blockTime: tx.blockTime || tx.block_time || 0,
+                        err: tx.status !== "Success" ? { err: tx.status } : null,
+                    }));
+                    allSignatures.push(...transformedSigs);
+                    if (signatures.length < limit || ((options === null || options === void 0 ? void 0 : options.limit) && allSignatures.length >= options.limit)) {
+                        break;
+                    }
+                    // Set before to the last signature for next page
+                    if (signatures.length > 0) {
+                        before = signatures[signatures.length - 1].txHash || signatures[signatures.length - 1].signature;
+                    }
+                }
+                return allSignatures.slice(0, options === null || options === void 0 ? void 0 : options.limit);
+            });
+        },
+        getParsedTransaction(signature) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const endpoint = `${baseUrl}/transaction/details?tx=${signature}`;
+                const response = yield fetch(endpoint, { headers });
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch transaction: ${response.statusText}`);
+                }
+                const data = yield response.json();
+                return {
+                    meta: {
+                        err: data.status !== "Success" ? { err: data.status } : null,
+                        logMessages: data.logMessages || [],
+                        preTokenBalances: data.inputAccount || [],
+                        postTokenBalances: data.outputAccount || [],
+                    },
+                    blockTime: data.blockTime || data.block_time || 0,
+                    status: data.status,
+                    err: data.status !== "Success" ? { err: data.status } : null,
+                    tokenBalances: data.tokenBalances || [],
+                    preTokenBalances: data.inputAccount || [],
+                    postTokenBalances: data.outputAccount || [],
+                };
+            });
+        },
+        getBalanceChange(f) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const allTransfers = [];
+                    let page = 1;
+                    const pageSize = Math.min(((_a = f.options) === null || _a === void 0 ? void 0 : _a.limit) || 100, 100);
+                    while (true) {
+                        const params = new URLSearchParams({
+                            address: f.addr.toString(),
+                            page: page.toString(),
+                            page_size: pageSize.toString(),
+                        });
+                        if (f.mint) {
+                            params.append("token", f.mint.toString());
+                        }
+                        if (f.flow) {
+                            params.append("flow", f.flow);
+                        }
+                        if (f.tokenAccount) {
+                            params.append("token_account", f.tokenAccount.toString());
+                        }
+                        const endpoint = `${baseUrl}/account/balance_change?${params}`;
+                        const response = yield fetch(endpoint, { headers });
+                        if (f.tokenAccount.toString() === constants_1.polyBridgeEscrow) {
+                            console.log("Poly solscan response: ", JSON.stringify(response));
+                        }
+                        if (!response.ok) {
+                            console.error(`Failed to fetch balance changes: ${response.statusText}`);
+                            break;
+                        }
+                        const body = yield response.json();
+                        const transfers = [];
+                        if (f.tokenAccount.toString() === constants_1.polyBridgeEscrow) {
+                            console.log("poly solscan data: ", JSON.stringify(body));
+                        }
+                        for (const item of body.data || []) {
+                            if (item.change_type === (f.flow === "in" ? "inc" : "dec")) {
+                                transfers.push({
+                                    amount: Math.abs(item.amount || 0),
+                                    tokenDecimals: item.token_decimals || 0,
+                                    sig: item.trans_id,
+                                    blockTime: item.block_time || 0,
+                                });
+                            }
+                        }
+                        allTransfers.push(...transfers);
+                        if (transfers.length === 0 || transfers.length < pageSize) {
+                            break;
+                        }
+                        page++;
+                    }
+                    return allTransfers.filter((t) => t.amount !== 0);
+                }
+                catch (error) {
+                    console.error("Error in getBalanceChange:", error);
+                    return [];
+                }
+            });
+        },
+        getTransfers(f) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const allTransfers = [];
+                    let page = 1;
+                    const pageSize = Math.min(f.pageSize || 100, 100);
+                    while (true) {
+                        const params = new URLSearchParams({
+                            address: f.addr.toString(),
+                            token: f.mint.toString(),
+                            flow: f.flow,
+                            page: page.toString(),
+                            page_size: pageSize.toString(),
+                        });
+                        const endpoint = `${baseUrl}/account/transfer?${params}`;
+                        const response = yield fetch(endpoint, { headers });
+                        if (!response.ok) {
+                            throw new Error(`Failed to fetch transfers: ${response.statusText}`);
+                        }
+                        const body = yield response.json();
+                        const transfers = [];
+                        for (const item of body.data || []) {
+                            transfers.push({
+                                amount: item.amount || 0,
+                                tokenDecimals: item.token_decimals || 0,
+                                fromAddress: item.from_address ? new web3_js_1.PublicKey(item.from_address) : undefined,
+                                toAddress: item.to_address ? new web3_js_1.PublicKey(item.to_address) : undefined,
+                                sig: item.trans_id,
+                                blockTime: item.block_time || 0,
+                            });
+                        }
+                        allTransfers.push(...transfers);
+                        if (transfers.length === 0 || transfers.length < pageSize) {
+                            break;
+                        }
+                        page++;
+                    }
+                    return allTransfers.filter((t) => t.amount !== 0);
+                }
+                catch (error) {
+                    console.error("Error in getTransfers:", error);
+                    throw new Error(`Failed to get transfers: ${error}`);
+                }
+            });
+        },
+    };
+};
+exports.solscanProClient = solscanProClient;
+const heliusClient = (apiKey) => {
+    const helius = new helius_sdk_1.Helius(apiKey, "mainnet-beta");
+    return {
+        getSignaturesForAddress(addr, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return helius.connection.getSignaturesForAddress(addr, {
+                    before: options === null || options === void 0 ? void 0 : options.before,
+                    limit: (options === null || options === void 0 ? void 0 : options.limit) || 1000,
+                });
+            });
+        },
+        getParsedTransaction(signature) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return helius.connection.getTransaction(signature, {
+                    maxSupportedTransactionVersion: 0,
+                });
+            });
+        },
+        getBalanceChange(f) {
+            var _a, _b, _c, _d;
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // Get transactions for the address
+                    const response = yield helius.connection.getSignaturesForAddress(f.addr, {
+                        limit: 100,
+                    });
+                    const transfers = [];
+                    // Process each signature to get transaction details
+                    for (const sig of response) {
+                        try {
+                            const tx = yield helius.connection.getTransaction(sig.signature, {
+                                maxSupportedTransactionVersion: 0,
+                            });
+                            if (!tx || ((_a = tx.meta) === null || _a === void 0 ? void 0 : _a.err))
+                                continue;
+                            // Look for token balance changes
+                            const preBalances = tx.meta.preTokenBalances || [];
+                            const postBalances = tx.meta.postTokenBalances || [];
+                            for (const postBalance of postBalances) {
+                                if (postBalance.mint !== f.mint.toString())
+                                    continue;
+                                if (postBalance.owner !== f.addr.toString())
+                                    continue;
+                                const preBalance = preBalances.find((pre) => pre.accountIndex === postBalance.accountIndex);
+                                const preAmount = Number(((_b = preBalance === null || preBalance === void 0 ? void 0 : preBalance.uiTokenAmount) === null || _b === void 0 ? void 0 : _b.amount) || 0);
+                                const postAmount = Number(((_c = postBalance.uiTokenAmount) === null || _c === void 0 ? void 0 : _c.amount) || 0);
+                                const change = postAmount - preAmount;
+                                if (change !== 0) {
+                                    const isInflow = change > 0;
+                                    if ((f.flow === "in" && isInflow) || (f.flow === "out" && !isInflow)) {
+                                        transfers.push({
+                                            amount: Math.abs(change),
+                                            tokenDecimals: ((_d = postBalance.uiTokenAmount) === null || _d === void 0 ? void 0 : _d.decimals) || 0,
+                                            sig: sig.signature,
+                                            blockTime: tx.blockTime || 0,
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                        catch (e) {
+                            console.error(`Error processing signature ${sig.signature}:`, e);
+                        }
+                    }
+                    return transfers.filter((t) => t.amount !== 0);
+                }
+                catch (error) {
+                    console.error("Error in getBalanceChange:", error);
+                    return [];
+                }
+            });
+        },
+        getTransfers(f) {
+            var _a, _b, _c, _d;
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // Use enhanced transactions API for better token transfer data
+                    const response = yield helius.connection.getSignaturesForAddress(f.addr, {
+                        limit: f.pageSize || 100,
+                    });
+                    const transfers = [];
+                    for (const sig of response) {
+                        try {
+                            const tx = yield helius.connection.getTransaction(sig.signature, {
+                                maxSupportedTransactionVersion: 0,
+                            });
+                            if (!tx || ((_a = tx.meta) === null || _a === void 0 ? void 0 : _a.err))
+                                continue;
+                            // Parse token transfers from transaction
+                            const preTokenBalances = tx.meta.preTokenBalances || [];
+                            const postTokenBalances = tx.meta.postTokenBalances || [];
+                            // Group by account index to track transfers
+                            const balanceChanges = new Map();
+                            for (const postBalance of postTokenBalances) {
+                                if (postBalance.mint !== f.mint.toString())
+                                    continue;
+                                const preBalance = preTokenBalances.find((pre) => pre.accountIndex === postBalance.accountIndex);
+                                const preAmount = Number(((_b = preBalance === null || preBalance === void 0 ? void 0 : preBalance.uiTokenAmount) === null || _b === void 0 ? void 0 : _b.amount) || 0);
+                                const postAmount = Number(((_c = postBalance.uiTokenAmount) === null || _c === void 0 ? void 0 : _c.amount) || 0);
+                                const change = postAmount - preAmount;
+                                if (change !== 0) {
+                                    balanceChanges.set(postBalance.accountIndex, {
+                                        mint: postBalance.mint,
+                                        owner: postBalance.owner,
+                                        change,
+                                        decimals: ((_d = postBalance.uiTokenAmount) === null || _d === void 0 ? void 0 : _d.decimals) || 0,
+                                    });
+                                }
+                            }
+                            // Find transfers involving the target address
+                            for (const [accountIndex, balanceChange] of balanceChanges) {
+                                const isFromTarget = balanceChange.owner === f.addr.toString() && balanceChange.change < 0;
+                                const isToTarget = balanceChange.owner === f.addr.toString() && balanceChange.change > 0;
+                                if ((f.flow === "out" && isFromTarget) || (f.flow === "in" && isToTarget)) {
+                                    // Find the counterpart transfer
+                                    let fromAddress;
+                                    let toAddress;
+                                    if (isFromTarget) {
+                                        fromAddress = f.addr;
+                                        // Find who received the tokens
+                                        for (const [_, otherChange] of balanceChanges) {
+                                            if (otherChange.owner !== f.addr.toString() && otherChange.change > 0) {
+                                                toAddress = new web3_js_1.PublicKey(otherChange.owner);
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        toAddress = f.addr;
+                                        // Find who sent the tokens
+                                        for (const [_, otherChange] of balanceChanges) {
+                                            if (otherChange.owner !== f.addr.toString() && otherChange.change < 0) {
+                                                fromAddress = new web3_js_1.PublicKey(otherChange.owner);
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    transfers.push({
+                                        amount: Math.abs(balanceChange.change),
+                                        tokenDecimals: balanceChange.decimals,
+                                        fromAddress,
+                                        toAddress,
+                                        sig: sig.signature,
+                                        blockTime: tx.blockTime || 0,
+                                    });
+                                }
+                            }
+                        }
+                        catch (e) {
+                            console.error(`Error processing signature ${sig.signature}:`, e);
+                        }
+                    }
+                    return transfers.filter((t) => t.amount !== 0);
+                }
+                catch (error) {
+                    console.error("Error in getTransfers:", error);
+                    throw new Error(`Failed to get transfers: ${error}`);
+                }
+            });
+        },
+    };
+};
+exports.heliusClient = heliusClient;
+class Backfiller {
+    constructor(solscanApiKey, heliusApiKey, pg, isDryRun = false) {
+        this._types = {};
+        this._txs = [];
+        this.isDryRun = false;
+        this.solscan = { pageSize: 100 };
+        this.solscan.apiKey = solscanApiKey;
+        this.solscanClient = (0, exports.solscanProClient)(solscanApiKey);
+        this.heliusClient = (0, exports.heliusClient)(heliusApiKey);
+        this.pg = pg;
+        this.isDryRun = isDryRun;
+    }
+    emit() {
+        this._types["emit"] = {};
+        return this;
+    }
+    loans() {
+        this._types["loan"] = {};
+        return this;
+    }
+    buyBurnUSDCInflow() {
+        this._types["buyBurnUSDCInflow"] = {};
+        return this;
+    }
+    manualMint() {
+        this._types["manualMint"] = {};
+        return this;
+    }
+    renderComputeNetwork() {
+        this._types["renderComputeNetwork"] = {};
+        return this;
+    }
+    burnRENDERInflow() {
+        this._types["burnRENDERInflow"] = {};
+        return this;
+    }
+    vaultOutflows(p) {
+        this._types["vaultOutflows"] = {};
+        this.solscan.pageSize = p.pageSize || 100;
+        return this;
+    }
+    txs(...sigs) {
+        this._txs.push(...sigs);
+    }
+    formatAmount(amount, decimals = 8) {
+        const amt = typeof amount === "bigint" ? Number(amount) : amount;
+        return (amt / Math.pow(10, decimals)).toLocaleString(undefined, {
+            maximumFractionDigits: 8,
+            minimumFractionDigits: 0,
+        });
+    }
+    formatTimestamp(blockTime) {
+        return new Date(blockTime * 1000).toISOString();
+    }
+    indexLoans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const trs = [
+                {
+                    transfer: {
+                        toSolKey: "2P2gisXpbsYEUsTDQKdcDKSg1UZvx7qxfLTkvJGZdeJC",
+                        fromSolKey: constants_1.v3SquadsVault,
+                        solTx: "3oC8BybX5YrkfPyvV8rAE1tnJr6egtZFHLghqHuLi3eaT4aWm87qZPJFrjFRn6nwVemd2ponsew85tBs6VVQzTJv",
+                        executedAt: new Date("December 22, 2023 04:13:58 UTC"),
+                        symbol: "RENDER",
+                        channel: "loan",
+                        amountPayed: BigInt(44999 * Math.pow(10, 8)),
+                    },
+                },
+                {
+                    transfer: {
+                        toSolKey: "2P2gisXpbsYEUsTDQKdcDKSg1UZvx7qxfLTkvJGZdeJC",
+                        fromSolKey: constants_1.v3SquadsVault,
+                        channel: "loan",
+                        solTx: "2f5sEBHcP8wpF79voUEUiP8pryDt7FvqrTXQrEpXzAxbzyFYPkavZGtJc5N8CXhfbJav8hQTr9YcENKseiouaWzc",
+                        executedAt: new Date("December 22, 2023 02:39:53 UTC"),
+                        symbol: "RENDER",
+                        amountPayed: BigInt(1 * Math.pow(10, 8)),
+                    },
+                },
+                {
+                    transfer: {
+                        toSolKey: "5DGbogKUo8haEYC9Tt4FTHE5ue55bjLC4DpSgE1g6yT1",
+                        fromSolKey: constants_1.v3SquadsVault,
+                        channel: "loan",
+                        solTx: "42n55BZcKVBCSZQoaneBQLn57v7zZGZorGe3uBLheGu4BQtpaTChdT1z3vHwgU4MHghJw3wJ72rFLkib761ewJCj",
+                        executedAt: new Date("January 12, 2024 00:17:02 UTC"),
+                        symbol: "RENDER",
+                        amountPayed: BigInt(1 * Math.pow(10, 8)),
+                    },
+                },
+                {
+                    transfer: {
+                        toSolKey: "5DGbogKUo8haEYC9Tt4FTHE5ue55bjLC4DpSgE1g6yT1",
+                        fromSolKey: constants_1.v3SquadsVault,
+                        channel: "loan",
+                        solTx: "THJLvA1UTqH22hNP7Ecnfn4iY736VJAZ8scgSUjrDDaGpSQJmGYKJYXGtDu6TB96fKo6mJBtUBZvLb4ors17JUR",
+                        executedAt: new Date("January 17, 2024 22:09:58 UTC"),
+                        symbol: "RENDER",
+                        amountPayed: BigInt(49999 * Math.pow(10, 8)),
+                    },
+                },
+                {
+                    transfer: {
+                        toSolKey: "5DGbogKUo8haEYC9Tt4FTHE5ue55bjLC4DpSgE1g6yT1",
+                        fromSolKey: constants_1.devsSquadsVault,
+                        channel: "loan",
+                        solTx: "5BcxrMExq34jtMB5c3bH3A8TN4pCp9sxjC5HMcS7Mh8pig3r2eQhvRnJeE1RBTyQ4JDXyANWmDU9SKdYFyT2wDoq",
+                        executedAt: new Date("February 28, 2024 22:43:21 UTC"),
+                        symbol: "RENDER",
+                        amountPayed: BigInt(1 * Math.pow(10, 8)),
+                    },
+                },
+                {
+                    transfer: {
+                        toSolKey: "5DGbogKUo8haEYC9Tt4FTHE5ue55bjLC4DpSgE1g6yT1",
+                        fromSolKey: constants_1.devsSquadsVault,
+                        channel: "loan",
+                        solTx: "5E4E35CT4e3fhbMAwcKdfAvJL4uUHR8hHE8REmKnDCEsFZ6mxaE1YyeYK8Sbg5AJqBJxsZkcYSohY8T14YLC5pXs",
+                        executedAt: new Date("February 29, 2024 01:17:51 UTC"),
+                        symbol: "RENDER",
+                        amountPayed: BigInt(199999 * Math.pow(10, 8)),
+                    },
+                },
+            ];
+            if (this.isDryRun) {
+                for (const t of trs) {
+                    const amount = this.formatAmount(t.transfer.amountPayed);
+                    const timestamp = this.formatTimestamp(t.transfer.executedAt.getTime() / 1000);
+                    console.log(`${t.transfer.solTx} | ${timestamp} | ${t.transfer.channel} | ${t.transfer.fromSolKey} -> ${t.transfer.toSolKey} | ${amount} ${t.transfer.symbol}`);
+                }
+                return;
+            }
+            for (const t of trs) {
+                try {
+                    yield this.pg.createPayments(this.pg.db, [t]);
+                }
+                catch (e) {
+                    console.log(`except ${e}`);
+                }
+            }
+        });
+    }
+    findEmitTxs() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const fetchSigs = (ads) => __awaiter(this, void 0, void 0, function* () {
+                const uniqSigs = {};
+                const sigsAgg = [];
+                for (const ad of ads) {
+                    const sigs = [];
+                    while (true) {
+                        const sigsBatch = yield this.heliusClient.getSignaturesForAddress(ad, {
+                            before: sigs.length > 0 ? sigs[sigs.length - 1].signature : undefined,
+                            limit: 1000,
+                        });
+                        sigs.push(...sigsBatch.filter((s) => !uniqSigs[s.signature]));
+                        for (const s of sigsBatch) {
+                            uniqSigs[s.signature] = true;
+                        }
+                        if (sigsBatch.length < 1000) {
+                            break;
+                        }
+                    }
+                    if (!this.isDryRun) {
+                        console.log(`fetched ${sigs.length} sigs for ${ad}`);
+                    }
+                    sigsAgg.push(...sigs);
+                }
+                sigsAgg.sort((a, b) => b.blockTime - a.blockTime);
+                return sigsAgg;
+            });
+            const sigs = yield fetchSigs([
+                (0, emission_distributor_sdk_1.emissionDistributorKey)(new web3_js_1.PublicKey(constants_1.renderMint))[0],
+                (0, emission_distributor_sdk_1.emissionDistributorV1Key)(new web3_js_1.PublicKey(constants_1.renderMint))[0],
+            ]);
+            if (!this.isDryRun) {
+                console.log(`sigs ${sigs.length}`);
+            }
+            let proced = 0;
+            const out = [];
+            for (const s of sigs) {
+                const p = yield this.heliusClient.getParsedTransaction(s.signature);
+                if (((_a = p === null || p === void 0 ? void 0 : p.meta) === null || _a === void 0 ? void 0 : _a.err) || (p === null || p === void 0 ? void 0 : p.err)) {
+                    continue;
+                }
+                const logMessages = ((_b = p === null || p === void 0 ? void 0 : p.meta) === null || _b === void 0 ? void 0 : _b.logMessages) || [];
+                for (const l of logMessages) {
+                    if (l.includes('DistributeEmissionsV0') ||
+                        l.includes('DistributeEmissionsV1')) {
+                        out.push(s.signature);
+                        if (this.isDryRun) {
+                            console.log(`${s.signature} | ${this.formatTimestamp(s.blockTime)} | emission | Emission Distributor -> Various Recipients | N/A RENDER`);
+                        }
+                        break;
+                    }
+                }
+                proced += 1;
+                if (proced % 10 == 0 && !this.isDryRun) {
+                    console.log(`proced ${proced}`);
+                }
+            }
+            console.log(`emit txs: ${out.length}`);
+            return out;
+        });
+    }
+    indexTxs(txs, channel, reindexTx = false, deleteFailed = false, mints = [constants_1.renderMint, constants_1.usdcMint], senders = [
+        constants_1.passthruEscrow,
+        constants_1.v3SquadsVault,
+        constants_1.upgradeRewardsEscrow,
+        constants_1.upgradeRewardsCircuitBreaker,
+        constants_1.renderMint,
+    ], assertSender = '') {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            let proced = 0;
+            console.log(`processing ${txs.length} txs`);
+            const insertedIds = [];
+            for (const solTx of txs) {
+                if (solTx == '') {
+                    continue;
+                }
+                console.log(`solTx ${solTx}`);
+                const tx = yield this.heliusClient.getParsedTransaction(solTx);
+                if (!tx || (tx.status !== 'Success' && tx.err)) {
+                    if (this.isDryRun) {
+                        console.log(`Would delete failed transaction ${solTx} from database`);
+                        continue;
+                    }
+                    console.log(`shouldnt exist ${solTx} in db. deleting`);
+                    try {
+                        const res = yield this.pg.db.trx.deleteFrom('sol_tx')
+                            .where('sig', '=', solTx)
+                            .execute();
+                        console.log(`deleted ${res.length > 0 ? res[0].numDeletedRows || 0 : 0} tx`);
+                    }
+                    catch (e) {
+                        console.log(`failed to delete tx ${solTx}: ${e}`);
+                    }
+                    continue;
+                }
+                const onchain = {};
+                const tokenBalances = ((_a = tx.meta) === null || _a === void 0 ? void 0 : _a.tokenBalances) || [];
+                const preTokenBalances = ((_b = tx.meta) === null || _b === void 0 ? void 0 : _b.preTokenBalances) || [];
+                const postTokenBalances = ((_c = tx.meta) === null || _c === void 0 ? void 0 : _c.postTokenBalances) || [];
+                for (const balance of postTokenBalances) {
+                    const mint = mints.find((m) => balance.mint === m);
+                    if (mint) {
+                        const amt = Number(((_d = balance.uiTokenAmount) === null || _d === void 0 ? void 0 : _d.amount) || balance.amount || 0);
+                        onchain[balance.owner] = { mint, amt };
+                    }
+                }
+                let sender = '';
+                for (const balance of preTokenBalances) {
+                    const mint = mints.find((m) => balance.mint === m);
+                    if (mint) {
+                        const amt = Number(((_e = balance.uiTokenAmount) === null || _e === void 0 ? void 0 : _e.amount) || balance.amount || 0);
+                        if (onchain[balance.owner]) {
+                            onchain[balance.owner] = {
+                                mint,
+                                amt: onchain[balance.owner].amt - amt,
+                            };
+                            if (onchain[balance.owner].amt < 0) {
+                                const foundSender = senders.find((s) => s === balance.owner.toString());
+                                if (!foundSender) {
+                                    throw new Error(`sender ${balance.owner} not in expected senders ${senders}`);
+                                }
+                                if (assertSender !== '' && foundSender !== assertSender) {
+                                    throw new Error(`assert sender ${balance.owner} != ${assertSender}`);
+                                }
+                                sender = foundSender;
+                            }
+                        }
+                    }
+                }
+                if (channel === 'emit') {
+                    sender = constants_1.renderMint;
+                }
+                if (!sender) {
+                    console.log(`no matching sender found`);
+                }
+                if (Object.keys(onchain).length === 0) {
+                    console.log(`skipping ${solTx}. nothing to index`);
+                    continue;
+                }
+                const result = yield this.indexTransfers(onchain, { blockTime: tx.blockTime || tx.blocktime || 0, sig: solTx }, sender, channel, reindexTx);
+                if (!this.isDryRun && result.insertedIds) {
+                    insertedIds.push(...result.insertedIds);
+                }
+                if (result.stop) {
+                    console.log(`stopping processing due to catch-up at tx ${solTx}`);
+                    break;
+                }
+                proced += 1;
+                if (proced % 10 === 0 && !this.isDryRun) {
+                    console.log(`proced ${proced}`);
+                }
+            }
+            console.log(`done. inserted ${insertedIds.length} transfers: ${insertedIds.join(',')}`);
+        });
+    }
+    indexTransfers(onchain, tx, sender, channel, reindexTx = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ents = Object.entries(onchain).filter(([k, { mint, amt }]) => amt != 0);
+            if (this.isDryRun) {
+                for (const [k, { amt, mint }] of ents) {
+                    if (k == sender) {
+                        continue;
+                    }
+                    const symbol = (() => {
+                        if (mint == constants_1.renderMint) {
+                            return 'RENDER';
+                        }
+                        if (mint == constants_1.usdcMint) {
+                            return 'USDC';
+                        }
+                        return 'UNKNOWN';
+                    })();
+                    const amount = this.formatAmount(amt);
+                    const timestamp = this.formatTimestamp(tx.blockTime);
+                    console.log(`would insert ${tx.sig.slice(0, 8)}... | ${timestamp} | ${channel} | ${sender} -> ${k} | ${amount} ${symbol}`);
+                }
+                return { stop: false, insertedIds: [] };
+            }
+            if (reindexTx) {
+                try {
+                    const res = yield this.pg.db.trx.deleteFrom('sol_tx')
+                        .where('sig', '=', tx.sig)
+                        .execute();
+                    console.log(`deleted ${res.length > 0 ? res[0].numDeletedRows || 0 : 0} tx`);
+                }
+                catch (e) {
+                    console.log(`failed to delete tx ${tx.sig}: ${e}`);
+                }
+            }
+            console.log(`diffs: ${ents.map(([k, v]) => `k ${k} v -> ${JSON.stringify(v)}`)}`);
+            const insertedIds = [];
+            for (const [k, { amt, mint }] of ents) {
+                if (k == sender) {
+                    continue;
+                }
+                const trx = yield this.pg.startTransaction();
+                try {
+                    const { inserted } = yield this.pg.createPayments(trx, [
+                        {
+                            transfer: {
+                                fromSolKey: sender,
+                                toSolKey: k,
+                                symbol: (() => {
+                                    if (mint == constants_1.renderMint) {
+                                        return 'RENDER';
+                                    }
+                                    if (mint == constants_1.usdcMint) {
+                                        return 'USDC';
+                                    }
+                                    throw new Error(`unknown mint ${mint}`);
+                                })(),
+                                channel: channel,
+                                solTx: tx.sig,
+                                executedAt: new Date(tx.blockTime * 1000),
+                                amountPayed: BigInt(amt),
+                            },
+                        },
+                    ]);
+                    console.log(`inserted ${JSON.stringify(inserted)}`);
+                    insertedIds.push(...inserted.map((t) => t.transferId).filter((i) => !!i));
+                    trx.commit();
+                }
+                catch (e) {
+                    trx.rollback();
+                    if (`${e}`.includes('duplicate key value violates unique constraint')) {
+                        console.log(`caught up indexing ${e}`);
+                        return { stop: true, insertedIds };
+                    }
+                    throw e;
+                }
+            }
+            console.log(`tx ${tx.sig} -> insertedIds ${insertedIds.length}`);
+            return { stop: false, insertedIds };
+        });
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const t of Object.keys(this._types)) {
+                if (t == 'emit') {
+                    const txs = yield this.findEmitTxs();
+                    yield this.indexTxs(txs, 'emit');
+                }
+                else if (t == 'buyBurnUSDCInflow') {
+                    const trs = yield this.solscanClient.getTransfers({
+                        mint: new web3_js_1.PublicKey(constants_1.usdcMint),
+                        flow: 'in',
+                        addr: new web3_js_1.PublicKey(constants_1.buyAndBurnEscrow),
+                    });
+                    for (const t of trs) {
+                        if (!this.isDryRun) {
+                            console.log(`buyBurnUSDCInflows: ${JSON.stringify(t)}`);
+                        }
+                        const { stop } = yield this.indexTransfers({ [constants_1.buyAndBurnEscrow]: { mint: constants_1.usdcMint, amt: t.amount } }, { blockTime: t.blockTime, sig: t.sig }, t.fromAddress.toString(), 'internal');
+                        if (stop) {
+                            break;
+                        }
+                    }
+                }
+                else if (t == 'manualMint') {
+                    console.log(`About to fetch manual mints - renderMint: ${constants_1.renderMint}, bridgeEscrow: ${constants_1.bridgeEscrow}, isDryRun: ${this.isDryRun}`);
+                    const trs = yield this.solscanClient.getBalanceChange({
+                        mint: new web3_js_1.PublicKey(constants_1.renderMint),
+                        addr: new web3_js_1.PublicKey('AYm4Knn6Sw1f52Eq42ujQ2ez5Xb7iBJeviprFCA7ADCy'),
+                        flow: 'in',
+                        tokenAccount: new web3_js_1.PublicKey(constants_1.bridgeEscrow),
+                    });
+                    console.log(`polyTrs result: ${trs.length} transactions`);
+                    for (const t of trs) {
+                        if (!this.isDryRun) {
+                            console.log(`manualMints: ${JSON.stringify(t)}`);
+                        }
+                        const { stop } = yield this.indexTransfers({ [constants_1.bridgeEscrow]: { mint: constants_1.renderMint, amt: t.amount } }, { blockTime: t.blockTime, sig: t.sig }, constants_1.renderMint, 'manual_mint');
+                        if (stop) {
+                            break;
+                        }
+                    }
+                    console.log(`About to fetch poly manual mints - renderMint: ${constants_1.renderMint}, polyBridgeEscrow: ${constants_1.polyBridgeEscrow}, isDryRun: ${this.isDryRun}`);
+                    // polygon bridge escrow
+                    const polyTrs = yield this.solscanClient.getBalanceChange({
+                        mint: new web3_js_1.PublicKey(constants_1.renderMint),
+                        addr: new web3_js_1.PublicKey('E5uyafHUFpNTsiPvGmUpr8BmM1L8t1gx3g6H4Y4vraU5'),
+                        flow: 'in',
+                        tokenAccount: new web3_js_1.PublicKey(constants_1.polyBridgeEscrow),
+                    });
+                    console.log(`polyTrs result: ${polyTrs.length} transactions`);
+                    for (const t of polyTrs) {
+                        if (!this.isDryRun) {
+                            console.log(`polyManualMints: ${JSON.stringify(t)}`);
+                        }
+                        const { stop } = yield this.indexTransfers({ [constants_1.polyBridgeEscrow]: { mint: constants_1.renderMint, amt: t.amount } }, { blockTime: t.blockTime, sig: t.sig }, constants_1.renderMint, 'manual_mint');
+                        if (stop) {
+                            break;
+                        }
+                    }
+                }
+                else if (t == 'vaultOutflows') {
+                    for (const addr of [constants_1.devsSquadsVault, constants_1.masterSquadsVault]) {
+                        const trs = yield this.solscanClient.getTransfers({
+                            mint: new web3_js_1.PublicKey(constants_1.renderMint),
+                            flow: 'out',
+                            addr: new web3_js_1.PublicKey(addr),
+                            pageSize: this.solscan.pageSize,
+                        });
+                        for (const t of trs) {
+                            if (!this.isDryRun) {
+                                console.log(`vaultOutflow: ${JSON.stringify(t)}`);
+                            }
+                            const { stop } = yield this.indexTransfers({
+                                [t.toAddress.toString()]: { mint: constants_1.renderMint, amt: t.amount },
+                            }, { blockTime: t.blockTime, sig: t.sig }, addr, 'internal');
+                            if (stop) {
+                                break;
+                            }
+                        }
+                    }
+                }
+                else if (t == "loan") {
+                    yield this.indexLoans();
+                }
+                else if (t == "renderComputeNetwork") {
+                    const trs = yield this.solscanClient.getTransfers({
+                        mint: new web3_js_1.PublicKey(constants_1.renderMint),
+                        flow: "in",
+                        addr: new web3_js_1.PublicKey(constants_1.renderComputeNetworkEscrow),
+                    });
+                    for (const t of trs) {
+                        if (!this.isDryRun) {
+                            console.log(`renderComputeNetwork: ${JSON.stringify(t)}`);
+                        }
+                        const { stop } = yield this.indexTransfers({ [constants_1.renderComputeNetworkEscrow]: { mint: constants_1.renderMint, amt: t.amount } }, { blockTime: t.blockTime, sig: t.sig }, t.fromAddress.toString(), "internal");
+                        if (stop) {
+                            break;
+                        }
+                    }
+                }
+                else if (t == "burnRENDERInflow") {
+                    const trs = yield this.solscanClient.getTransfers({
+                        mint: new web3_js_1.PublicKey(constants_1.renderMint),
+                        flow: "out",
+                        addr: new web3_js_1.PublicKey(constants_1.devsSquadsVault),
+                    });
+                    for (const t of trs) {
+                        if (((_a = t.toAddress) === null || _a === void 0 ? void 0 : _a.toString()) !== constants_1.buyAndBurnEscrow) {
+                            continue;
+                        }
+                        if (!this.isDryRun) {
+                            console.log(`burnRENDERInflow: ${JSON.stringify(t)}`);
+                        }
+                        const { stop } = yield this.indexTransfers({ [constants_1.buyAndBurnEscrow]: { mint: constants_1.renderMint, amt: t.amount } }, { blockTime: t.blockTime, sig: t.sig }, t.fromAddress.toString(), "internal");
+                        if (stop) {
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+exports.Backfiller = Backfiller;
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const args = process.argv.slice(2);
+        const getArgValue = (argName) => {
+            const argIndex = args.indexOf(`--${argName}`);
+            return argIndex !== -1 && argIndex + 1 < args.length ? args[argIndex + 1] : undefined;
+        };
+        const hasFlag = (flagName) => {
+            return args.includes(`--${flagName}`);
+        };
+        const solscanApiKey = getArgValue("solscanApiKey");
+        if (!solscanApiKey) {
+            console.error("Error: --solscanApiKey is required");
+            process.exit(1);
+        }
+        const heliusApiKey = getArgValue("heliusApiKey");
+        if (!heliusApiKey) {
+            console.error("Error: --heliusApiKey is required");
+            process.exit(1);
+        }
+        const isDryRun = hasFlag("dryRun");
+        let pg;
+        if (!isDryRun) {
+            const pgUrl = getArgValue("pgUrl");
+            if (!pgUrl) {
+                console.error("Error: --pgUrl is required (unless using --dryRun)");
+                process.exit(1);
+            }
+            pg = (0, v2Client_1.pgClient)({
+                connectionString: pgUrl,
+            });
+        }
+        const backfiller = new Backfiller(solscanApiKey, heliusApiKey, pg, isDryRun);
+        if (hasFlag("loans")) {
+            backfiller.loans();
+        }
+        if (hasFlag("vaultOutflows")) {
+            backfiller.vaultOutflows({});
+        }
+        if (hasFlag("emissions")) {
+            backfiller.emit();
+        }
+        if (hasFlag("buyBurnUSDCInflow")) {
+            backfiller.buyBurnUSDCInflow();
+        }
+        if (hasFlag("manualMints")) {
+            backfiller.manualMint();
+        }
+        if (hasFlag("renderComputeNetwork")) {
+            backfiller.renderComputeNetwork();
+        }
+        if (hasFlag("burnRENDERInflow")) {
+            backfiller.burnRENDERInflow();
+        }
+        if (hasFlag("loans") ||
+            hasFlag("vaultOutflows") ||
+            hasFlag("emissions") ||
+            hasFlag("buyBurnUSDCInflow") ||
+            hasFlag("manualMints") ||
+            hasFlag("renderComputeNetwork") ||
+            hasFlag("burnRENDERInflow")) {
+            yield backfiller.run();
+        }
+        else {
+            console.log("No operations specified. Available flags: --loans, --vaultOutflows, --emissions, --buyBurnUSDCInflow, --manualMints, --renderComputeNetwork, --burnRENDERInflow, --dryRun");
+        }
+    });
+}
+if (require.main === module) {
+    main().catch(console.error);
+}
+//# sourceMappingURL=backfiller.js.map