@helium/sus 0.6.24-next.8 → 0.6.30

package/lib/esm/src/index.js

@@ -1,4 +1,4 @@
-import { BorshAccountsCoder, BorshInstructionCoder, } from "@coral-xyz/anchor";
+import { BN, BorshAccountsCoder, BorshInstructionCoder, } from "@coral-xyz/anchor";
 import { decodeIdlAccount } from "@coral-xyz/anchor/dist/cjs/idl";
 import { utf8 } from "@coral-xyz/anchor/dist/cjs/utils/bytes";
 import { getLeafAssetId } from "@metaplex-foundation/mpl-bubblegum";
@@ -10,15 +10,7 @@ import axios from "axios";
 import { inflate } from "pako";
 const BUBBLEGUM_PROGRAM_ID = new PublicKey("BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY");
 const ACCOUNT_COMPRESSION_PROGRAM_ID = new PublicKey("cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK");
-export async function sus({ connection, wallet, serializedTransaction, 
-/// CNFT specific params
-checkCNfts = false, extraSearchAssetParams, cNfts, 
-// Cluster for explorer
-cluster = "mainnet-beta", }) {
-    const warnings = [];
-    const transaction = VersionedTransaction.deserialize(serializedTransaction);
-    const message = transaction.message.serialize().toString("base64");
-    const explorerLink = `https://explorer.solana.com/tx/inspector?cluster=${cluster}&message=${encodeURIComponent(message)}`;
+async function getAccountKeys({ connection, transaction, }) {
     const addressLookupTableAccounts = [];
     const { addressTableLookups } = transaction.message;
     if (addressTableLookups.length > 0) {
@@ -31,37 +23,111 @@ cluster = "mainnet-beta", }) {
             }
         }
     }
