@render-foundation/utils 0.0.165 → 0.0.166

package/lib/esm/src/backfiller.js

@@ -1,194 +1,445 @@
-import { PublicKey } from '@solana/web3.js';
-import { renderMint, buyAndBurnEscrow, passthruEscrow, v3SquadsVault, upgradeRewardsEscrow, upgradeRewardsCircuitBreaker, usdcMint, devsSquadsVault, masterSquadsVault, bridgeEscrow, } from './constants';
-import { emissionDistributorKey, emissionDistributorV1Key, } from '@render-foundation/emission-distributor-sdk';
-export const solscan = (cookie) => {
+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 = {
-        accept: 'application/json, text/plain, */*',
-        'accept-language': 'en-US,en;q=0.9',
-        'accept-encoding': 'gzip, deflate, br',
-        connection: 'keep-alive',
-        cookie: cookie,
-        origin: 'https://solscan.io',
-        referer: 'https://solscan.io/',
-        'sec-ch-ua': '"Not A(Brand";v="99", "Google Chrome";v="120", "Chromium";v="120"',
-        'sec-ch-ua-mobile': '?0',
-        'sec-ch-ua-platform': '"macOS"',
-        'sec-fetch-dest': 'empty',
-        'sec-fetch-mode': 'cors',
-        'sec-fetch-site': 'same-site',
-        'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-        'cache-control': 'no-cache',
-        pragma: 'no-cache',
+        token: apiKey,
     };
-    const url = 'https://api-v2.solscan.io';
+    const baseUrl = "https://pro-api.solscan.io/v2.0";
     return {
-        async getBalanceChange(f) {
-            const r = {
-                page: '1',
-                page_size: '100',
+        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 || [],
             };
-            if (f.mint) {
-                r['token'] = f.mint.toString();
-            }
-            if (f.flow) {
-                r['flow'] = f.flow;
-            }
-            if (f.addr) {
-                r['address'] = f.addr.toString();
-            }
-            if (f.tokenAccount) {
-                r['token_account'] = f.tokenAccount.toString();
-            }
-            const params = new URLSearchParams(r);
-            const ep = `${url}/v2/account/balance_change?${params}`;
-            console.log(`fetching ${ep}`);
-            const res = await fetch(ep, { headers });
-            const body = await res.json();
-            return body.data.filter((t) => t.change_type == 'inc').map(({ trans_id, block_time, amount, token_decimals }) => ({
-                amount: amount,
-                tokenDecimals: token_decimals,
-                sig: trans_id,
-                blockTime: block_time,
-            })).filter((t) => t.amount != 0);
+        },
+        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) {
-            const r = {
-                page: '1',
-                page_size: f.pageSize?.toString() ?? '100',
-            };
-            if (f.mint) {
-                r['token'] = f.mint.toString();
-            }
-            if (f.flow) {
-                r['flow'] = f.flow;
-            }
-            if (f.addr) {
-                r['address'] = f.addr.toString();
-            }
-            const params = new URLSearchParams(r);
-            const ep = `${url}/v2/account/transfer?${params}`;
-            const res = await fetch(ep, { headers });
-            if (res.status != 200) {
-                throw new Error(`failed ${await res.text()}`);
-            }
-            const body = await res.json();
-            return body.data.map(({ trans_id, block_time, amount, token_decimals, to_address, from_address, }) => ({
-                amount: amount,
-                tokenDecimals: token_decimals,
-                fromAddress: new PublicKey(from_address),
-                toAddress: new PublicKey(to_address),
-                sig: trans_id,
-                blockTime: block_time,
-            }));
+            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 = {};
-    conn;
     _txs = [];
+    solscanClient;
+    heliusClient;
     pg;
+    isDryRun = false;
     solscan = { pageSize: 100 };
-    constructor(conn, pg) {
-        this.conn = conn;
+    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'] = {};
+        this._types["emit"] = {};
         return this;
     }
     loans() {
-        this._types['loan'] = {};
+        this._types["loan"] = {};
         return this;
     }
-    buyBurnUSDCInflow(solscanCookie) {
-        this._types['buyBurnUSDCInflow'] = {};
-        this.solscan.cookie = solscanCookie;
+    buyBurnUSDCInflow() {
+        this._types["buyBurnUSDCInflow"] = {};
         return this;
     }
-    manualMint(solscanCookie) {
-        this._types['manualMint'] = {};
-        this.solscan.cookie = solscanCookie;
+    manualMint() {
+        this._types["manualMint"] = {};
         return this;
     }
     vaultOutflows(p) {
-        this._types['vaultOutflows'] = {};
-        this.solscan.cookie = p.solscanCookie;
-        this.solscan.pageSize = p.pageSize;
+        this._types["vaultOutflows"] = {};
+        this.solscan.pageSize = p.pageSize || 100;
         return this;
     }
     txs(...sigs) {
         this._txs.push(...sigs);
     }
-    indexLoans = async () => {
+    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',
+                    toSolKey: "2P2gisXpbsYEUsTDQKdcDKSg1UZvx7qxfLTkvJGZdeJC",
                     fromSolKey: v3SquadsVault,
-                    solTx: '3oC8BybX5YrkfPyvV8rAE1tnJr6egtZFHLghqHuLi3eaT4aWm87qZPJFrjFRn6nwVemd2ponsew85tBs6VVQzTJv',
-                    executedAt: new Date('December 22, 2023 04:13:58 UTC'),
-                    symbol: 'RENDER',
-                    channel: 'loan',
+                    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',
+                    toSolKey: "2P2gisXpbsYEUsTDQKdcDKSg1UZvx7qxfLTkvJGZdeJC",
                     fromSolKey: v3SquadsVault,
-                    channel: 'loan',
-                    solTx: '2f5sEBHcP8wpF79voUEUiP8pryDt7FvqrTXQrEpXzAxbzyFYPkavZGtJc5N8CXhfbJav8hQTr9YcENKseiouaWzc',
-                    executedAt: new Date('December 22, 2023 02:39:53 UTC'),
-                    symbol: 'RENDER',
+                    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',
+                    toSolKey: "5DGbogKUo8haEYC9Tt4FTHE5ue55bjLC4DpSgE1g6yT1",
                     fromSolKey: v3SquadsVault,
-                    channel: 'loan',
-                    solTx: '42n55BZcKVBCSZQoaneBQLn57v7zZGZorGe3uBLheGu4BQtpaTChdT1z3vHwgU4MHghJw3wJ72rFLkib761ewJCj',
-                    executedAt: new Date('January 12, 2024 00:17:02 UTC'),
-                    symbol: 'RENDER',
+                    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',
+                    toSolKey: "5DGbogKUo8haEYC9Tt4FTHE5ue55bjLC4DpSgE1g6yT1",
                     fromSolKey: v3SquadsVault,
-                    channel: 'loan',
-                    solTx: 'THJLvA1UTqH22hNP7Ecnfn4iY736VJAZ8scgSUjrDDaGpSQJmGYKJYXGtDu6TB96fKo6mJBtUBZvLb4ors17JUR',
-                    executedAt: new Date('January 17, 2024 22:09:58 UTC'),
-                    symbol: 'RENDER',
+                    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',
+                    toSolKey: "5DGbogKUo8haEYC9Tt4FTHE5ue55bjLC4DpSgE1g6yT1",
                     fromSolKey: devsSquadsVault,
-                    channel: 'loan',
-                    solTx: '5BcxrMExq34jtMB5c3bH3A8TN4pCp9sxjC5HMcS7Mh8pig3r2eQhvRnJeE1RBTyQ4JDXyANWmDU9SKdYFyT2wDoq',
-                    executedAt: new Date('February 28, 2024 22:43:21 UTC'),
-                    symbol: 'RENDER',
+                    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',
+                    toSolKey: "5DGbogKUo8haEYC9Tt4FTHE5ue55bjLC4DpSgE1g6yT1",
                     fromSolKey: devsSquadsVault,
-                    channel: 'loan',
-                    solTx: '5E4E35CT4e3fhbMAwcKdfAvJL4uUHR8hHE8REmKnDCEsFZ6mxaE1YyeYK8Sbg5AJqBJxsZkcYSohY8T14YLC5pXs',
-                    executedAt: new Date('February 29, 2024 01:17:51 UTC'),
-                    symbol: 'RENDER',
+                    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]);
@@ -197,7 +448,7 @@ export class Backfiller {
                 console.log(`except ${e}`);
             }
         }
-    };
+    }
     async findEmitTxs() {
         const fetchSigs = async (ads) => {
             const uniqSigs = {};
@@ -205,9 +456,10 @@ export class Backfiller {
             for (const ad of ads) {
                 const sigs = [];
                 while (true) {
-                    const sigsBatch = await this.conn.getSignaturesForAddress(ad, {
+                    const sigsBatch = await this.heliusClient.getSignaturesForAddress(ad, {
                         before: sigs.length > 0 ? sigs[sigs.length - 1].signature : undefined,
-                    }, 'confirmed');
+                        limit: 1000,
+                    });
                     sigs.push(...sigsBatch.filter((s) => !uniqSigs[s.signature]));
                     for (const s of sigsBatch) {
                         uniqSigs[s.signature] = true;
@@ -216,7 +468,9 @@ export class Backfiller {
                         break;
                     }
                 }
-                console.log(`fetched ${sigs.length} sigs for ${ad}`);
+                if (!this.isDryRun) {
+                    console.log(`fetched ${sigs.length} sigs for ${ad}`);
+                }
                 sigsAgg.push(...sigs);
             }
             sigsAgg.sort((a, b) => b.blockTime - a.blockTime);
@@ -226,98 +480,130 @@ export class Backfiller {
             emissionDistributorKey(new PublicKey(renderMint))[0],
             emissionDistributorV1Key(new PublicKey(renderMint))[0],
         ]);
-        console.log(`sigs ${sigs.length}`);
+        if (!this.isDryRun) {
+            console.log(`sigs ${sigs.length}`);
+        }
         let proced = 0;
         const out = [];
         for (const s of sigs) {
-            const p = await this.conn.getParsedTransaction(s.signature, {
-                maxSupportedTransactionVersion: 0,
-                commitment: 'confirmed',
-            });
-            if (p.meta.err) {
+            const p = await this.heliusClient.getParsedTransaction(s.signature);
+            if (p?.meta?.err || p?.err) {
                 continue;
             }
-            for (const l of p.meta.logMessages) {
-                if (l.includes('DistributeEmissionsV0') ||
-                    l.includes('DistributeEmissionsV1')) {
+            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 % 50 == 0) {
+            if (proced % 10 == 0 && !this.isDryRun) {
                 console.log(`proced ${proced}`);
             }
         }
         console.log(`emit txs: ${out.length}`);
-        //console.log(`last ${sigs.slice(sigs.length - 5).map((s) => s.signature)}`)
         return out;
     }
-    async run() {
-        for (const t of Object.keys(this._types)) {
-            if (t == 'emit') {
-                const txs = await this.findEmitTxs();
-                await this.indexTxs(txs, 'emit');
+    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;
             }
-            else if (t == 'buyBurnUSDCInflow') {
-                const trs = await solscan(this.solscan.cookie).getTransfers({
-                    mint: new PublicKey(usdcMint),
-                    flow: 'in',
-                    addr: new PublicKey(buyAndBurnEscrow),
-                });
-                for (const t of trs) {
-                    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;
-                    }
+            console.log(`solTx ${solTx}`);
+            const tx = await this.heliusClient.getParsedTransaction(solTx);
+            if (!tx || (tx.status !== "Success" && tx.err)) {
+                if (this.isDryRun) {
+                    console.log(`[DRY RUN] Would delete failed transaction ${solTx} from database`);
+                    continue;
                 }
+                console.log(`shouldnt exist ${solTx} in db. deleting`);
+                const res = await this.pg.db.trx.deleteFrom("sol_tx").where("sig", "=", solTx).executeTakeFirstOrThrow();
+                console.log(`deleted ${res.numDeletedRows} tx`);
+                continue;
             }
-            else if (t == 'manualMint') {
-                const trs = await solscan(this.solscan.cookie).getBalanceChange({
-                    mint: new PublicKey(renderMint),
-                    addr: new PublicKey('AYm4Knn6Sw1f52Eq42ujQ2ez5Xb7iBJeviprFCA7ADCy'),
-                    flow: 'in',
-                    tokenAccount: new PublicKey(bridgeEscrow),
-                });
-                for (const t of trs) {
-                    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 onchain = {};
+            const tokenBalances = tx.tokenBalances || [];
+            const preTokenBalances = tx.preTokenBalances || [];
+            const postTokenBalances = tx.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 };
                 }
             }
-            else if (t == 'vaultOutflows') {
-                for (const addr of [devsSquadsVault, masterSquadsVault]) {
-                    const trs = await solscan(this.solscan.cookie).getTransfers({
-                        mint: new PublicKey(renderMint),
-                        flow: 'out',
-                        addr: new PublicKey(addr),
-                        pageSize: this.solscan.pageSize,
-                    });
-                    inner: for (const t of trs) {
-                        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 inner;
+            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;
                         }
                     }
                 }
             }
-            else if (t == 'loan') {
-                await this.indexLoans();
+            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 { stop } = await this.indexTransfers(onchain, { blockTime: tx.blockTime || tx.blocktime || 0, sig: solTx }, sender, channel);
+            if (stop) {
+                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(`${tx.sig} | ${timestamp} | ${channel} | ${sender} -> ${k} | ${amount} ${symbol}`);
+            }
+            return { stop: false };
+        }
         if (reindexTx) {
-            let res = await this.pg.db.trx
-                .deleteFrom('sol_tx')
-                .where('sig', '=', tx.sig)
-                .executeTakeFirstOrThrow();
+            const res = await this.pg.db.trx.deleteFrom("sol_tx").where("sig", "=", tx.sig).executeTakeFirstOrThrow();
             console.log(`deleted ${res.numDeletedRows} tx`);
         }
         console.log(`diffs: ${ents.map(([k, v]) => `k ${k} v -> ${JSON.stringify(v)}`)}`);
@@ -335,10 +621,10 @@ export class Backfiller {
                             toSolKey: k,
                             symbol: (() => {
                                 if (mint == renderMint) {
-                                    return 'RENDER';
+                                    return "RENDER";
                                 }
                                 if (mint == usdcMint) {
-                                    return 'USDC';
+                                    return "USDC";
                                 }
                                 throw new Error(`unknown mint ${mint}`);
                             })(),
@@ -355,7 +641,7 @@ export class Backfiller {
             }
             catch (e) {
                 trx.rollback();
-                if (`${e}`.includes('duplicate key value violates unique constraint')) {
+                if (`${e}`.includes("duplicate key value violates unique constraint")) {
                     console.log(`caught up indexing ${e}`);
                     return { stop: true };
                 }
@@ -365,81 +651,146 @@ export class Backfiller {
         console.log(`tx ${tx.sig} -> insertedIds ${insertedIds.length}`);
         return { stop: false };
     }
-    async indexTxs(txs, channel, reindexTx = false, deleteFailed = false, mints = [renderMint, usdcMint], 
-    // squadsV4
-    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;
+    async run() {
+        for (const t of Object.keys(this._types)) {
+            if (t == "emit") {
+                const txs = await this.findEmitTxs();
+                await this.indexTxs(txs, "emit");
             }
-            console.log(`solTx ${solTx}`);
-            const tx = await this.conn.getParsedTransaction(solTx, {
-                maxSupportedTransactionVersion: 0,
-                commitment: 'confirmed',
-            });
-            if (!tx || tx.meta.err) {
-                console.log(`shouldnt exist ${solTx} in db. deleting`);
-                let res = await this.pg.db.trx
-                    .deleteFrom('sol_tx')
-                    .where('sig', '=', solTx)
-                    .executeTakeFirstOrThrow();
-                console.log(`deleted ${res.numDeletedRows} tx`);
-                continue;
+            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;
+                    }
+                }
             }
-            const onchain = {};
-            for (const b of tx.meta.postTokenBalances) {
-                const mint = mints.find((m) => b.mint == m);
-                const amt = Number(b.uiTokenAmount.amount ?? 0);
-                if (mint) {
-                    onchain[b.owner] = { mint, amt };
+            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;
+                    }
                 }
             }
-            let sender;
-            for (const b of tx.meta.preTokenBalances) {
-                const mint = mints.find((m) => b.mint == m);
-                const amt = Number(b.uiTokenAmount.amount ?? 0);
-                if (mint) {
-                    onchain[b.owner] = { mint, amt: onchain[b.owner].amt - amt };
-                    if (onchain[b.owner].amt < 0) {
-                        sender = senders.find((s) => s == b.owner.toString());
-                        if (!sender) {
-                            throw new Error(`sender ${b.owner} not in expected senders ${senders}`);
+            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)}`);
                         }
-                        if (assertSender != '' && sender != assertSender) {
-                            throw new Error(`assert sender ${b.owner} != ${assertSender}`);
+                        const { stop } = await this.indexTransfers({
+                            [t.toAddress.toString()]: { mint: renderMint, amt: t.amount },
+                        }, { blockTime: t.blockTime, sig: t.sig }, addr, "internal");
+                        if (stop) {
+                            break;
                         }
                     }
                 }
             }
-            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 { stop } = await this.indexTransfers(onchain, { blockTime: tx.blockTime, sig: solTx }, sender, channel);
-            if (stop) {
-                break;
-            }
-            proced += 1;
-            if (proced % 10 == 0) {
-                console.log(`proced ${proced}`);
+            else if (t == "loan") {
+                await this.indexLoans();
             }
         }
-        console.log(`done. inserted ${insertedIds.length} transfers: ${insertedIds.join(',')}`);
     }
 }
+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