@helium/sus 0.6.2-next.34

package/lib/cjs/index.js

@@ -0,0 +1,699 @@
+"use strict";
+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.fetchMetadatas = exports.getMetadataId = exports.getDetailedWritableAccountsWithoutTM = exports.isInsufficientBal = exports.sus = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const idl_1 = require("@coral-xyz/anchor/dist/cjs/idl");
+const bytes_1 = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const mpl_bubblegum_1 = require("@metaplex-foundation/mpl-bubblegum");
+const mpl_token_metadata_1 = require("@metaplex-foundation/mpl-token-metadata");
+const sha256_1 = require("@noble/hashes/sha256");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const axios_1 = __importDefault(require("axios"));
+const pako_1 = require("pako");
+const BUBBLEGUM_PROGRAM_ID = new web3_js_1.PublicKey("BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY");
+const ACCOUNT_COMPRESSION_PROGRAM_ID = new web3_js_1.PublicKey("cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK");
+function getAccountKeys({ connection, transaction, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addressLookupTableAccounts = [];
+        const { addressTableLookups } = transaction.message;
+        if (addressTableLookups.length > 0) {
+            // eslint-disable-next-line no-restricted-syntax
+            for (const addressTableLookup of addressTableLookups) {
+                // eslint-disable-next-line no-await-in-loop
+                const result = yield (connection === null || connection === void 0 ? void 0 : connection.getAddressLookupTable(addressTableLookup.accountKey));
+                if (result === null || result === void 0 ? void 0 : result.value) {
+                    addressLookupTableAccounts.push(result === null || result === void 0 ? void 0 : result.value);
+                }
+            }
+        }
+        return transaction.message.getAccountKeys({
+            addressLookupTableAccounts,
+        });
+    });
+}
+function getMultipleAccounts({ connection, keys, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 = yield connection.getMultipleAccountsInfo(batchKeys);
+            results.push(...batchResults);
+        }
+        return results;
+    });
+}
+function sus({ connection, wallet, serializedTransactions, 
+/// CNFT specific params
+checkCNfts = false, extraSearchAssetParams, cNfts, 
+// Cluster for explorer
+cluster = "mainnet-beta", accountBlacklist, }) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        let assets = cNfts;
+        if (checkCNfts) {
+            if (!assets) {
+                const assetsResponse = yield axios_1.default.post(connection.rpcEndpoint, {
+                    jsonrpc: "2.0",
+                    method: "searchAssets",
+                    id: "get-assets-op-1",
+                    params: Object.assign({ 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 = (_a = assetsResponse.data.result) === null || _a === void 0 ? void 0 : _a.items;
+            }
+        }
+        const warningsByTx = serializedTransactions.map(() => []);
+        const transactions = serializedTransactions.map((t) => web3_js_1.VersionedTransaction.deserialize(t));
+        const accountKeysByTx = yield Promise.all(transactions.map((transaction) => getAccountKeys({ connection, transaction })));
+        const simulationAccountsByTx = accountKeysByTx.map((accountKeys, txIndex) => [
+            ...new Set(accountKeys.staticAccountKeys
+                .filter((_, index) => transactions[txIndex].message.isAccountWritable(index))
+                .concat(accountKeys.accountKeysFromLookups
+                ? // Only writable accounts will contribute to balance changes
+                    accountKeys.accountKeysFromLookups.writable
+                : [])),
+        ].filter((a) => !(accountBlacklist === null || accountBlacklist === void 0 ? void 0 : accountBlacklist.has(a.toBase58()))));
+        const allAccounts = [...new Set(simulationAccountsByTx.flat())];
+        const fetchedAccounts = yield getMultipleAccounts({
+            connection,
+            keys: allAccounts,
+        });
+        const fetchedAccountsByAddr = fetchedAccounts.reduce((acc, account, index) => {
+            acc[allAccounts[index].toBase58()] = account;
+            return acc;
+        }, {});
+        let { blockhash } = yield (connection === null || connection === void 0 ? void 0 : connection.getLatestBlockhash("finalized"));
+        const simulatedTxs = [];
+        // Linearly simulate txs so as not to hit rate limits
+        for (const [index, transaction] of transactions.entries()) {
+            let simulatedTxn = null;
+            let tries = 0;
+            // Retry until we stop getting blockhashNotFound
+            blockhashLoop: while (true) {
+                transaction.message.recentBlockhash = blockhash;
+                simulatedTxn = yield connection.simulateTransaction(transaction, {
+                    accounts: {
+                        encoding: "base64",
+                        addresses: ((_b = simulationAccountsByTx[index]) === null || _b === void 0 ? void 0 : _b.map((account) => account.toBase58())) || [],
+                    },
+                });
+                if (isBlockhashNotFound(simulatedTxn)) {
+                    ({ blockhash } = yield (connection === null || connection === void 0 ? void 0 : connection.getLatestBlockhash("finalized")));
+                    tries++;
+                    if (tries >= 5) {
+                        simulatedTxs.push(simulatedTxn);
+                        break blockhashLoop;
+                    }
+                }
+                else {
+                    simulatedTxs.push(simulatedTxn);
+                    break blockhashLoop;
+                }
+            }
+        }
+        const fullAccountsByTxn = simulationAccountsByTx.map((simulationAccounts, transactionIndex) => {
+            const simulatedTxn = simulatedTxs[transactionIndex];
+            return simulationAccounts.map((account, index) => {
+                var _a;
+                const post = (_a = simulatedTxn.value.accounts) === null || _a === void 0 ? void 0 : _a[index];
+                return {
+                    address: account,
+                    post: post
+                        ? Object.assign(Object.assign({}, post), { owner: new web3_js_1.PublicKey(post.owner), data: Buffer.from(post.data[0], post.data[1]) }) : undefined,
+                    pre: fetchedAccountsByAddr[account.toBase58()],
+                };
+            });
+        });
+        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) => { var _a; return ((_a = acc === null || acc === void 0 ? void 0 : acc.pre) === null || _a === void 0 ? void 0 : _a.owner) || (acc.post ? new web3_js_1.PublicKey(acc.post.owner) : null); })
+            .concat(...instructionProgramIds)
+            .filter(truthy);
+        const idlKeys = programKeys.map(getIdlKey);
+        const idls = (yield getMultipleAccounts({ connection, keys: idlKeys }))
+            .map((acc, index) => {
+            if (acc) {
+                return {
+                    program: programKeys[index],
+                    idl: decodeIdl(acc),
+                };
+            }
+        })
+            .filter(truthy)
+            .reduce((acc, { program, idl }) => {
+            if (idl) {
+                acc[program.toBase58()] = idl;
+            }
+            return acc;
+        }, {});
+        const writableAccountsByTxRaw = fullAccountsByTxn.map((accounts) => getDetailedWritableAccountsWithoutTM({
+            accounts,
+            idls,
+        }));
+        const tokens = [
+            ...new Set(writableAccountsByTxRaw.flatMap((w) => w.tokens).map((t) => t.toBase58())),
+        ].map((t) => new web3_js_1.PublicKey(t));
+        const metadatas = (yield 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) => {
+                var _a, _b;
+                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[(((_a = acc.pre.parsed) === null || _a === void 0 ? void 0 : _a.mint) || ((_b = acc.post.parsed) === null || _b === void 0 ? void 0 : _b.mint)).toBase58()];
+                    if (metadata) {
+                        name = `${metadata.symbol} Token Account`;
+                    }
+                    else {
+                        name = `Unknown Token Account`;
+                    }
+                }
+                return Object.assign(Object.assign({}, acc), { name,
+                    metadata });
+            });
+            writableAccounts.forEach((acc) => {
+                var _a, _b, _c, _d;
+                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 web3_js_1.PublicKey("11111111111111111111111111111111");
+                const postOwner = ((_a = acc.post.account) === null || _a === void 0 ? void 0 : _a.owner) || sysProg;
+                const preOwner = ((_b = acc.pre.account) === null || _b === void 0 ? void 0 : _b.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 ${(_d = (_c = acc.post.parsed) === null || _c === void 0 ? void 0 : _c.owner) === null || _d === void 0 ? void 0 : _d.toBase58()}. This gives that wallet full custody of these tokens.`,
+                        account: acc.address,
+                    });
+                }
+            });
+            return writableAccounts;
+        });
+        const instructionsByTx = yield Promise.all(transactions.map((transaction, index) => __awaiter(this, void 0, void 0, function* () {
+            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) => { var _a; return ((_a = ix.parsed) === null || _a === void 0 ? void 0 : _a.name) === "ledgerTransferPositionV0"; })) {
+                warningsByTx[index].push({
+                    severity: "critical",
+                    shortMessage: "Theft of Locked HNT",
+                    message: "This transaction is attempting to steal your locked HNT positions",
+                });
+            }
+            if (instructions.some((ix) => {
+                var _a, _b;
+                return ((_a = ix.parsed) === null || _a === void 0 ? void 0 : _a.name) === "updateDestinationV0" ||
+                    ((_b = ix.parsed) === null || _b === void 0 ? void 0 : _b.name) === "updateCompressionDestinationV0";
+            })) {
+                warningsByTx[index].push({
+                    severity: "warning",
+                    shortMessage: "Rewards Destination Changed",
+                    message: "This transaction will change the destination wallet of your mining rewards",
+                });
+            }
+            if ((yield 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 = Buffer.from(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 === null || simulatedTxn === void 0 ? void 0 : simulatedTxn.value.err) {
+                warnings.push({
+                    severity: "critical",
+                    shortMessage: "Simulation Failed",
+                    message: "Transaction failed in simulation",
+                });
+                result = {
+                    instructions,
+                    error: simulatedTxn.value.err,
+                    logs,
+                    solFee: 0,
+                    priorityFee: 0,
+                    insufficientFunds: isInsufficientBal(simulatedTxn === null || simulatedTxn === void 0 ? void 0 : simulatedTxn.value.err),
+                    explorerLink,
+                    balanceChanges: [],
+                    possibleCNftChanges: [],
+                    writableAccounts,
+                    rawSimulation: simulatedTxn.value,
+                    warnings,
+                };
+            }
+            else {
+                let solFee = ((transaction === null || transaction === void 0 ? void 0 : transaction.signatures.length) || 1) * 5000;
+                let priorityFee = 0;
+                const fee = (yield (connection === null || connection === void 0 ? void 0 : connection.getFeeForMessage(transaction.message, "confirmed")))
+                    .value || solFee;
+                priorityFee = fee - solFee;
+                const balanceChanges = writableAccounts
+                    .map((acc) => {
+                    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+                    const type = (acc.pre.type !== "Unknown" && acc.pre.type) ||
+                        (acc.post.type !== "Unknown" && acc.post.type);
+                    switch (type) {
+                        case "TokenAccount":
+                            if (((_a = acc.post.parsed) === null || _a === void 0 ? void 0 : _a.delegate) && !((_b = acc.pre.parsed) === null || _b === void 0 ? void 0 : _b.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 ${(_d = (_c = acc.post.parsed) === null || _c === void 0 ? void 0 : _c.owner) === null || _d === void 0 ? void 0 : _d.toBase58()}. This gives that wallet full custody of these tokens.`,
+                                    account: acc.address,
+                                });
+                            }
+                            return {
+                                owner: ((_e = acc.post.parsed) === null || _e === void 0 ? void 0 : _e.owner) || ((_f = acc.pre.parsed) === null || _f === void 0 ? void 0 : _f.owner),
+                                address: acc.address,
+                                amount: (((_g = acc.post.parsed) === null || _g === void 0 ? void 0 : _g.amount) || BigInt(0)) -
+                                    (((_h = acc.pre.parsed) === null || _h === void 0 ? void 0 : _h.amount) || BigInt(0)),
+                                metadata: acc.metadata,
+                            };
+                        case "NativeAccount":
+                            return {
+                                owner: acc.address,
+                                address: acc.address,
+                                amount: BigInt((((_j = acc.post.account) === null || _j === void 0 ? void 0 : _j.lamports) || 0) -
+                                    (((_k = acc.pre.account) === null || _k === void 0 ? void 0 : _k.lamports) || 0)),
+                                metadata: {
+                                    mint: spl_token_1.NATIVE_MINT,
+                                    decimals: 9,
+                                    name: "SOL",
+                                    symbol: "SOL",
+                                },
+                            };
+                        default:
+                            return null;
+                    }
+                })
+                    .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,
+                };
+            }
+            results.push(result);
+        }
+        return results;
+    });
+}
+exports.sus = sus;
+function isBlockhashNotFound(simulatedTxn) {
+    var _a;
+    return ((_a = simulatedTxn === null || simulatedTxn === void 0 ? void 0 : simulatedTxn.value.err) === null || _a === void 0 ? void 0 : _a.toString()) === "BlockhashNotFound";
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isInsufficientBal(e) {
+    var _a, _b;
+    return (e.toString().includes("Insufficient Balance") ||
+        e.toString().includes('"Custom":1') ||
+        ((_b = (_a = e.InstructionError) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.Custom) === 1);
+}
+exports.isInsufficientBal = isInsufficientBal;
+function parseInstructions({ idls, instructions, }) {
+    return instructions.map((ix) => {
+        const idl = idls[ix.programId.toBase58()];
+        if (idl) {
+            try {
+                const coder = new anchor_1.BorshInstructionCoder(idl);
+                const parsed = coder.decode(ix.data, "base58");
+                if (parsed) {
+                    const formatted = coder.format(parsed, ix.accounts);
+                    if (formatted) {
+                        return {
+                            parsed: {
+                                name: parsed.name,
+                                programName: idl.name,
+                                data: parsed.data,
+                                accounts: formatted.accounts,
+                            },
+                            raw: ix,
+                        };
+                    }
+                }
+            }
+            catch (e) {
+                // Ignore, not a valid ix
+            }
+        }
+        return { raw: ix };
+    });
+}
+function getIdlKey(programId) {
+    const base = web3_js_1.PublicKey.findProgramAddressSync([], programId)[0];
+    const buffer = Buffer.concat([
+        base.toBuffer(),
+        Buffer.from("anchor:idl"),
+        programId.toBuffer(),
+    ]);
+    const publicKeyBytes = (0, sha256_1.sha256)(buffer);
+    return new web3_js_1.PublicKey(publicKeyBytes);
+}
+function decodeIdl(account) {
+    try {
+        const idlData = (0, idl_1.decodeIdlAccount)(Buffer.from(account.data.subarray(8)));
+        const inflatedIdl = (0, pako_1.inflate)(idlData.data);
+        return JSON.parse(bytes_1.utf8.decode(inflatedIdl));
+    }
+    catch (e) {
+        // Ignore, not a valid IDL
+    }
+}
+function getDetailedWritableAccountsWithoutTM({ accounts, idls, }) {
+    const uniqueTokens = new Set();
+    const withoutMetadata = accounts.map(({ address, pre, post }) => {
+        let name = "Unknown";
+        let type = "Unknown";
+        let preParsed = null;
+        let postParsed = null;
+        let accountOwner = undefined;
+        const postData = post && post.data;
+        const postAccount = post && postData
+            ? {
+                executable: post.executable,
+                owner: new web3_js_1.PublicKey(post.owner),
+                lamports: post.lamports,
+                data: postData,
+                rentEpoch: post.rentEpoch,
+            }
+            : null;
+        const owner = (pre === null || pre === void 0 ? void 0 : pre.owner) || (post ? new web3_js_1.PublicKey(post.owner) : null);
+        switch (owner === null || owner === void 0 ? void 0 : owner.toBase58()) {
+            case ACCOUNT_COMPRESSION_PROGRAM_ID.toBase58():
+                name = "Merkle Tree";
+                type = "MerkleTree";
+                break;
+            case web3_js_1.SystemProgram.programId.toBase58():
+                name = "Native SOL Account";
+                type = "NativeAccount";
+                accountOwner = address;
+                break;
+            case spl_token_1.TOKEN_2022_PROGRAM_ID.toBase58():
+                ({ parsed: preParsed, type } = decodeTokenStruct(address, pre, spl_token_1.TOKEN_2022_PROGRAM_ID) || { type });
+                ({ parsed: postParsed, type } = decodeTokenStruct(address, postAccount, spl_token_1.TOKEN_2022_PROGRAM_ID) || { type });
+                break;
+            case spl_token_1.TOKEN_PROGRAM_ID.toBase58():
+                ({ parsed: preParsed, type } = decodeTokenStruct(address, pre, spl_token_1.TOKEN_PROGRAM_ID) || { type });
+                ({ parsed: postParsed, type } = decodeTokenStruct(address, postAccount, spl_token_1.TOKEN_PROGRAM_ID) || { type });
+                break;
+            default:
+                if (owner) {
+                    const idl = idls[owner.toBase58()];
+                    if (idl) {
+                        const decodedPre = decodeIdlStruct(idl, pre);
+                        const decodedPost = decodeIdlStruct(idl, postAccount);
+                        preParsed = decodedPre === null || decodedPre === void 0 ? void 0 : decodedPre.parsed;
+                        postParsed = decodedPost === null || decodedPost === void 0 ? void 0 : decodedPost.parsed;
+                        type =
+                            ((decodedPre === null || decodedPre === void 0 ? void 0 : decodedPre.type) !== "Unknown" && (decodedPre === null || decodedPre === void 0 ? void 0 : decodedPre.type)) ||
+                                ((decodedPost === null || decodedPost === void 0 ? void 0 : decodedPost.type) !== "Unknown" && (decodedPost === null || decodedPost === void 0 ? void 0 : decodedPost.type)) ||
+                                "Unknown";
+                        name = type;
+                    }
+                }
+                break;
+        }
+        // If token, get the name based on the metadata
+        if (new Set([
+            spl_token_1.TOKEN_2022_PROGRAM_ID.toBase58(),
+            spl_token_1.TOKEN_PROGRAM_ID.toBase58(),
+        ]).has((owner === null || owner === void 0 ? void 0 : owner.toBase58()) || "")) {
+            if (type === "Mint") {
+                uniqueTokens.add(address.toBase58());
+            }
+            else if (type === "TokenAccount") {
+                const mint = ((preParsed === null || preParsed === void 0 ? void 0 : preParsed.mint) || (postParsed === null || postParsed === void 0 ? void 0 : postParsed.mint)).toBase58();
+                accountOwner = (preParsed === null || preParsed === void 0 ? void 0 : preParsed.owner) || (postParsed === null || postParsed === void 0 ? void 0 : postParsed.owner);
+                uniqueTokens.add(mint);
+            }
+        }
+        return {
+            address,
+            name,
+            owner: accountOwner,
+            pre: {
+                type,
+                account: pre || null,
+                parsed: preParsed,
+            },
+            post: {
+                type,
+                account: post || null,
+                parsed: postParsed,
+            },
+            changedInSimulation: pre && postData
+                ? !pre.data.equals(postData) ||
+                    pre.lamports != post.lamports ||
+                    !pre.owner.equals(new web3_js_1.PublicKey(post.owner))
+                : true,
+        };
+    });
+    const tokens = [...uniqueTokens].map((t) => new web3_js_1.PublicKey(t));
+    return {
+        withoutMetadata,
+        tokens,
+    };
+}
+exports.getDetailedWritableAccountsWithoutTM = getDetailedWritableAccountsWithoutTM;
+function decodeIdlStruct(idl, account) {
+    var _a, _b;
+    if (!account) {
+        return null;
+    }
+    try {
+        const coder = new anchor_1.BorshAccountsCoder(idl);
+        const descriminator = account.data.slice(0, 8);
+        const type = (_b = (_a = idl.accounts) === null || _a === void 0 ? void 0 : _a.find((account) => anchor_1.BorshAccountsCoder.accountDiscriminator(account.name).equals(descriminator))) === null || _b === void 0 ? void 0 : _b.name;
+        if (type) {
+            return {
+                type,
+                parsed: coder.decode(type, account.data),
+            };
+        }
+    }
+    catch (e) {
+        // Ignore, not a valid account
+    }
+    return null;
+}
+function decodeTokenStruct(address, account, programId) {
+    if (!account) {
+        return null;
+    }
+    try {
+        return {
+            type: "TokenAccount",
+            parsed: (0, spl_token_1.unpackAccount)(address, account, programId),
+        };
+    }
+    catch (e) {
+        // Not an account
+    }
+    try {
+        return {
+            type: "Mint",
+            parsed: (0, spl_token_1.unpackMint)(address, account, programId),
+        };
+    }
+    catch (e) {
+        // Not an account
+    }
+    try {
+        return {
+            type: "Multisig",
+            parsed: (0, spl_token_1.unpackMultisig)(address, account, programId),
+        };
+    }
+    catch (e) {
+        // Not an account
+    }
+    return null;
+}
+function getMetadataId(mint) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("metadata", "utf-8"), mpl_token_metadata_1.PROGRAM_ID.toBuffer(), mint.toBuffer()], mpl_token_metadata_1.PROGRAM_ID)[0];
+}
+exports.getMetadataId = getMetadataId;
+function fetchMetadatas(connection, tokens) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const metadatas = tokens.map(getMetadataId);
+        const all = yield 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) => {
+            try {
+                const mint = (0, spl_token_1.unpackMint)(tokens[index], mintAccounts[index]);
+                if (acc) {
+                    const collectable = mpl_token_metadata_1.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 {
+                    mint: tokens[index],
+                    decimals: mint.decimals,
+                };
+            }
+            catch (e) {
+                // Ignore, not a valid mint
+            }
+            return null;
+        });
+    });
+}
+exports.fetchMetadatas = fetchMetadatas;
+const truthy = (value) => !!value;
+function isBurnHotspot(connection, ix, assets) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (ix.raw.programId.equals(BUBBLEGUM_PROGRAM_ID) &&
+            ((_a = ix.parsed) === null || _a === void 0 ? void 0 : _a.name) === "burn") {
+            const tree = (_c = (_b = ix.parsed) === null || _b === void 0 ? void 0 : _b.accounts.find((acc) => acc.name === "Merkle Tree")) === null || _c === void 0 ? void 0 : _c.pubkey;
+            if (tree) {
+                const index = (_e = (_d = ix.parsed) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.index;
+                const assetId = yield (0, mpl_bubblegum_1.getLeafAssetId)(tree, new anchor_1.BN(index));
+                let asset;
+                if (assets) {
+                    asset = assets.find(a => a.id === assetId.toBase58());
+                }
+                else {
+                    const assetResponse = yield axios_1.default.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 &&
+                    ((_f = asset.creators[0]) === null || _f === void 0 ? void 0 : _f.address) == HELIUM_ENTITY_CREATOR.toBase58() &&
+                    ((_g = asset.creators[0]) === null || _g === void 0 ? void 0 : _g.verified));
+            }
+        }
+        return false;
+    });
+}
+const DAO = web3_js_1.PublicKey.findProgramAddressSync([
+    Buffer.from("dao", "utf-8"),
+    new web3_js_1.PublicKey("hntyVP6YFm1Hg25TN9WGLqM12b8TQmcknKrdu1oxWux").toBuffer(),
+], new web3_js_1.PublicKey("hdaoVTCqhfHHo75XdAMxBKdUqvq1i5bF23sisBqVgGR"))[0];
+const HELIUM_ENTITY_CREATOR = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("entity_creator", "utf-8"), DAO.toBuffer()], new web3_js_1.PublicKey("hemjuPXBpNvggtaUnN1MwT3wrdhttKEfosTcc2P9Pg8"))[0];
+//# sourceMappingURL=index.js.map