-    const accountKeys = transaction.message.getAccountKeys({
+    return transaction.message.getAccountKeys({
         addressLookupTableAccounts,
     });
-    const simulationAccounts = [
+}
+async function getMultipleAccounts({ connection, keys, }) {
+    const batchSize = 100;
+    const batches = Math.ceil(keys.length / batchSize);
+    const results = [];
+    for (let i = 0; i < batches; i++) {
+        const batchKeys = keys.slice(i * batchSize, (i + 1) * batchSize);
+        const batchResults = await connection.getMultipleAccountsInfo(batchKeys);
+        results.push(...batchResults);
+    }
+    return results;
+}
+export async function sus({ connection, wallet, serializedTransactions, 
+/// CNFT specific params
+checkCNfts = false, extraSearchAssetParams, cNfts, 
+// Cluster for explorer
+cluster = "mainnet-beta", accountBlacklist, }) {
+    let assets = cNfts;
+    if (checkCNfts) {
+        if (!assets) {
+            const assetsResponse = await axios.post(connection.rpcEndpoint, {
+                jsonrpc: "2.0",
+                method: "searchAssets",
+                id: "get-assets-op-1",
+                params: {
+                    page: 1,
+                    // limit to checking 200 assets
+                    limit: 200,
+                    compressed: true,
+                    ownerAddress: wallet.toBase58(),
+                    ...extraSearchAssetParams,
+                },
+                headers: {
+                    "Cache-Control": "no-cache",
+                    Pragma: "no-cache",
+                    Expires: "0",
+                },
+            });
+            assets = assetsResponse.data.result?.items;
+        }
+    }
+    const warningsByTx = serializedTransactions.map(() => []);
+    const transactions = serializedTransactions.map((t) => VersionedTransaction.deserialize(t));
+    const accountKeysByTx = await Promise.all(transactions.map((transaction) => getAccountKeys({ connection, transaction })));
+    const simulationAccountsByTx = accountKeysByTx.map((accountKeys, txIndex) => [
         ...new Set(accountKeys.staticAccountKeys
-            .filter((_, index) => transaction.message.isAccountWritable(index))
+            .filter((_, index) => transactions[txIndex].message.isAccountWritable(index))
             .concat(accountKeys.accountKeysFromLookups
             ? // Only writable accounts will contribute to balance changes
                 accountKeys.accountKeysFromLookups.writable
             : [])),
-    ];
-    const fetchedAccounts = await connection.getMultipleAccountsInfo(simulationAccounts);
+    ].filter((a) => !accountBlacklist?.has(a.toBase58())));
+    const allAccounts = [...new Set(simulationAccountsByTx.flat())];
+    const fetchedAccounts = await getMultipleAccounts({
+        connection,
+        keys: allAccounts,
+    });
+    const fetchedAccountsByAddr = fetchedAccounts.reduce((acc, account, index) => {
+        acc[allAccounts[index].toBase58()] = account;
+        return acc;
+    }, {});
     const { blockhash } = await connection?.getLatestBlockhash();
-    transaction.message.recentBlockhash = blockhash;
-    const simulatedTxn = await connection?.simulateTransaction(transaction, {
-        accounts: {
-            encoding: "base64",
-            addresses: simulationAccounts?.map((account) => account.toBase58()) || [],
-        },
+    const simulatedTxs = [];
+    // Linearly simulate txs so as not to hit rate limits
+    for (const [index, transaction] of transactions.entries()) {
+        transaction.message.recentBlockhash = blockhash;
+        const simulatedTxn = await connection?.simulateTransaction(transaction, {
+            accounts: {
+                encoding: "base64",
+                addresses: simulationAccountsByTx[index]?.map((account) => account.toBase58()) ||
+                    [],
+            },
+        });
+        simulatedTxs.push(simulatedTxn);
+    }
+    const fullAccountsByTxn = simulationAccountsByTx.map((simulationAccounts, transactionIndex) => {
+        const simulatedTxn = simulatedTxs[transactionIndex];
+        return simulationAccounts.map((account, index) => {
+            const post = simulatedTxn.value.accounts?.[index];
+            return {
+                address: account,
+                post: post
+                    ? {
+                        ...post,
+                        owner: new PublicKey(post.owner),
+                        data: Buffer.from(post.data[0], post.data[1]),
+                    }
+                    : undefined,
+                pre: fetchedAccountsByAddr[account.toBase58()],
+            };
+        });
     });
-    const fullAccounts = simulationAccounts.map((account, index) => ({
-        address: account,
-        post: simulatedTxn.value.accounts?.[index],
-        pre: fetchedAccounts[index],
-    }));
-    const programKeys = fullAccounts
+    const instructionProgramIds = transactions
+        .flatMap((transaction, index) => transaction.message.compiledInstructions.map((ix) => accountKeysByTx[index].get(ix.programIdIndex) || null))
+        .filter(truthy);
+    const programKeys = fullAccountsByTxn
+        .flat()
         .map((acc) => acc?.pre?.owner || (acc.post ? new PublicKey(acc.post.owner) : null))
-        .concat(...transaction.message.compiledInstructions.map((ix) => accountKeys.get(ix.programIdIndex) || null))
+        .concat(...instructionProgramIds)
         .filter(truthy);
     const idlKeys = programKeys.map(getIdlKey);
-    const idls = (await connection.getMultipleAccountsInfo(idlKeys))
+    const idls = (await getMultipleAccounts({ connection, keys: idlKeys }))
         .map((acc, index) => {
         if (acc) {
             return {
@@ -77,52 +143,130 @@ cluster = "mainnet-beta", }) {
         }
         return acc;
     }, {});
-    const writableAccounts = await getDetailedWritableAccounts({
-        connection,
-        accounts: fullAccounts,
+    const writableAccountsByTxRaw = fullAccountsByTxn.map((accounts) => getDetailedWritableAccountsWithoutTM({
+        accounts,
         idls,
+    }));
+    const tokens = [
+        ...new Set(writableAccountsByTxRaw.flatMap((w) => w.tokens).map((t) => t.toBase58())),
+    ].map((t) => new PublicKey(t));
+    const metadatas = (await fetchMetadatas(connection, tokens)).reduce((acc, m, index) => {
+        if (m) {
+            acc[tokens[index].toBase58()] = m;
+        }
+        return acc;
+    }, {});
+    const writableAccountsByTx = writableAccountsByTxRaw.map(({ withoutMetadata }, index) => {
+        const writableAccounts = withoutMetadata.map((acc) => {
+            let name = acc.name;
+            let metadata;
+            // Attempt to take last known type
+            const type = (acc.pre.type !== "Unknown" && acc.pre.type) ||
+                (acc.post.type !== "Unknown" && acc.post.type) ||
+                "Unknown";
+            // If token, get the name based on the metadata
+            if (type === "Mint") {
+                metadata = metadatas[acc.address.toBase58()];
+                if (metadata) {
+                    name = `${metadata.symbol} Mint`;
+                }
+                else {
+                    name = `Unknown Mint`;
+                }
+            }
+            else if (type === "TokenAccount") {
+                metadata =
+                    metadatas[(acc.pre.parsed?.mint || acc.post.parsed?.mint).toBase58()];
+                if (metadata) {
+                    name = `${metadata.symbol} Token Account`;
+                }
+                else {
+                    name = `Unknown Token Account`;
+                }
+            }
+            return {
+                ...acc,
+                name,
+                metadata,
+            };
+        });
+        writableAccounts.forEach((acc) => {
+            if (!acc.changedInSimulation) {
+                warningsByTx[index].push({
+                    severity: "warning",
+                    shortMessage: "Unchanged",
+                    message: "Account did not change in simulation but was labeled as writable. The behavior of the transaction may differ from the simulation.",
+                    account: acc.address,
+                });
+            }
+            // Catch malicious sol ownwer change
+            const sysProg = new PublicKey("11111111111111111111111111111111");
+            const postOwner = acc.post.account?.owner || sysProg;
+            const preOwner = acc.pre.account?.owner || sysProg;
+            const accountOwnerChanged = !preOwner.equals(postOwner);
+            if (acc.name === "Native SOL Account" && acc.owner && acc.owner.equals(wallet) && accountOwnerChanged) {
+                warningsByTx[index].push({
+                    severity: "critical",
+                    shortMessage: "Owner Changed",
+                    message: `The owner of ${acc.name} changed to ${acc.post.parsed?.owner?.toBase58()}. This gives that wallet full custody of these tokens.`,
+                    account: acc.address,
+                });
+            }
+        });
+        return writableAccounts;
     });
-    const instructions = await parseInstructions({
-        idls,
-        instructions: transaction.message.compiledInstructions.map((ix) => ({
-            data: Buffer.from(ix.data),
-            programId: accountKeys.get(ix.programIdIndex),
-            accounts: ix.accountKeyIndexes.map((ix) => ({
-                pubkey: accountKeys.get(ix),
-                isSigner: transaction.message.isAccountSigner(ix),
-                isWritable: transaction.message.isAccountWritable(ix),
+    const instructionsByTx = await Promise.all(transactions.map(async (transaction, index) => {
+        const instructions = parseInstructions({
+            idls,
+            instructions: transaction.message.compiledInstructions.map((ix) => ({
+                data: Buffer.from(ix.data),
+                programId: accountKeysByTx[index].get(ix.programIdIndex),
+                accounts: ix.accountKeyIndexes.map((ix) => ({
+                    pubkey: accountKeysByTx[index].get(ix),
+                    isSigner: transaction.message.isAccountSigner(ix),
+                    isWritable: transaction.message.isAccountWritable(ix),
+                })),
             })),
-        })),
-    });
-    if (instructions.some((ix) => ix.parsed?.name === "ledgerTransferPositionV0")) {
-        warnings.push({
-            severity: "critical",
-            shortMessage: "Theft of Locked HNT",
-            message: "This transaction is attempting to steal your locked HNT positions",
-        });
-    }
-    if ((await Promise.all(instructions.map((ix) => isBurnHotspot(connection, ix)))).some((isBurn) => isBurn)) {
-        warnings.push({
-            severity: "critical",
-            shortMessage: "Hotspot Destroyed",
-            message: "This transaction will brick your Hotspot!",
         });
-    }
-    const logs = simulatedTxn.value.logs;
-    if (simulatedTxn?.value.err) {
-        if (isInsufficientBal(simulatedTxn?.value.err)) {
+        if (instructions.some((ix) => ix.parsed?.name === "ledgerTransferPositionV0")) {
+            warningsByTx[index].push({
+                severity: "critical",
+                shortMessage: "Theft of Locked HNT",
+                message: "This transaction is attempting to steal your locked HNT positions",
+            });
+        }
+        if ((await Promise.all(instructions.map((ix) => isBurnHotspot(connection, ix, assets)))).some((isBurn) => isBurn)) {
+            warningsByTx[index].push({
+                severity: "critical",
+                shortMessage: "Hotspot Destroyed",
+                message: "This transaction will brick your Hotspot!",
+            });
+        }
+        return instructions;
+    }));
+    const results = [];
+    for (const [index, simulatedTxn] of simulatedTxs.entries()) {
+        const warnings = warningsByTx[index];
+        const instructions = instructionsByTx[index];
+        const writableAccounts = writableAccountsByTx[index];
+        const transaction = transactions[index];
+        const message = transaction.message.serialize().toString("base64");
+        const explorerLink = `https://explorer.solana.com/tx/inspector?cluster=${cluster}&message=${encodeURIComponent(message)}`;
+        const logs = simulatedTxn.value.logs;
+        let result;
+        if (simulatedTxn?.value.err) {
             warnings.push({
-                severity: "warning",
+                severity: "critical",
                 shortMessage: "Simulation Failed",
                 message: "Transaction failed in simulation",
             });
-            return {
+            result = {
                 instructions,
                 error: simulatedTxn.value.err,
                 logs,
                 solFee: 0,
                 priorityFee: 0,
-                insufficientFunds: true,
+                insufficientFunds: isInsufficientBal(simulatedTxn?.value.err),
                 explorerLink,
                 balanceChanges: [],
                 possibleCNftChanges: [],
@@ -131,109 +275,93 @@ cluster = "mainnet-beta", }) {
                 warnings,
             };
         }
-    }
-    let solFee = (transaction?.signatures.length || 1) * 5000;
-    let priorityFee = 0;
-    const fee = (await connection?.getFeeForMessage(transaction.message, "confirmed"))
-        .value || solFee;
-    priorityFee = fee - solFee;
-    const balanceChanges = writableAccounts
-        .map((acc) => {
-        const type = acc.pre.type || acc.post.type;
-        switch (type) {
-            case "TokenAccount":
-                if (acc.post.parsed?.delegate && !acc.pre.parsed?.delegate) {
-                    warnings.push({
-                        severity: "warning",
-                        shortMessage: "Withdraw Authority Given",
-                        message: `Delegation was taken on ${acc.name}. This gives permission to withdraw tokens without the owner's permission.`,
-                        account: acc.address
-                    });
-                }
-                if (acc.post.parsed &&
-                    acc.pre.parsed &&
-                    !acc.post.parsed.owner.equals(acc.pre.parsed.owner)) {
-                    warnings.push({
-                        severity: "warning",
-                        shortMessage: "Owner Changed",
-                        message: `The owner of ${acc.name} changed to ${acc.post.parsed?.owner}. This gives that wallet full custody of these tokens.`,
-                        account: acc.address,
-                    });
+        else {
+            let solFee = (transaction?.signatures.length || 1) * 5000;
+            let priorityFee = 0;
+            const fee = (await connection?.getFeeForMessage(transaction.message, "confirmed"))
+                .value || solFee;
+            priorityFee = fee - solFee;
+            const balanceChanges = writableAccounts
+                .map((acc) => {
+                const type = (acc.pre.type !== "Unknown" && acc.pre.type) ||
+                    (acc.post.type !== "Unknown" && acc.post.type);
+                switch (type) {
+                    case "TokenAccount":
+                        if (acc.post.parsed?.delegate && !acc.pre.parsed?.delegate) {
+                            warnings.push({
+                                severity: "warning",
+                                shortMessage: "Withdraw Authority Given",
+                                message: `Delegation was taken on ${acc.name}. This gives permission to withdraw tokens without the owner's permission.`,
+                                account: acc.address,
+                            });
+                        }
+                        if (acc.post.parsed &&
+                            acc.pre.parsed &&
+                            !acc.post.parsed.owner.equals(acc.pre.parsed.owner)) {
+                            warnings.push({
+                                severity: "warning",
+                                shortMessage: "Owner Changed",
+                                message: `The owner of ${acc.name} changed to ${acc.post.parsed?.owner?.toBase58()}. This gives that wallet full custody of these tokens.`,
+                                account: acc.address,
+                            });
+                        }
+                        return {
+                            owner: acc.post.parsed?.owner || acc.pre.parsed?.owner,
+                            address: acc.address,
+                            amount: (acc.post.parsed?.amount || BigInt(0)) -
+                                (acc.pre.parsed?.amount || BigInt(0)),
+                            metadata: acc.metadata,
+                        };
+                    case "NativeAccount":
+                        return {
+                            owner: acc.address,
+                            address: acc.address,
+                            amount: BigInt((acc.post.account?.lamports || 0) -
+                                (acc.pre.account?.lamports || 0)),
+                            metadata: {
+                                mint: NATIVE_MINT,
+                                decimals: 9,
+                                name: "SOL",
+                                symbol: "SOL",
+                            },
+                        };
+                    default:
+                        return null;
                 }
-                return {
-                    owner: acc.post.parsed?.owner || acc.pre.parsed?.owner,
-                    address: acc.address,
-                    amount: (acc.post.parsed?.amount || BigInt(0)) -
-                        (acc.pre.parsed?.amount || BigInt(0)),
-                    metadata: acc.metadata,
-                };
-            case "NativeAccount":
-                return {
-                    owner: acc.address,
-                    address: acc.address,
-                    amount: BigInt((acc.post.account?.lamports || 0) -
-                        (acc.pre.account?.lamports || 0)),
-                    metadata: {
-                        mint: NATIVE_MINT,
-                        decimals: 9,
-                        name: "SOL",
-                        symbol: "SOL",
-                    },
-                };
-            default:
-                return null;
-        }
-    })
-        .filter(truthy);
-    if (balanceChanges.filter((b) => b.owner.equals(wallet) && b.amount < BigInt(0))
-        .length > 2) {
-        warnings.push({
-            severity: "warning",
-            shortMessage: "2+ Writable Accounts",
-            message: "More than 2 accounts with negative balance change. Is this emptying your wallet?",
-        });
-    }
-    let possibleCNftChanges = [];
-    if (checkCNfts) {
-        let assets = cNfts;
-        if (!assets) {
-            const assetsResponse = await axios.post(connection.rpcEndpoint, {
-                jsonrpc: "2.0",
-                method: "searchAssets",
-                id: "get-assets-op-1",
-                params: {
-                    page: 1,
-                    // limit to checking 200 assets
-                    limit: 200,
-                    compressed: true,
-                    ...extraSearchAssetParams,
-                },
-                headers: {
-                    "Cache-Control": "no-cache",
-                    Pragma: "no-cache",
-                    Expires: "0",
-                },
-            });
-            assets = assetsResponse.data.result?.items;
+            })
+                .filter(truthy);
+            // Don't count new mints being created, as this might flag on candymachine txs
+            if (balanceChanges.filter((b) => b.owner.equals(wallet) && fetchedAccountsByAddr[b.address.toBase58()]).length >= 3) {
+                warnings.push({
+                    severity: "warning",
+                    shortMessage: "3+ Token Accounts",
+                    message: "3 or more token accounts are impacted by this transaction. Any token account listed as writable can be emptied by the transaction, is this okay?",
+                });
+            }
+            let possibleCNftChanges = [];
+            if (checkCNfts) {
+                const possibleMerkles = new Set(writableAccounts
+                    .filter((acc) => acc.name === "Merkle Tree")
+                    .map((a) => a.address.toBase58()));
+                possibleCNftChanges = (assets || []).filter((item) => item.compression.tree && possibleMerkles.has(item.compression.tree));
+            }
+            result = {
+                instructions,
+                logs,
+                solFee,
+                priorityFee,
+                insufficientFunds: false,
+                explorerLink,
+                balanceChanges,
+                possibleCNftChanges,
+                writableAccounts,
+                rawSimulation: simulatedTxn.value,
+                warnings,
+            };
         }
-        const possibleMerkles = new Set(writableAccounts
-            .filter((acc) => acc.name === "Merkle Tree")
-            .map((a) => a.address.toBase58()));
-        possibleCNftChanges = (assets || []).filter((item) => item.compression.tree && possibleMerkles.has(item.compression.tree));
+        results.push(result);
     }
-    return {
-        instructions,
-        logs,
-        solFee,
-        priorityFee,
-        insufficientFunds: false,
-        explorerLink,
-        balanceChanges,
-        possibleCNftChanges,
-        writableAccounts,
-        rawSimulation: simulatedTxn.value,
-        warnings,
-    };
+    return results;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isInsufficientBal(e) {
@@ -241,7 +369,7 @@ export function isInsufficientBal(e) {
         e.toString().includes('"Custom":1') ||
         e.InstructionError?.[1]?.Custom === 1);
 }
-async function parseInstructions({ idls, instructions, }) {
+function parseInstructions({ idls, instructions, }) {
     return instructions.map((ix) => {
         const idl = idls[ix.programId.toBase58()];
         if (idl) {
@@ -290,7 +418,7 @@ function decodeIdl(account) {
         // Ignore, not a valid IDL
     }
 }
-export async function getDetailedWritableAccounts({ connection, accounts, idls, }) {
+export function getDetailedWritableAccountsWithoutTM({ accounts, idls, }) {
     const uniqueTokens = new Set();
     const withoutMetadata = accounts.map(({ address, pre, post }) => {
         let name = "Unknown";
@@ -298,12 +426,7 @@ export async function getDetailedWritableAccounts({ connection, accounts, idls,
         let preParsed = null;
         let postParsed = null;
         let accountOwner = undefined;
-        const postData = post &&
-            Buffer.from(
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            post.data[0], 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            post.data[1]);
+        const postData = post && post.data;
         const postAccount = post && postData
             ? {
                 executable: post.executable,
@@ -336,12 +459,11 @@ export async function getDetailedWritableAccounts({ connection, accounts, idls,
                 if (owner) {
                     const idl = idls[owner.toBase58()];
                     if (idl) {
-                        ({ parsed: preParsed, type } = decodeIdlStruct(idl, pre) || {
-                            type: "No Published IDL",
-                        });
-                        ({ parsed: postParsed, type } = decodeIdlStruct(idl, postAccount) || {
-                            type: "No Published IDL",
-                        });
+                        const decodedPre = decodeIdlStruct(idl, pre);
+                        const decodedPost = decodeIdlStruct(idl, postAccount);
+                        preParsed = decodedPre?.parsed;
+                        postParsed = decodedPost?.parsed;
+                        type = decodedPre?.type || decodedPost?.type || "Unknown";
                         name = type;
                     }
                 }
@@ -383,42 +505,10 @@ export async function getDetailedWritableAccounts({ connection, accounts, idls,
         };
     });
     const tokens = [...uniqueTokens].map((t) => new PublicKey(t));
-    const metadatas = (await fetchMetadatas(connection, tokens)).reduce((acc, m, index) => {
-        if (m) {
-            acc[tokens[index].toBase58()] = m;
-        }
-        return acc;
-    }, {});
-    return withoutMetadata.map((acc) => {
-        let name = acc.name;
-        let metadata;
-        const type = acc.pre.type || acc.post.type;
-        // If token, get the name based on the metadata
-        if (type === "Mint") {
-            metadata = metadatas[acc.address.toBase58()];
-            if (metadata) {
-                name = `${metadata.symbol} Mint`;
-            }
-            else {
-                name = `Unknown Mint`;
-            }
-        }
-        else if (type === "TokenAccount") {
-            metadata =
-                metadatas[(acc.pre.parsed?.mint || acc.post.parsed?.mint).toBase58()];
-            if (metadata) {
-                name = `${metadata.symbol} Token Account`;
-            }
-            else {
-                name = `Unknown Token Account`;
-            }
-        }
-        return {
-            ...acc,
-            name,
-            metadata,
-        };
-    });
+    return {
+        withoutMetadata,
+        tokens,
+    };
 }
 function decodeIdlStruct(idl, account) {
     if (!account) {
@@ -478,51 +568,64 @@ export function getMetadataId(mint) {
 }
 export async function fetchMetadatas(connection, tokens) {
     const metadatas = tokens.map(getMetadataId);
-    const all = await connection.getMultipleAccountsInfo([
-        ...metadatas,
-        ...tokens,
-    ]);
+    const all = await getMultipleAccounts({
+        keys: [...metadatas, ...tokens],
+        connection,
+    });
     const metadataAccounts = all.slice(0, metadatas.length);
     const mintAccounts = all.slice(metadatas.length, metadatas.length * 2);
     return metadataAccounts.map((acc, index) => {
-        const mint = unpackMint(tokens[index], mintAccounts[index]);
-        if (acc) {
-            const collectable = Metadata.fromAccountInfo(acc)[0];
+        try {
+            const mint = unpackMint(tokens[index], mintAccounts[index]);
+            if (acc) {
+                const collectable = Metadata.fromAccountInfo(acc)[0];
+                return {
+                    name: collectable.data.name.replace(/\0/g, ""),
+                    symbol: collectable.data.symbol.replace(/\0/g, ""),
+                    uri: collectable.data.uri.replace(/\0/g, ""),
+                    decimals: mint.decimals,
+                    mint: tokens[index],
+                };
+            }
             return {
-                name: collectable.data.name.replace(/\0/g, ""),
-                symbol: collectable.data.symbol.replace(/\0/g, ""),
-                uri: collectable.data.uri.replace(/\0/g, ""),
-                decimals: mint.decimals,
                 mint: tokens[index],
+                decimals: mint.decimals,
             };
         }
-        return {
-            mint: tokens[index],
-            decimals: mint.decimals,
-        };
+        catch (e) {
+            // Ignore, not a valid mint
+        }
+        return null;
     });
 }
 const truthy = (value) => !!value;
-async function isBurnHotspot(connection, ix) {
+async function isBurnHotspot(connection, ix, assets) {
     if (ix.raw.programId.equals(BUBBLEGUM_PROGRAM_ID) &&
         ix.parsed?.name === "burn") {
-        const tree = ix.parsed?.accounts.find((acc) => acc.name === "merkleTree")?.pubkey;
+        const tree = ix.parsed?.accounts.find((acc) => acc.name === "Merkle Tree")?.pubkey;
         if (tree) {
-            const assetId = await getLeafAssetId(tree, ix.parsed?.data[4]);
-            const assetResponse = await axios.post(connection.rpcEndpoint, {
-                jsonrpc: "2.0",
-                method: "getAsset",
-                id: "get-asset-op-1",
-                params: {
-                    id: assetId.toBase58(),
-                },
-                headers: {
-                    "Cache-Control": "no-cache",
-                    Pragma: "no-cache",
-                    Expires: "0",
-                },
-            });
-            const asset = assetResponse.data.result;
+            const index = ix.parsed?.data?.index;
+            const assetId = await getLeafAssetId(tree, new BN(index));
+            let asset;
+            if (assets) {
+                asset = assets.find(a => a.id === assetId.toBase58());
+            }
+            else {
+                const assetResponse = await axios.post(connection.rpcEndpoint, {
+                    jsonrpc: "2.0",
+                    method: "getAsset",
+                    id: "get-asset-op-1",
+                    params: {
+                        id: assetId.toBase58(),
+                    },
+                    headers: {
+                        "Cache-Control": "no-cache",
+                        Pragma: "no-cache",
+                        Expires: "0",
+                    },
+                });
+                asset = assetResponse.data.result;
+            }
             return (asset &&
                 asset.creators[0]?.address == HELIUM_ENTITY_CREATOR.toBase58() &&
                 asset.creators[0]?.verified);