@helium/helium-admin-cli 0.11.6 → 0.11.7

package/lib/cjs/claim-and-close-subscriber-key-to-assets.js

@@ -0,0 +1,664 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const client = __importStar(require("@helium/distributor-oracle"));
+const helium_entity_manager_sdk_1 = require("@helium/helium-entity-manager-sdk");
+const helium_sub_daos_sdk_1 = require("@helium/helium-sub-daos-sdk");
+const lazy_distributor_sdk_1 = require("@helium/lazy-distributor-sdk");
+const rewards_oracle_sdk_1 = require("@helium/rewards-oracle-sdk");
+const mobile_entity_manager_sdk_1 = require("@helium/mobile-entity-manager-sdk");
+const spl_utils_1 = require("@helium/spl-utils");
+const web3_js_1 = require("@solana/web3.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const bs58_1 = __importDefault(require("bs58"));
+const os_1 = __importDefault(require("os"));
+const p_limit_1 = __importDefault(require("p-limit"));
+const yargs_1 = __importDefault(require("yargs/yargs"));
+const utils_1 = require("./utils");
+// Hardcoded key_to_asset addresses from initial migration that need special handling
+// These can be closed even if they have iot_info or mobile_info accounts
+const HARDCODED_KEY_TO_ASSETS = [
+    new web3_js_1.PublicKey("AcKpRTmy6YKpQaWfLDBUaduQU1kHhNVLrPkW3TmEEqsc"),
+    new web3_js_1.PublicKey("3stUgrUq4j5BbamGdy7X2Y3dee24EeY5u1F7RHrrmaoP"),
+    new web3_js_1.PublicKey("4v7nfEN2Wj342Zm6V1Jwk9i5YCUHu6zBAJFENk6Gxzvr"),
+    new web3_js_1.PublicKey("2RtR6aVt6QgCSdV8LEH6ogWtDXGJpL73aB72DevJKgFC"),
+];
+function run(args = process.argv) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const yarg = (0, yargs_1.default)(args).options({
+            wallet: {
+                alias: "k",
+                describe: "Anchor wallet keypair",
+                default: `${os_1.default.homedir()}/.config/solana/id.json`,
+            },
+            url: {
+                alias: "u",
+                default: "http://127.0.0.1:8899",
+                describe: "The solana url",
+            },
+            authority: {
+                type: "string",
+                describe: "Path to the authority keypair. Defaults to wallet.",
+            },
+            commit: {
+                type: "boolean",
+                describe: "Actually claim and close accounts. Otherwise dry-run",
+                default: false,
+            },
+        });
+        const argv = yield yarg.argv;
+        process.env.ANCHOR_WALLET = argv.wallet;
+        process.env.ANCHOR_PROVIDER_URL = argv.url;
+        anchor.setProvider(anchor.AnchorProvider.local(argv.url));
+        const provider = anchor.getProvider();
+        const lazyProgram = yield (0, lazy_distributor_sdk_1.init)(provider);
+        const hemProgram = yield (0, helium_entity_manager_sdk_1.init)(provider);
+        const rewardsOracleProgram = yield (0, rewards_oracle_sdk_1.init)(provider);
+        const memProgram = yield (0, mobile_entity_manager_sdk_1.init)(provider);
+        const authority = argv.authority
+            ? (0, utils_1.loadKeypair)(argv.authority)
+            : (0, utils_1.loadKeypair)(argv.wallet);
+        const dao = (0, helium_sub_daos_sdk_1.daoKey)(spl_utils_1.HNT_MINT)[0];
+        const mobileSubDao = (0, helium_sub_daos_sdk_1.subDaoKey)(spl_utils_1.MOBILE_MINT)[0];
+        const iotSubDao = (0, helium_sub_daos_sdk_1.subDaoKey)(spl_utils_1.IOT_MINT)[0];
+        const mobileConfig = (0, helium_entity_manager_sdk_1.rewardableEntityConfigKey)(mobileSubDao, "MOBILE")[0];
+        const iotConfig = (0, helium_entity_manager_sdk_1.rewardableEntityConfigKey)(iotSubDao, "IOT")[0];
+        const lazyDistributor = (0, lazy_distributor_sdk_1.lazyDistributorKey)(spl_utils_1.MOBILE_MINT)[0];
+        // ========== STEP 1: Find all subscriber assets AND hardcoded key_to_assets ==========
+        console.log("=== STEP 1: FINDING KEY_TO_ASSET ACCOUNTS ===\n");
+        // Build list of key_to_asset info
+        const keyToAssetInfos = [];
+        // Process hardcoded key_to_assets FIRST
+        // Note: We fetch these to get assetId and asset data (for entityKey)
+        console.log(`Checking ${HARDCODED_KEY_TO_ASSETS.length} hardcoded accounts...`);
+        const hardcodedAccounts = yield Promise.all(HARDCODED_KEY_TO_ASSETS.map((keyToAssetAddr) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const keyToAssetAcc = yield hemProgram.account.keyToAssetV0.fetch(keyToAssetAddr);
+                return {
+                    keyToAsset: keyToAssetAddr,
+                    assetId: keyToAssetAcc.asset,
+                    entityKey: Buffer.from(keyToAssetAcc.entityKey),
+                    isHardcoded: true,
+                };
+            }
+            catch (err) {
+                return null; // Already closed
+            }
+        })));
+        keyToAssetInfos.push(...hardcodedAccounts.filter((a) => a !== null));
+        if (keyToAssetInfos.length > 0) {
+            console.log(`  Found ${keyToAssetInfos.length} hardcoded key_to_assets\n`);
+        }
+        else {
+            console.log(`  All hardcoded accounts already closed\n`);
+        }
+        // Find all subscriber assets using DAS
+        // Strategy: Fetch all MakerV0 accounts, identify subscriber collections, search by those
+        console.log("Finding all subscriber assets via DAS...");
+        const allSubscriberAssets = new Map(); // Dedupe by asset ID
+        try {
+            // Fetch all CarrierV0 accounts to get subscriber collections
+            console.log("Fetching CarrierV0 accounts...");
+            const carriers = yield memProgram.account.carrierV0.all();
+            const subscriberCollections = new Set();
+            for (const carrier of carriers) {
+                subscriberCollections.add(carrier.account.collection.toBase58());
+            }
+            console.log(`  Found ${subscriberCollections.size} subscriber collection(s) from ${carriers.length} carriers`);
+            if (subscriberCollections.size === 0) {
+                console.log("  No subscriber collections found");
+            }
+            // Search each subscriber collection using cursor-based pagination
+            console.log("Searching DAS for subscriber assets...");
+            // Retry wrapper for DAS calls with exponential backoff
+            function getAssetsWithRetry(endpoint, params, maxRetries = 5) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    for (let attempt = 0; attempt < maxRetries; attempt++) {
+                        try {
+                            return yield (0, spl_utils_1.getAssetsByGroup)(endpoint, params);
+                        }
+                        catch (err) {
+                            if (attempt === maxRetries - 1) {
+                                throw err;
+                            }
+                            // Exponential backoff: 2s, 4s, 8s, 16s, 30s
+                            const delay = Math.min(2000 * Math.pow(2, attempt), 30000);
+                            const errorMsg = err.message || err.toString();
+                            console.log(`    Error: ${errorMsg.substring(0, 80)}... retrying in ${delay / 1000}s (attempt ${attempt + 1}/${maxRetries})`);
+                            yield new Promise((resolve) => setTimeout(resolve, delay));
+                        }
+                    }
+                    throw new Error("Max retries exceeded");
+                });
+            }
+            for (const collection of subscriberCollections) {
+                const limit = 1000;
+                const startSize = allSubscriberAssets.size;
+                let cursor = undefined;
+                let fetchCount = 0;
+                const startTime = Date.now();
+                console.log(`  Collection ${collection}: Starting...`);
+                while (true) {
+                    const result = yield getAssetsWithRetry(provider.connection.rpcEndpoint, {
+                        groupValue: collection,
+                        limit,
+                        cursor,
+                    });
+                    for (const asset of result.items) {
+                        allSubscriberAssets.set(asset.id.toBase58(), asset);
+                    }
+                    fetchCount++;
+                    const collectionTotal = allSubscriberAssets.size - startSize;
+                    // Show progress: first 3 fetches, then every 25 fetches
+                    if (fetchCount <= 3 || fetchCount % 25 === 0) {
+                        console.log(`    ${fetchCount} fetches: ${collectionTotal.toLocaleString()} assets`);
+                    }
+                    // Stop if no cursor returned (indicates end of data)
+                    if (!result.cursor) {
+                        break;
+                    }
+                    cursor = result.cursor;
+                    // Small delay to avoid rate limits (100ms between fetches)
+                    yield new Promise((resolve) => setTimeout(resolve, 100));
+                }
+                const thisCollectionTotal = allSubscriberAssets.size - startSize;
+                const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+                console.log(`  Complete: ${thisCollectionTotal.toLocaleString()} assets in ${fetchCount} fetches (${totalTime}s, cumulative: ${allSubscriberAssets.size.toLocaleString()})`);
+            }
+            console.log(`\nTotal unique subscriber assets found: ${allSubscriberAssets.size}`);
+            console.log("Processing assets into key_to_asset accounts...");
+            const existingKeyToAssetSet = new Set(keyToAssetInfos.map((k) => k.keyToAsset.toBase58()));
+            let processed = 0;
+            for (const asset of allSubscriberAssets.values()) {
+                const keyToAssetAddr = (0, helium_entity_manager_sdk_1.keyToAssetForAsset)(asset, dao);
+                // Ensure keyToAssetAddr is a PublicKey
+                const keyToAssetPubkey = typeof keyToAssetAddr === "string"
+                    ? new web3_js_1.PublicKey(keyToAssetAddr)
+                    : keyToAssetAddr;
+                // Skip if already in list (from hardcoded)
+                const keyToAssetStr = keyToAssetPubkey.toBase58();
+                if (!existingKeyToAssetSet.has(keyToAssetStr)) {
+                    keyToAssetInfos.push({
+                        keyToAsset: keyToAssetPubkey,
+                        assetId: asset.id,
+                        asset: asset,
+                        isHardcoded: false,
+                    });
+                    existingKeyToAssetSet.add(keyToAssetStr);
+                }
+                processed++;
+                // Show progress every 100k assets
+                if (processed % 100000 === 0) {
+                    console.log(`  Processed ${processed.toLocaleString()} / ${allSubscriberAssets.size.toLocaleString()} assets...`);
+                }
+            }
+            console.log(`  Processed all ${allSubscriberAssets.size.toLocaleString()} assets\n`);
+            // Free memory - no longer need full asset objects or dedup set
+            allSubscriberAssets.clear();
+            existingKeyToAssetSet.clear();
+        }
+        catch (err) {
+            console.log(`\n⚠️  DAS search failed: ${err.message}`);
+            console.log(`   Continuing with ${keyToAssetInfos.length} hardcoded key_to_assets only.`);
+        }
+        const hardcodedCount = keyToAssetInfos.filter((k) => k.isHardcoded).length;
+        const subscriberCount = keyToAssetInfos.filter((k) => !k.isHardcoded).length;
+        console.log(`\nTotal: ${keyToAssetInfos.length.toLocaleString()} key_to_asset accounts (${hardcodedCount} hardcoded, ${subscriberCount.toLocaleString()} subscribers)`);
+        // Extract entity keys (try URI first, fetch as fallback)
+        console.log("Extracting entity keys from asset data...");
+        const existingKeyToAssets = [];
+        const needsFetch = [];
+        // Try to extract from URI first
+        keyToAssetInfos.forEach((info) => {
+            var _a, _b;
+            if (info.entityKey) {
+                // Hardcoded account - already have entity key
+                existingKeyToAssets.push({
+                    keyToAsset: info.keyToAsset,
+                    assetId: info.assetId,
+                    entityKey: info.entityKey,
+                    isHardcoded: info.isHardcoded,
+                });
+            }
+            else if ((_b = (_a = info.asset) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.json_uri) {
+                // Try to extract from URI
+                const entityKeyStr = info.asset.content.json_uri.split("/").slice(-1)[0];
+                const cleanEntityKeyStr = entityKeyStr
+                    .split(".")[0]
+                    .split("?")[0]
+                    .split("#")[0];
+                try {
+                    const entityKey = Buffer.from(bs58_1.default.decode(cleanEntityKeyStr));
+                    existingKeyToAssets.push({
+                        keyToAsset: info.keyToAsset,
+                        assetId: info.assetId,
+                        entityKey,
+                        isHardcoded: info.isHardcoded,
+                    });
+                }
+                catch (err) {
+                    // URI extraction failed - need to fetch
+                    needsFetch.push(info);
+                }
+            }
+            else {
+                // No URI - need to fetch
+                needsFetch.push(info);
+            }
+        });
+        console.log(`  Extracted ${existingKeyToAssets.length.toLocaleString()} entity keys from URIs`);
+        // Fetch the ones that failed URI extraction
+        if (needsFetch.length > 0) {
+            console.log(`  Fetching ${needsFetch.length.toLocaleString()} keyToAssetV0 accounts (URI extraction failed)...`);
+            function fetchKeyToAssetsWithRetry(chunk, maxRetries = 3) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    for (let attempt = 0; attempt < maxRetries; attempt++) {
+                        try {
+                            const accountInfos = yield hemProgram.account.keyToAssetV0.fetchMultiple(chunk.map((k) => k.keyToAsset));
+                            return { accountInfos, chunk };
+                        }
+                        catch (err) {
+                            if (attempt === maxRetries - 1)
+                                throw err;
+                            const delay = Math.min(1000 * Math.pow(2, attempt), 5000);
+                            yield new Promise((resolve) => setTimeout(resolve, delay));
+                        }
+                    }
+                    throw new Error("Max retries exceeded");
+                });
+            }
+            const keyToAssetChunks = (0, spl_utils_1.chunks)(needsFetch, 100);
+            const keyToAssetLimiter = (0, p_limit_1.default)(10);
+            let keyToAssetFetchedCount = 0;
+            let keyToAssetBatchIndex = 0;
+            const keyToAssetBatchResults = yield Promise.all(keyToAssetChunks.map((chunk) => keyToAssetLimiter(() => __awaiter(this, void 0, void 0, function* () {
+                const result = yield fetchKeyToAssetsWithRetry(chunk);
+                keyToAssetFetchedCount += chunk.length;
+                keyToAssetBatchIndex++;
+                // Show progress
+                if (keyToAssetBatchIndex <= 3 ||
+                    keyToAssetBatchIndex % 10 === 0 ||
+                    keyToAssetFetchedCount === needsFetch.length) {
+                    console.log(`    ${keyToAssetBatchIndex} batches: ${keyToAssetFetchedCount.toLocaleString()} accounts`);
+                }
+                return result;
+            }))));
+            // Process fetched accounts
+            keyToAssetBatchResults.forEach(({ accountInfos, chunk }) => {
+                accountInfos.forEach((account, index) => {
+                    if (account) {
+                        existingKeyToAssets.push({
+                            keyToAsset: chunk[index].keyToAsset,
+                            assetId: chunk[index].assetId,
+                            entityKey: Buffer.from(account.entityKey),
+                            isHardcoded: chunk[index].isHardcoded,
+                        });
+                    }
+                });
+            });
+            console.log(`  Fetched ${keyToAssetFetchedCount.toLocaleString()} entity keys from accounts`);
+        }
+        console.log(`  Total: ${existingKeyToAssets.length.toLocaleString()} entity keys\n`);
+        // Free memory - no longer need original key_to_asset infos or assets
+        keyToAssetInfos.length = 0;
+        // ========== STEP 2: Claim all rewards until none remain ==========
+        console.log("\n=== STEP 2: CLAIMING REWARDS ===\n");
+        let claimIteration = 0;
+        let totalClaimedAmount = new bn_js_1.default(0);
+        let totalClaimedTransactions = 0;
+        // Build recipient lookup
+        console.log(`Fetching ${existingKeyToAssets.length.toLocaleString()} recipient accounts...`);
+        const existingRecipients = new Set();
+        const recipientKeys = existingKeyToAssets.map(({ assetId }) => (0, lazy_distributor_sdk_1.recipientKey)(lazyDistributor, assetId)[0]);
+        function fetchRecipientsWithRetry(chunk, maxRetries = 3) {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (let attempt = 0; attempt < maxRetries; attempt++) {
+                    try {
+                        const accountInfos = yield lazyProgram.account.recipientV0.fetchMultiple(chunk);
+                        return { accountInfos, chunk };
+                    }
+                    catch (err) {
+                        if (attempt === maxRetries - 1)
+                            throw err;
+                        const delay = Math.min(1000 * Math.pow(2, attempt), 5000);
+                        yield new Promise((resolve) => setTimeout(resolve, delay));
+                    }
+                }
+                throw new Error("Max retries exceeded");
+            });
+        }
+        // Fetch recipients with concurrency limit
+        const recipientChunks = (0, spl_utils_1.chunks)(recipientKeys, 1000);
+        const limiter = (0, p_limit_1.default)(10);
+        let fetchedCount = 0;
+        let batchIndex = 0;
+        // Build assetsWithRecipients directly while fetching (no extra loops!)
+        const assetsWithRecipients = [];
+        yield Promise.all(recipientChunks.map((chunk, chunkIndex) => limiter(() => __awaiter(this, void 0, void 0, function* () {
+            const result = yield fetchRecipientsWithRetry(chunk);
+            fetchedCount += chunk.length;
+            batchIndex++;
+            // Calculate starting index for this chunk
+            const chunkStartIndex = chunkIndex * 1000;
+            // Build assetsWithRecipients directly from results
+            result.accountInfos.forEach((info, index) => {
+                if (info) {
+                    const recipientAddr = chunk[index].toBase58();
+                    existingRecipients.add(recipientAddr);
+                    // Use index to get corresponding asset (no map lookup!)
+                    assetsWithRecipients.push(existingKeyToAssets[chunkStartIndex + index]);
+                }
+            });
+            // Show progress: first 3 batches, then every 25 batches
+            if (batchIndex <= 3 ||
+                batchIndex % 25 === 0 ||
+                fetchedCount === recipientKeys.length) {
+                console.log(`  ${batchIndex} batches: ${fetchedCount.toLocaleString()} accounts`);
+            }
+            return result;
+        }))));
+        console.log(`  Found ${existingRecipients.size.toLocaleString()} existing recipients\n`);
+        console.log(`Checking rewards for ${assetsWithRecipients.length.toLocaleString()} assets with recipients (skipping ${(existingKeyToAssets.length - assetsWithRecipients.length).toLocaleString()} without recipients)\n`);
+        while (true) {
+            claimIteration++;
+            console.log(`--- Claim Iteration ${claimIteration} ---`);
+            // Check pending rewards using bulk API
+            let assetsWithRewards = 0;
+            let assetsWithZeroRewards = 0;
+            let totalPendingRewards = new bn_js_1.default(0);
+            const assetsToClaim = [];
+            // Create map of entityKey -> asset info for lookup
+            const entityKeyToAsset = new Map();
+            assetsWithRecipients.forEach(({ assetId, entityKey }) => {
+                // Decode entity key to string format that oracle expects (b58 for subscriber assets)
+                const entityKeyStr = (0, helium_entity_manager_sdk_1.decodeEntityKey)(entityKey, { b58: {} });
+                if (entityKeyStr) {
+                    entityKeyToAsset.set(entityKeyStr, {
+                        assetId,
+                        entityKey,
+                    });
+                }
+            });
+            // Get bulk rewards in chunks
+            const entityKeys = Array.from(entityKeyToAsset.keys());
+            const rewardsChunks = (0, spl_utils_1.chunks)(entityKeys, 5000);
+            const rewardsLimiter = (0, p_limit_1.default)(5);
+            let checkedCount = 0;
+            let rewardsBatchIndex = 0;
+            const bulkRewardsResults = yield Promise.all(rewardsChunks.map((chunk) => rewardsLimiter(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const bulkRewards = yield client.getBulkRewards(lazyProgram, lazyDistributor, chunk);
+                    rewardsBatchIndex++;
+                    checkedCount += chunk.length;
+                    // Show progress
+                    if (rewardsBatchIndex <= 3 ||
+                        rewardsBatchIndex % 5 === 0 ||
+                        checkedCount === entityKeys.length) {
+                        console.log(`  ${rewardsBatchIndex} batches: ${checkedCount.toLocaleString()} assets`);
+                    }
+                    return { chunk, bulkRewards };
+                }
+                catch (err) {
+                    console.error(`Error fetching bulk rewards: ${err.message}`);
+                    return { chunk, bulkRewards: [] };
+                }
+            }))));
+            // Merge bulk rewards from all chunks
+            // Each chunk has the same oracle keys but different entity key data
+            const mergedBulkRewards = [];
+            if (bulkRewardsResults.length > 0 &&
+                bulkRewardsResults[0].bulkRewards.length > 0) {
+                const numOracles = bulkRewardsResults[0].bulkRewards.length;
+                for (let oracleIdx = 0; oracleIdx < numOracles; oracleIdx++) {
+                    const mergedRewards = {};
+                    // Merge rewards from all chunks for this oracle
+                    bulkRewardsResults.forEach(({ bulkRewards }) => {
+                        if (bulkRewards[oracleIdx]) {
+                            Object.assign(mergedRewards, bulkRewards[oracleIdx].currentRewards);
+                        }
+                    });
+                    mergedBulkRewards.push({
+                        currentRewards: mergedRewards,
+                        oracleKey: bulkRewardsResults[0].bulkRewards[oracleIdx].oracleKey,
+                    });
+                }
+            }
+            // Process rewards using merged bulk rewards
+            entityKeys.forEach((entityKey) => {
+                const assetInfo = entityKeyToAsset.get(entityKey);
+                if (!assetInfo)
+                    return;
+                // Aggregate rewards across all oracles for this entity
+                const rewards = mergedBulkRewards.map((oracle) => ({
+                    currentRewards: oracle.currentRewards[entityKey] || "0",
+                    oracleKey: oracle.oracleKey,
+                }));
+                const totalRewards = rewards.reduce((sum, r) => {
+                    return sum.add(new bn_js_1.default(r.currentRewards));
+                }, new bn_js_1.default(0));
+                if (totalRewards.gt(new bn_js_1.default(0))) {
+                    assetsWithRewards++;
+                    totalPendingRewards = totalPendingRewards.add(totalRewards);
+                    assetsToClaim.push({
+                        asset: assetInfo.assetId,
+                        rewards,
+                    });
+                }
+                else {
+                    assetsWithZeroRewards++;
+                }
+            });
+            const pendingMobile = totalPendingRewards.div(new bn_js_1.default(100000000)).toString();
+            console.log(`\nPending: ${assetsWithRewards} assets with ${pendingMobile} MOBILE (${assetsWithZeroRewards} with zero)`);
+            // If no more rewards, break out of loop
+            if (assetsWithRewards === 0) {
+                console.log("\n✓ All rewards have been claimed!");
+                break;
+            }
+            if (!argv.commit) {
+                console.log(`\nDry run: would claim rewards for ${assetsWithRewards} assets`);
+                break;
+            }
+            console.log(`\nClaiming rewards for ${assetsWithRewards} assets...`);
+            // Batch claim rewards using formBulkTransactions (up to 100 assets per call)
+            console.log(`Preparing ${assetsToClaim.length} claim transactions...`);
+            const claimChunks = (0, spl_utils_1.chunks)(assetsToClaim, 100); // formBulkTransactions supports up to 100
+            const claimTxLimiter = (0, p_limit_1.default)(10);
+            let preparedCount = 0;
+            const allBatchTxns = yield Promise.all(claimChunks.map((chunk) => claimTxLimiter(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const assets = chunk.map((c) => c.asset);
+                    // Use formBulkTransactions which is more efficient than individual formTransaction calls
+                    const txns = yield client.formBulkTransactions({
+                        program: lazyProgram,
+                        rewardsOracleProgram: rewardsOracleProgram,
+                        rewards: mergedBulkRewards,
+                        assets,
+                        lazyDistributor,
+                        wallet: authority.publicKey,
+                    });
+                    preparedCount += chunk.length;
+                    // Show progress every 100 or at end
+                    if (preparedCount % 100 === 0 ||
+                        preparedCount === assetsToClaim.length) {
+                        console.log(`  Prepared ${preparedCount}/${assetsToClaim.length} transactions`);
+                    }
+                    return txns;
+                }
+                catch (err) {
+                    console.error(`Error forming bulk transactions for batch: ${err.message}`);
+                    return [];
+                }
+            }))));
+            const txns = allBatchTxns.flat().filter(spl_utils_1.truthy);
+            console.log(`Sending ${txns.length} transactions...`);
+            for (const tx of txns) {
+                tx.sign([authority]);
+            }
+            yield (0, spl_utils_1.bulkSendRawTransactions)(provider.connection, txns.map((tx) => Buffer.from(tx.serialize())), (status) => {
+                // Only show every 10 batches for mainnet scale
+                if (status.totalProgress % 10 === 0 ||
+                    status.totalProgress === txns.length) {
+                    console.log(`  Sent ${status.totalProgress} / ${txns.length}`);
+                }
+            });
+            totalClaimedAmount = totalClaimedAmount.add(totalPendingRewards);
+            totalClaimedTransactions += txns.length;
+            console.log(`Iteration ${claimIteration} complete. Claimed ${totalPendingRewards
+                .div(new bn_js_1.default(100000000))
+                .toString()} MOBILE across ${txns.length} transactions.`);
+            // Free memory for next iteration
+            assetsToClaim.length = 0;
+            txns.length = 0;
+            // Wait a bit before next iteration to let chain settle
+            console.log("\nWaiting 5 seconds before next check...");
+            yield new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+        const claimedMobile = totalClaimedAmount.div(new bn_js_1.default(100000000)).toString();
+        console.log(`\nClaimed ${claimedMobile} MOBILE in ${claimIteration} iteration(s), ${totalClaimedTransactions} tx(s)`);
+        // Free memory - no longer need recipient data
+        existingRecipients.clear();
+        recipientKeys.length = 0;
+        // ========== STEP 3: Close all KeyToAssetV0 accounts ==========
+        console.log("\n=== STEP 3: CLOSING ACCOUNTS ===\n");
+        if (!argv.commit) {
+            const closingHardcoded = existingKeyToAssets.filter((k) => k.isHardcoded).length;
+            const closingSubscribers = existingKeyToAssets.filter((k) => !k.isHardcoded).length;
+            console.log(`Dry run: would close ${existingKeyToAssets.length} accounts (${closingHardcoded} hardcoded, ${closingSubscribers} subscribers)`);
+            console.log(`\nRe-run with --commit to execute`);
+            console.log(`Then run close-all-subscriber-recipients to close RecipientV0 accounts`);
+            return;
+        }
+        console.log(`Closing ${existingKeyToAssets.length.toLocaleString()} accounts...`);
+        // Build close instructions
+        const instructions = [];
+        // Separate hardcoded (need info checks) from subscribers (no checks needed)
+        const hardcodedAccountsToClose = existingKeyToAssets.filter((k) => k.isHardcoded);
+        const subscriberAccounts = existingKeyToAssets.filter((k) => !k.isHardcoded);
+        console.log(`  Hardcoded: ${hardcodedAccountsToClose.length}, Subscribers: ${subscriberAccounts.length.toLocaleString()}`);
+        // Process hardcoded accounts (check info accounts)
+        if (hardcodedAccountsToClose.length > 0) {
+            console.log("Processing hardcoded accounts...");
+            for (const { keyToAsset, assetId, entityKey } of hardcodedAccountsToClose) {
+                const [mobileInfo] = (0, helium_entity_manager_sdk_1.mobileInfoKey)(mobileConfig, entityKey);
+                const [iotInfo] = (0, helium_entity_manager_sdk_1.iotInfoKey)(iotConfig, entityKey);
+                const [mobileInfoAcc, iotInfoAcc] = yield Promise.all([
+                    provider.connection.getAccountInfo(mobileInfo),
+                    provider.connection.getAccountInfo(iotInfo),
+                ]);
+                console.log(`  ${keyToAsset.toBase58()}`);
+                console.log(`    Mobile Info: ${mobileInfoAcc ? "exists (will close)" : "does not exist"}`);
+                console.log(`    IoT Info: ${iotInfoAcc ? "exists (will close)" : "does not exist"}`);
+                const ix = yield hemProgram.methods
+                    .tempCloseKeyToAssetV0()
+                    .accountsPartial({
+                    keyToAsset,
+                    dao,
+                    authority: authority.publicKey,
+                    asset: assetId,
+                    mobileConfig,
+                    iotConfig,
+                    mobileInfo,
+                    iotInfo,
+                    iotSubDao,
+                    mobileSubDao,
+                })
+                    .instruction();
+                instructions.push(ix);
+            }
+        }
+        // Process subscriber accounts (no info checks - they shouldn't have info accounts)
+        if (subscriberAccounts.length > 0) {
+            console.log(`Processing ${subscriberAccounts.length.toLocaleString()} subscriber accounts...`);
+            let processed = 0;
+            const subscriberChunks = (0, spl_utils_1.chunks)(subscriberAccounts, 100);
+            const instructionLimiter = (0, p_limit_1.default)(50);
+            const allBatchInstructions = yield Promise.all(subscriberChunks.map((chunk) => instructionLimiter(() => __awaiter(this, void 0, void 0, function* () {
+                const batchInstructions = yield Promise.all(chunk.map(({ keyToAsset, assetId, entityKey }) => __awaiter(this, void 0, void 0, function* () {
+                    const [mobileInfo] = (0, helium_entity_manager_sdk_1.mobileInfoKey)(mobileConfig, entityKey);
+                    const [iotInfo] = (0, helium_entity_manager_sdk_1.iotInfoKey)(iotConfig, entityKey);
+                    return yield hemProgram.methods
+                        .tempCloseKeyToAssetV0()
+                        .accountsPartial({
+                        keyToAsset,
+                        dao,
+                        authority: authority.publicKey,
+                        asset: assetId,
+                        mobileConfig,
+                        iotConfig,
+                        mobileInfo,
+                        iotInfo,
+                        iotSubDao,
+                        mobileSubDao,
+                    })
+                        .instruction();
+                })));
+                processed += chunk.length;
+                // Show progress every 10k instructions
+                if (processed % 10000 === 0 ||
+                    processed === subscriberAccounts.length) {
+                    console.log(`  Prepared ${processed.toLocaleString()} / ${subscriberAccounts.length.toLocaleString()} instructions...`);
+                }
+                return batchInstructions;
+            }))));
+            instructions.push(...allBatchInstructions.flat().filter(spl_utils_1.truthy));
+        }
+        console.log(`\nBatching ${instructions.length.toLocaleString()} instructions into transactions...`);
+        // Free memory - no longer need existingKeyToAssets
+        existingKeyToAssets.length = 0;
+        const closeTxns = yield (0, spl_utils_1.batchInstructionsToTxsWithPriorityFee)(provider, instructions, {
+            useFirstEstimateForAll: true,
+            computeUnitLimit: 600000,
+        });
+        // Free memory - instructions now in transactions
+        instructions.length = 0;
+        console.log(`\nSending ${closeTxns.length} transactions...`);
+        // Sign with authority and send
+        yield (0, spl_utils_1.bulkSendTransactions)(provider, closeTxns, (status) => {
+            console.log(`Sending ${status.currentBatchProgress} / ${status.currentBatchSize} in batch. ${status.totalProgress} / ${closeTxns.length}`);
+        }, 10, [authority]);
+        const finalClaimedMobile = totalClaimedAmount
+            .div(new bn_js_1.default(100000000))
+            .toString();
+        console.log(`\n✓ Complete: Claimed ${finalClaimedMobile} MOBILE, closed ${instructions.length} accounts`);
+        console.log(`Next: run close-all-subscriber-recipients`);
+    });
+}
+exports.run = run;
+//# sourceMappingURL=claim-and-close-subscriber-key-to-assets.js.map