@render-foundation/utils 0.0.170 → 0.0.171

package/lib/esm/src/backfiller.js

@@ -0,0 +1,850 @@
+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 (f.tokenAccount.toString() === polyBridgeEscrow) {
+                        console.log('Poly solscan response: ', JSON.stringify(response));
+                    }
+                    if (!response.ok) {
+                        console.error(`Failed to fetch balance changes: ${response.statusText}`);
+                        break;
+                    }
+                    const body = await response.json();
+                    const transfers = [];
+                    if (f.tokenAccount.toString() === 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 [];
+            }
+        },
+        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') {
+                console.log(`About to fetch manual mints - renderMint: ${renderMint}, bridgeEscrow: ${bridgeEscrow}, isDryRun: ${this.isDryRun}`);
+                const trs = await this.solscanClient.getBalanceChange({
+                    mint: new PublicKey(renderMint),
+                    addr: new PublicKey('AYm4Knn6Sw1f52Eq42ujQ2ez5Xb7iBJeviprFCA7ADCy'),
+                    flow: 'in',
+                    tokenAccount: new PublicKey(bridgeEscrow),
+                });
+                console.log(`polyTrs result: ${trs.length} transactions`);
+                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;
+                    }
+                }
+                console.log(`About to fetch poly manual mints - renderMint: ${renderMint}, polyBridgeEscrow: ${polyBridgeEscrow}, isDryRun: ${this.isDryRun}`);
+                // polygon bridge escrow
+                const polyTrs = await this.solscanClient.getBalanceChange({
+                    mint: new PublicKey(renderMint),
+                    addr: new PublicKey('E5uyafHUFpNTsiPvGmUpr8BmM1L8t1gx3g6H4Y4vraU5'),
+                    flow: 'in',
+                    tokenAccount: new PublicKey(polyBridgeEscrow),
+                });
+                console.log(`polyTrs result: ${polyTrs.length} transactions`);
+                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