@render-foundation/utils 0.0.169 → 0.0.170

package/lib/esm/src/backfiller.js

@@ -1,810 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import { renderMint, buyAndBurnEscrow, passthruEscrow, v3SquadsVault, upgradeRewardsEscrow, upgradeRewardsCircuitBreaker, usdcMint, devsSquadsVault, masterSquadsVault, bridgeEscrow, polyBridgeEscrow, } from "./constants";
-import { pgClient } from "./client/pg/v2Client";
-import { emissionDistributorKey, emissionDistributorV1Key } from "@render-foundation/emission-distributor-sdk";
-import { Helius } from "helius-sdk";
-export const solscanProClient = (apiKey) => {
-    const headers = {
-        token: apiKey,
-    };
-    const baseUrl = "https://pro-api.solscan.io/v2.0";
-    return {
-        async getSignaturesForAddress(addr, options) {
-            const allSignatures = [];
-            let before = options?.before;
-            const limit = Math.min(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 = await fetch(endpoint, { headers });
-                if (!response.ok) {
-                    throw new Error(`Failed to fetch signatures: ${response.statusText}`);
-                }
-                const data = await 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?.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?.limit);
-        },
-        async getParsedTransaction(signature) {
-            const endpoint = `${baseUrl}/transaction/details?tx=${signature}`;
-            const response = await fetch(endpoint, { headers });
-            if (!response.ok) {
-                throw new Error(`Failed to fetch transaction: ${response.statusText}`);
-            }
-            const data = await 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 || [],
-            };
-        },
-        async getBalanceChange(f) {
-            try {
-                const allTransfers = [];
-                let page = 1;
-                const pageSize = Math.min(f.options?.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 = await fetch(endpoint, { headers });
-                    if (!response.ok) {
-                        console.error(`Failed to fetch balance changes: ${response.statusText}`);
-                        break;
-                    }
-                    const body = await response.json();
-                    const transfers = [];
-                    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 [];
-            }
-        },
-        async getTransfers(f) {
-            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 = await fetch(endpoint, { headers });
-                    if (!response.ok) {
-                        throw new Error(`Failed to fetch transfers: ${response.statusText}`);
-                    }
-                    const body = await 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 PublicKey(item.from_address) : undefined,
-                            toAddress: item.to_address ? new 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}`);
-            }
-        },
-    };
-};
-export const heliusClient = (apiKey) => {
-    const helius = new Helius(apiKey, 'mainnet-beta');
-    return {
-        async getSignaturesForAddress(addr, options) {
-            return helius.connection.getSignaturesForAddress(addr, {
-                before: options?.before,
-                limit: options?.limit || 1000,
-            });
-        },
-        async getParsedTransaction(signature) {
-            return helius.connection.getTransaction(signature, {
-                maxSupportedTransactionVersion: 0,
-            });
-        },
-        async getBalanceChange(f) {
-            try {
-                // Get transactions for the address
-                const response = await helius.connection.getSignaturesForAddress(f.addr, {
-                    limit: 100,
-                });
-                const transfers = [];
-                // Process each signature to get transaction details
-                for (const sig of response) {
-                    try {
-                        const tx = await helius.connection.getTransaction(sig.signature, {
-                            maxSupportedTransactionVersion: 0,
-                        });
-                        if (!tx || tx.meta?.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(preBalance?.uiTokenAmount?.amount || 0);
-                            const postAmount = Number(postBalance.uiTokenAmount?.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: postBalance.uiTokenAmount?.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 [];
-            }
-        },
-        async getTransfers(f) {
-            try {
-                // Use enhanced transactions API for better token transfer data
-                const response = await helius.connection.getSignaturesForAddress(f.addr, {
-                    limit: f.pageSize || 100,
-                });
-                const transfers = [];
-                for (const sig of response) {
-                    try {
-                        const tx = await helius.connection.getTransaction(sig.signature, {
-                            maxSupportedTransactionVersion: 0,
-                        });
-                        if (!tx || tx.meta?.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(preBalance?.uiTokenAmount?.amount || 0);
-                            const postAmount = Number(postBalance.uiTokenAmount?.amount || 0);
-                            const change = postAmount - preAmount;
-                            if (change !== 0) {
-                                balanceChanges.set(postBalance.accountIndex, {
-                                    mint: postBalance.mint,
-                                    owner: postBalance.owner,
-                                    change,
-                                    decimals: postBalance.uiTokenAmount?.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 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 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}`);
-            }
-        },
-    };
-};
-export class Backfiller {
-    _types = {};
-    _txs = [];
-    solscanClient;
-    heliusClient;
-    pg;
-    isDryRun = false;
-    solscan = { pageSize: 100 };
-    constructor(solscanApiKey, heliusApiKey, pg, isDryRun = false) {
-        this.solscan.apiKey = solscanApiKey;
-        this.solscanClient = solscanProClient(solscanApiKey);
-        this.heliusClient = 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;
-    }
-    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();
-    }
-    async indexLoans() {
-        const trs = [
-            {
-                transfer: {
-                    toSolKey: "2P2gisXpbsYEUsTDQKdcDKSg1UZvx7qxfLTkvJGZdeJC",
-                    fromSolKey: 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: 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: 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: 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: 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: 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 {
-                await this.pg.createPayments(this.pg.db, [t]);
-            }
-            catch (e) {
-                console.log(`except ${e}`);
-            }
-        }
-    }
-    async findEmitTxs() {
-        const fetchSigs = async (ads) => {
-            const uniqSigs = {};
-            const sigsAgg = [];
-            for (const ad of ads) {
-                const sigs = [];
-                while (true) {
-                    const sigsBatch = await 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 = await fetchSigs([
-            emissionDistributorKey(new PublicKey(renderMint))[0],
-            emissionDistributorV1Key(new PublicKey(renderMint))[0],
-        ]);
-        if (!this.isDryRun) {
-            console.log(`sigs ${sigs.length}`);
-        }
-        let proced = 0;
-        const out = [];
-        for (const s of sigs) {
-            const p = await this.heliusClient.getParsedTransaction(s.signature);
-            if (p?.meta?.err || p?.err) {
-                continue;
-            }
-            const logMessages = p?.meta?.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;
-    }
-    async indexTxs(txs, channel, reindexTx = false, deleteFailed = false, mints = [renderMint, usdcMint], senders = [passthruEscrow, v3SquadsVault, upgradeRewardsEscrow, upgradeRewardsCircuitBreaker, renderMint], assertSender = "") {
-        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 = await 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 = await 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 = tx.meta?.tokenBalances || [];
-            const preTokenBalances = tx.meta?.preTokenBalances || [];
-            const postTokenBalances = tx.meta?.postTokenBalances || [];
-            for (const balance of postTokenBalances) {
-                const mint = mints.find((m) => balance.mint === m);
-                if (mint) {
-                    const amt = Number(balance.uiTokenAmount?.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(balance.uiTokenAmount?.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 = 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 = await 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(",")}`);
-    }
-    async indexTransfers(onchain, tx, sender, channel, reindexTx = false) {
-        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 == renderMint) {
-                        return "RENDER";
-                    }
-                    if (mint == 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 = await 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 = await this.pg.startTransaction();
-            try {
-                const { inserted } = await this.pg.createPayments(trx, [
-                    {
-                        transfer: {
-                            fromSolKey: sender,
-                            toSolKey: k,
-                            symbol: (() => {
-                                if (mint == renderMint) {
-                                    return "RENDER";
-                                }
-                                if (mint == 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 };
-    }
-    async run() {
-        for (const t of Object.keys(this._types)) {
-            if (t == "emit") {
-                const txs = await this.findEmitTxs();
-                await this.indexTxs(txs, "emit");
-            }
-            else if (t == "buyBurnUSDCInflow") {
-                const trs = await this.solscanClient.getTransfers({
-                    mint: new PublicKey(usdcMint),
-                    flow: "in",
-                    addr: new PublicKey(buyAndBurnEscrow),
-                });
-                for (const t of trs) {
-                    if (!this.isDryRun) {
-                        console.log(`buyBurnUSDCInflows: ${JSON.stringify(t)}`);
-                    }
-                    const { stop } = await this.indexTransfers({ [buyAndBurnEscrow]: { mint: usdcMint, amt: t.amount } }, { blockTime: t.blockTime, sig: t.sig }, t.fromAddress.toString(), "internal");
-                    if (stop) {
-                        break;
-                    }
-                }
-            }
-            else if (t == "manualMint") {
-                const trs = await this.solscanClient.getBalanceChange({
-                    mint: new PublicKey(renderMint),
-                    addr: new PublicKey("AYm4Knn6Sw1f52Eq42ujQ2ez5Xb7iBJeviprFCA7ADCy"),
-                    flow: "in",
-                    tokenAccount: new PublicKey(bridgeEscrow),
-                });
-                for (const t of trs) {
-                    if (!this.isDryRun) {
-                        console.log(`manualMints: ${JSON.stringify(t)}`);
-                    }
-                    const { stop } = await this.indexTransfers({ [bridgeEscrow]: { mint: renderMint, amt: t.amount } }, { blockTime: t.blockTime, sig: t.sig }, renderMint, "manual_mint");
-                    if (stop) {
-                        break;
-                    }
-                }
-                const polyTrs = await this.solscanClient.getBalanceChange({
-                    mint: new PublicKey(renderMint),
-                    addr: new PublicKey("AYm4Knn6Sw1f52Eq42ujQ2ez5Xb7iBJeviprFCA7ADCy"),
-                    flow: "in",
-                    tokenAccount: new PublicKey(polyBridgeEscrow),
-                });
-                for (const t of polyTrs) {
-                    if (!this.isDryRun) {
-                        console.log(`polyManualMints: ${JSON.stringify(t)}`);
-                    }
-                    const { stop } = await this.indexTransfers({ [polyBridgeEscrow]: { mint: renderMint, amt: t.amount } }, { blockTime: t.blockTime, sig: t.sig }, renderMint, "manual_mint");
-                    if (stop) {
-                        break;
-                    }
-                }
-            }
-            else if (t == "vaultOutflows") {
-                for (const addr of [devsSquadsVault, masterSquadsVault]) {
-                    const trs = await this.solscanClient.getTransfers({
-                        mint: new PublicKey(renderMint),
-                        flow: "out",
-                        addr: new PublicKey(addr),
-                        pageSize: this.solscan.pageSize,
-                    });
-                    for (const t of trs) {
-                        if (!this.isDryRun) {
-                            console.log(`vaultOutflow: ${JSON.stringify(t)}`);
-                        }
-                        const { stop } = await this.indexTransfers({
-                            [t.toAddress.toString()]: { mint: renderMint, amt: t.amount },
-                        }, { blockTime: t.blockTime, sig: t.sig }, addr, "internal");
-                        if (stop) {
-                            break;
-                        }
-                    }
-                }
-            }
-            else if (t == "loan") {
-                await this.indexLoans();
-            }
-        }
-    }
-}
-async function main() {
-    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 = 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("loans") ||
-        hasFlag("vaultOutflows") ||
-        hasFlag("emissions") ||
-        hasFlag("buyBurnUSDCInflow") ||
-        hasFlag("manualMints")) {
-        await backfiller.run();
-    }
-    else {
-        console.log("No operations specified. Available flags: --loans, --vaultOutflows, --emissions, --buyBurnUSDCInflow, --manualMints, --dryRun");
-    }
-}
-if (require.main === module) {
-    main().catch(console.error);
-}
-//# sourceMappingURL=backfiller.js.map