txray 0.0.0-stage → 0.1.0

package/dist/domain/analyze.js

@@ -0,0 +1,161 @@
+import { transactionSchema } from "./schema.js";
+import { diagnose } from "./errors.js";
+import { parseLogs } from "./logs.js";
+import { programName, decodeInstruction, formatLamports, COMPUTE, } from "./instructions.js";
+export function analyzeTransaction(input, context) {
+    const raw = transactionSchema.parse(input);
+    const meta = raw.meta;
+    const message = raw.transaction.message;
+    const status = meta === null ? "unknown" : meta.err === null ? "succeeded" : "failed";
+    const diagnosis = diagnose(meta?.err ?? null, status);
+    const warnings = [];
+    if (meta === null)
+        warnings.push("Transaction metadata is missing. Outcome, fee and compute usage are unknown.");
+    if (raw.version === undefined)
+        warnings.push("Transaction version was not provided. Compute configuration is not inferred.");
+    if (raw.version === 1 && !message.transactionConfig)
+        warnings.push("The v1 transaction config is missing. Requested compute and priority fee are unknown.");
+    const keys = [
+        ...message.accountKeys,
+        ...(meta?.loadedAddresses?.writable ?? []),
+        ...(meta?.loadedAddresses?.readonly ?? []),
+    ];
+    const resolve = (index) => {
+        const key = keys[index];
+        if (!key && !warnings.some((w) => w.startsWith("Some account")))
+            warnings.push("Some account addresses could not be resolved. Lookup-table addresses may be missing.");
+        return key ?? null;
+    };
+    if (diagnosis.instructionIndex !== null &&
+        diagnosis.instructionIndex >= message.instructions.length) {
+        warnings.push("The reported failed instruction index is outside the instruction list. Its location is unknown.");
+        diagnosis.instructionIndex = null;
+    }
+    let requestedLimit = null;
+    let price = null;
+    let limitCount = 0;
+    let priceCount = 0;
+    const instructions = message.instructions.map((instruction, index) => {
+        const programId = resolve(instruction.programIdIndex);
+        const decoded = decodeInstruction(programId, instruction.data);
+        if (raw.version === "legacy" || raw.version === 0) {
+            if (decoded.limit !== null) {
+                requestedLimit = decoded.limit;
+                limitCount++;
+            }
+            if (decoded.price !== null) {
+                price = decoded.price;
+                priceCount++;
+            }
+        }
+        const state = status === "unknown"
+            ? "unknown"
+            : status === "succeeded"
+                ? "succeeded"
+                : diagnosis.instructionIndex === null
+                    ? "unknown"
+                    : index < diagnosis.instructionIndex
+                        ? "rolled_back"
+                        : index === diagnosis.instructionIndex
+                            ? "failed"
+                            : "not_run";
+        return {
+            index,
+            number: index + 1,
+            programId,
+            programName: programName(programId),
+            accounts: instruction.accounts.map(resolve),
+            data: instruction.data,
+            status: state,
+            action: raw.version === 1 && programId === COMPUTE
+                ? "Compute Budget instruction (configuration ignored in v1)"
+                : decoded.action,
+            inner: (meta?.innerInstructions
+                ?.filter((group) => group.index === index)
+                .flatMap((group) => group.instructions) ?? []).map((inner) => {
+                const id = resolve(inner.programIdIndex);
+                return {
+                    programId: id,
+                    programName: programName(id),
+                    accounts: inner.accounts.map(resolve),
+                    data: inner.data,
+                    stackHeight: inner.stackHeight ?? null,
+                    action: decodeInstruction(id, inner.data).action,
+                };
+            }),
+        };
+    });
+    if (limitCount > 1 || priceCount > 1) {
+        warnings.push("Duplicate compute settings were recorded. Requested limits and prices are not inferred.");
+        requestedLimit = null;
+        price = null;
+    }
+    if (raw.version === 1)
+        requestedLimit = message.transactionConfig?.computeUnitLimit ?? null;
+    diagnosis.programId =
+        diagnosis.instructionIndex === null
+            ? null
+            : (instructions[diagnosis.instructionIndex]?.programId ?? null);
+    const logs = meta?.logMessages ? parseLogs(meta.logMessages) : null;
+    if (logs === null)
+        warnings.push("Execution logs are unavailable. No log-based execution sequence is inferred.");
+    if (logs?.some((log) => log.kind === "truncated"))
+        warnings.push("The runtime truncated its logs. This execution log is incomplete.");
+    if (meta?.computeUnitsConsumed == null)
+        warnings.push("Compute consumption was not reported. Missing compute is not zero.");
+    const fee = {
+        lamports: meta?.fee ?? null,
+        sol: meta ? formatLamports(meta.fee) : null,
+        baseLamports: null,
+        requestedPriorityLamports: raw.version === 1
+            ? (message.transactionConfig?.priorityFee ?? null)
+            : null,
+        requestedMicroLamportsPerCu: price,
+        payer: message.accountKeys[0] ?? null,
+    };
+    const report = {
+        schemaVersion: 1,
+        signature: context.signature,
+        network: context.network,
+        source: context.source,
+        exampleId: context.exampleId ?? null,
+        checkedAt: new Date().toISOString(),
+        slot: raw.slot,
+        blockTime: raw.blockTime ?? null,
+        version: raw.version ?? "unknown",
+        status,
+        diagnosis,
+        fee,
+        compute: {
+            consumed: meta?.computeUnitsConsumed ?? null,
+            costUnits: meta?.costUnits ?? null,
+            requestedLimit,
+        },
+        instructions,
+        logs,
+        warnings,
+        raw,
+        summaryText: "",
+    };
+    report.summaryText = [
+        `txray | ${context.source === "example" ? "Fictional offline example" : "Live RPC inspection"}`,
+        `Network: ${context.network}`,
+        `Signature: ${context.signature}`,
+        `Outcome: ${status}`,
+        `Diagnosis: ${diagnosis.title}`,
+        diagnosis.explanation,
+        `Failed instruction: ${diagnosis.instructionIndex === null ? "Not identified" : `#${diagnosis.instructionIndex + 1} (RPC index ${diagnosis.instructionIndex})`}`,
+        `Top-level program: ${diagnosis.programId ?? "Not identified"}`,
+        `Recorded fee: ${fee.sol === null ? "Not reported" : `${fee.sol} SOL (${fee.lamports} lamports)`}`,
+        "Base/priority fee split: not provided by getTransaction",
+        `Compute used: ${report.compute.consumed ?? "Not reported"} CU`,
+        ...(status === "failed"
+            ? [
+                "Ordinary program state changes roll back on failure. Fees and durable-nonce advancement can persist.",
+            ]
+            : []),
+        ...warnings.map((w) => `Note: ${w}`),
+        `Observed: ${report.checkedAt}`,
+    ].join("\n");
+    return report;
+}

package/dist/domain/base58.js

@@ -0,0 +1,48 @@
+const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+export function fromBase58(value) {
+    if (value.length > 8192)
+        throw new Error("Base58 input too large");
+    let number = 0n;
+    for (const char of value) {
+        const index = alphabet.indexOf(char);
+        if (index < 0)
+            throw new Error("Invalid base58");
+        number = number * 58n + BigInt(index);
+    }
+    const bytes = [];
+    while (number > 0n) {
+        bytes.push(Number(number & 255n));
+        number >>= 8n;
+    }
+    let zeros = 0;
+    while (value[zeros] === "1")
+        zeros++;
+    return Uint8Array.from([
+        ...new Array(zeros).fill(0),
+        ...bytes.reverse(),
+    ]);
+}
+export function toBase58(bytes) {
+    let number = 0n;
+    for (const byte of bytes)
+        number = number * 256n + BigInt(byte);
+    let result = "";
+    while (number > 0n) {
+        result = alphabet[Number(number % 58n)] + result;
+        number /= 58n;
+    }
+    let zeros = 0;
+    while (zeros < bytes.length && bytes[zeros] === 0)
+        zeros++;
+    return "1".repeat(zeros) + result;
+}
+export function isSignature(value) {
+    if (value.length < 64 || value.length > 88)
+        return false;
+    try {
+        return fromBase58(value).length === 64;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/domain/errors.js

@@ -0,0 +1,192 @@
+export class TxrayError extends Error {
+    code;
+    status;
+    retryAfter;
+    constructor(code, message, status = 502, retryAfter) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.retryAfter = retryAfter;
+    }
+}
+const instructionErrors = {
+    InsufficientFunds: [
+        "Insufficient funds",
+        "An account did not have the funds required by this instruction. The record does not identify a specific account.",
+    ],
+    ComputationalBudgetExceeded: [
+        "Compute budget exceeded",
+        "Execution used more compute than allowed. Review the program and the requested compute limit before retrying.",
+    ],
+    ProgramFailedToComplete: [
+        "Program did not complete",
+        "The program stopped before completing. Inspect the runtime logs; this error alone does not establish why.",
+    ],
+    InvalidArgument: [
+        "Invalid argument",
+        "An instruction supplied an argument the program rejected.",
+    ],
+    InvalidInstructionData: [
+        "Invalid instruction data",
+        "The program could not accept the instruction data. Check its encoding and the program interface.",
+    ],
+    InvalidAccountData: [
+        "Invalid account data",
+        "The program rejected the contents or type of an account.",
+    ],
+    MissingRequiredSignature: [
+        "Missing required signature",
+        "An instruction required a signing authority that was not supplied.",
+    ],
+    IncorrectProgramId: [
+        "Incorrect program",
+        "The instruction was given an account owned by an unexpected program, or invoked the wrong program.",
+    ],
+    NotEnoughAccountKeys: [
+        "Missing account",
+        "The instruction did not supply all required accounts.",
+    ],
+    AccountAlreadyInitialized: [
+        "Account already initialized",
+        "The instruction tried to initialize an account that was already initialized.",
+    ],
+    UninitializedAccount: [
+        "Account not initialized",
+        "The program expected an initialized account.",
+    ],
+    PrivilegeEscalation: [
+        "Account privilege escalation",
+        "An inner call requested signing or writing permissions that its caller did not provide.",
+    ],
+    ReadonlyDataModified: [
+        "Read-only account modified",
+        "A program tried to modify data it was not allowed to write.",
+    ],
+    ArithmeticOverflow: [
+        "Arithmetic overflow",
+        "An arithmetic operation could not be represented within the allowed numeric range.",
+    ],
+    InvalidSeeds: [
+        "Invalid PDA seeds",
+        "The supplied seeds did not produce a valid program-derived address.",
+    ],
+};
+const transactionErrors = {
+    InsufficientFundsForFee: [
+        "Insufficient funds for fee",
+        "The fee payer could not cover the transaction fee.",
+    ],
+    InsufficientFundsForRent: [
+        "Insufficient funds for account storage",
+        "An account would not retain the minimum balance needed for its storage.",
+    ],
+    AccountNotFound: [
+        "Account not found",
+        "A required account was not available on the selected network.",
+    ],
+    ProgramAccountNotFound: [
+        "Program not found",
+        "A required program account was not available.",
+    ],
+    BlockhashNotFound: [
+        "Blockhash not found",
+        "The transaction blockhash was unavailable or expired.",
+    ],
+    InvalidProgramForExecution: [
+        "Program cannot execute",
+        "An instruction referenced an account that cannot execute as a program.",
+    ],
+    InvalidAccountIndex: [
+        "Invalid account index",
+        "An instruction referenced an account outside the transaction account list.",
+    ],
+    SignatureFailure: [
+        "Signature verification failed",
+        "At least one transaction signature did not verify.",
+    ],
+    AddressLookupTableNotFound: [
+        "Address lookup table not found",
+        "A referenced address lookup table was unavailable.",
+    ],
+    InvalidAddressLookupTableIndex: [
+        "Invalid lookup table index",
+        "The transaction referenced an entry outside its address lookup table.",
+    ],
+    MaxLoadedAccountsDataSizeExceeded: [
+        "Account data limit exceeded",
+        "The transaction needed more loaded account data than its configured limit.",
+    ],
+    UnsupportedVersion: [
+        "Unsupported transaction version",
+        "The transaction uses a version the runtime does not support.",
+    ],
+};
+export function diagnose(error, status) {
+    const result = {
+        title: status === "succeeded"
+            ? "Transaction succeeded"
+            : status === "unknown"
+                ? "Outcome unavailable"
+                : "Unknown transaction error",
+        explanation: status === "succeeded"
+            ? "All instructions completed. This records execution, not service quality or token safety."
+            : status === "unknown"
+                ? "The RPC did not provide transaction metadata, so the outcome cannot be determined."
+                : "The runtime returned an error txray does not recognize. The raw error is preserved below.",
+        known: status === "succeeded",
+        instructionIndex: null,
+        programId: null,
+        raw: error,
+    };
+    if (status !== "failed")
+        return result;
+    let detail = error;
+    let map = transactionErrors;
+    if (typeof error === "object" &&
+        error !== null &&
+        !Array.isArray(error) &&
+        "InstructionError" in error) {
+        const value = error.InstructionError;
+        if (Array.isArray(value) &&
+            value.length === 2 &&
+            Number.isSafeInteger(value[0]) &&
+            value[0] >= 0) {
+            result.instructionIndex = value[0];
+            detail = value[1];
+            map = instructionErrors;
+        }
+    }
+    if (typeof detail === "object" &&
+        detail !== null &&
+        !Array.isArray(detail) &&
+        "Custom" in detail) {
+        result.title = "Unknown program error";
+        result.explanation = `The program returned custom error ${JSON.stringify(detail.Custom)}. Its meaning is program-specific; txray has no verified definition for it. Read the program documentation and logs. Log text alone is not a verified error definition.`;
+        return result;
+    }
+    let code;
+    if (typeof detail === "string")
+        code = detail;
+    else if (map === transactionErrors &&
+        typeof detail === "object" &&
+        detail !== null &&
+        !Array.isArray(detail) &&
+        Object.keys(detail).length === 1 &&
+        "InsufficientFundsForRent" in detail) {
+        const rent = detail
+            .InsufficientFundsForRent;
+        if (typeof rent === "object" &&
+            rent !== null &&
+            "account_index" in rent &&
+            Number.isSafeInteger(rent.account_index) &&
+            Number(rent.account_index) >= 0)
+            code = "InsufficientFundsForRent";
+    }
+    const known = code && Object.hasOwn(map, code) ? map[code] : undefined;
+    if (known) {
+        result.title = known[0];
+        result.explanation = known[1];
+        result.known = true;
+    }
+    return result;
+}

package/dist/domain/instructions.js

@@ -0,0 +1,54 @@
+import { fromBase58 } from "./base58.js";
+export const COMPUTE = "ComputeBudget111111111111111111111111111111";
+export const SYSTEM = "11111111111111111111111111111111";
+const programs = {
+    [SYSTEM]: "System Program",
+    [COMPUTE]: "Compute Budget",
+    TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA: "Token Program",
+    TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb: "Token-2022",
+    ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL: "Associated Token",
+    MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr: "Memo",
+    BPFLoaderUpgradeab1e11111111111111111111111: "Upgradeable Loader",
+};
+export const programName = (id) => id
+    ? Object.hasOwn(programs, id)
+        ? programs[id]
+        : "Unknown program"
+    : "Unresolved program";
+export function formatLamports(value) {
+    const number = BigInt(value);
+    const whole = number / 1000000000n;
+    const fraction = (number % 1000000000n)
+        .toString()
+        .padStart(9, "0")
+        .replace(/0+$/, "");
+    return whole.toString() + (fraction ? "." + fraction : "");
+}
+function le(bytes) {
+    return bytes.reduceRight((value, byte) => value * 256n + BigInt(byte), 0n);
+}
+export function decodeInstruction(programId, data) {
+    const result = { action: null, limit: null, price: null };
+    try {
+        const bytes = fromBase58(data);
+        if (programId === COMPUTE) {
+            if (bytes[0] === 2 && bytes.length === 5) {
+                result.limit = le(bytes.slice(1)).toString();
+                result.action = `Set compute unit limit: ${result.limit} CU`;
+            }
+            if (bytes[0] === 3 && bytes.length === 9) {
+                result.price = le(bytes.slice(1)).toString();
+                result.action = `Set compute unit price: ${result.price} micro-lamports/CU`;
+            }
+        }
+        else if (programId === SYSTEM &&
+            bytes.length === 12 &&
+            le(bytes.slice(0, 4)) === 2n) {
+            result.action = `Transfer requested: ${formatLamports(le(bytes.slice(4)).toString())} SOL`;
+        }
+    }
+    catch {
+        /* Unrecognized or malformed instruction data remains undecoded. */
+    }
+    return result;
+}

package/dist/domain/logs.js

@@ -0,0 +1,47 @@
+export function parseLogs(lines) {
+    const stack = [];
+    return lines.map((text, index) => {
+        const event = {
+            line: index + 1,
+            text,
+            kind: "message",
+            depth: stack.at(-1)?.depth ?? null,
+            programId: null,
+            computeUsed: null,
+            computeLimit: null,
+        };
+        const invoke = /^Program ([1-9A-HJ-NP-Za-km-z]{32,44}) invoke \[([0-9]+)\]$/.exec(text);
+        const end = /^Program ([1-9A-HJ-NP-Za-km-z]{32,44}) (success|failed: .*)$/.exec(text);
+        const compute = /^Program ([1-9A-HJ-NP-Za-km-z]{32,44}) consumed ([0-9]+) of ([0-9]+) compute units$/.exec(text);
+        if (invoke && Number(invoke[2]) > 0 && Number(invoke[2]) <= 64) {
+            const depth = Number(invoke[2]);
+            while (stack.length && (stack.at(-1)?.depth ?? 0) >= depth)
+                stack.pop();
+            stack.push({ programId: invoke[1], depth });
+            Object.assign(event, { kind: "invoke", programId: invoke[1], depth });
+        }
+        else if (end) {
+            const frame = stack.findLastIndex((f) => f.programId === end[1]);
+            Object.assign(event, {
+                kind: end[2] === "success" ? "success" : "failure",
+                programId: end[1],
+                depth: frame < 0 ? null : stack[frame].depth,
+            });
+            if (frame >= 0)
+                stack.splice(frame);
+        }
+        else if (compute) {
+            Object.assign(event, {
+                kind: "compute",
+                programId: compute[1],
+                depth: stack.findLast((f) => f.programId === compute[1])?.depth ?? null,
+                computeUsed: compute[2],
+                computeLimit: compute[3],
+            });
+        }
+        else if (/^Log truncated(?:$|:)/i.test(text)) {
+            event.kind = "truncated";
+        }
+        return event;
+    });
+}

package/dist/domain/schema.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { isSignature } from "./base58.js";
+export const networkSchema = z.enum(["mainnet-beta", "devnet"]);
+export const requestSchema = z.strictObject({
+    signature: z
+        .string()
+        .refine(isSignature, "Enter a base58 Solana transaction signature (64 bytes)."),
+    network: networkSchema,
+});
+export const uint = z
+    .union([
+    z
+        .number()
+        .int()
+        .nonnegative()
+        .max(Number.MAX_SAFE_INTEGER)
+        .transform(String),
+    z.string().regex(/^(0|[1-9][0-9]{0,19})$/),
+])
+    .refine((v) => BigInt(v) <= 18446744073709551615n, "Value exceeds u64");
+const index = z.number().int().nonnegative().max(65535);
+const instruction = z
+    .object({
+    programIdIndex: index,
+    accounts: z.array(index).max(4096),
+    data: z.string().max(8192),
+    stackHeight: index.nullable().optional(),
+})
+    .passthrough();
+export const transactionSchema = z
+    .object({
+    slot: uint,
+    blockTime: z
+        .number()
+        .int()
+        .nonnegative()
+        .max(8640000000000)
+        .nullable()
+        .optional(),
+    version: z
+        .union([z.literal("legacy"), z.literal(0), z.literal(1)])
+        .optional(),
+    transaction: z
+        .object({
+        signatures: z.array(z.string().refine(isSignature)).min(1).max(256),
+        message: z
+            .object({
+            accountKeys: z.array(z.string().min(1).max(64)).max(4096),
+            instructions: z.array(instruction).max(4096),
+            transactionConfig: z
+                .object({
+                computeUnitLimit: uint.nullable(),
+                priorityFee: uint.nullable(),
+                heapSize: uint.nullable().optional(),
+                loadedAccountsDataSizeLimit: uint.nullable().optional(),
+            })
+                .passthrough()
+                .optional(),
+        })
+            .passthrough(),
+    })
+        .passthrough(),
+    meta: z
+        .object({
+        err: z.json(),
+        fee: uint,
+        computeUnitsConsumed: uint.nullable().optional(),
+        costUnits: uint.nullable().optional(),
+        logMessages: z
+            .array(z.string().max(200000))
+            .max(20000)
+            .nullable()
+            .optional(),
+        loadedAddresses: z
+            .object({
+            writable: z.array(z.string().max(64)).max(4096),
+            readonly: z.array(z.string().max(64)).max(4096),
+        })
+            .nullable()
+            .optional(),
+        innerInstructions: z
+            .array(z.object({ index, instructions: z.array(instruction).max(4096) }))
+            .max(4096)
+            .nullable()
+            .optional(),
+    })
+        .passthrough()
+        .nullable(),
+})
+    .passthrough();

package/dist/public/app.js

@@ -0,0 +1,7 @@
+var S="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";function k(e){if(e.length>8192)throw new Error("Base58 input too large");let o=0n;for(let r of e){let d=S.indexOf(r);if(d<0)throw new Error("Invalid base58");o=o*58n+BigInt(d)}let a=[];for(;o>0n;)a.push(Number(o&255n)),o>>=8n;let n=0;for(;e[n]==="1";)n++;return Uint8Array.from([...new Array(n).fill(0),...a.reverse()])}function L(e){if(e.length<64||e.length>88)return!1;try{return k(e).length===64}catch{return!1}}function t(e){let o=document.getElementById(e);if(!o)throw new Error(`Missing element: ${e}`);return o}function i(e,o="",a){let n=document.createElement(e);return n.className=o,a!==void 0&&(n.textContent=a),n}var R=t("inspect-form"),v=t("signature"),M=t("network"),u=t("activity"),h=t("error"),T=t("result"),w=t("empty"),c=null,U={succeeded:"Succeeded",failed:"Failed",rolled_back:"Ran; rolled back",not_run:"Not run",unknown:"Not determined"};function p(e){return e===null?"Not reported":BigInt(e).toLocaleString("en-US")}function l(e,o,a,n=""){e.append(i("dt","",o),i("dd",n,a))}function I(e){c=e;let o=e.source==="example";t("source-label").textContent=o?"Offline example \xB7 Fictional values":`Live RPC \xB7 ${e.network==="devnet"?"Devnet":"Mainnet"}`,t("source-label").className=`source-label${o?" example":""}`,t("diagnosis").className=`diagnosis ${e.status}`,t("outcome").textContent=e.status==="failed"?"Transaction failed":e.status==="succeeded"?"Execution completed":"Incomplete record",t("diagnosis-title").textContent=e.diagnosis.title,t("explanation").textContent=e.diagnosis.explanation;let a=t("failure-note");a.hidden=e.status!=="failed",a.textContent="Program state changes ordinarily roll back on failure. Fees and durable-nonce advancement can persist. A recorded fee is not refunded by this debugger.";let n=e.diagnosis.instructionIndex;t("failed-instruction").textContent=n===null?"Not identified":`#${n+1} (RPC index ${n})`,t("fee").textContent=e.fee.sol===null?"Not reported":`${e.fee.sol} SOL`,t("compute").textContent=e.compute.consumed===null?"Not reported":`${p(e.compute.consumed)} CU`,t("failed-program").textContent=e.diagnosis.programId??"Not identified";let r=t("resources");r.replaceChildren(),l(r,"Recorded fee",e.fee.lamports===null?"Not reported":`${p(e.fee.lamports)} lamports`),l(r,"Base / priority split","Not provided by getTransaction"),l(r,"Requested compute limit",e.compute.requestedLimit===null?"Not reported":`${p(e.compute.requestedLimit)} CU`),e.version===1?l(r,"Requested priority fee (v1)",e.fee.requestedPriorityLamports===null?"Not set or unavailable":`${p(e.fee.requestedPriorityLamports)} lamports`):l(r,"Requested CU price",e.fee.requestedMicroLamportsPerCu===null?"Not reported":`${p(e.fee.requestedMicroLamportsPerCu)} micro-lamports/CU`),l(r,"Scheduling cost",e.compute.costUnits===null?"Not reported":`${p(e.compute.costUnits)} cost units`);let d=t("identity");d.replaceChildren(),l(d,"Signature",e.signature,"address"),l(d,"Version",String(e.version)),l(d,"Slot",p(e.slot)),l(d,"Fee payer",e.fee.payer??"Not reported","address");let y=e.blockTime===null?null:new Date(e.blockTime*1e3);l(d,"Block time",y&&!Number.isNaN(y.getTime())?y.toISOString():"Not reported"),l(d,"Observed",new Date(e.checkedAt).toISOString()),t("warnings").replaceChildren(...e.warnings.map(s=>i("li","",s))),t("warnings-section").hidden=e.warnings.length===0,t("raw-error").textContent=JSON.stringify(e.diagnosis.raw,null,2),t("instruction-count").textContent=`${e.instructions.length} top-level`,t("instructions").replaceChildren(...e.instructions.map(s=>{let m=i("li",`instruction ${s.status}`);m.append(i("span","instruction-number",`#${s.number}`));let x=i("div"),E=i("div","instruction-header");E.append(i("strong","",s.programName),i("span","instruction-state",U[s.status]??"Not determined")),x.append(E,i("p","instruction-id address",s.programId??"Program address not available")),s.action&&x.append(i("p","instruction-action",s.action));let b=i("details");b.append(i("summary","",`Accounts & data (RPC index ${s.index})`)),b.append(i("pre","",`Accounts:
+${s.accounts.map((g,f)=>`${f}: ${g??"Unresolved address"}`).join(`
+`)||"None"}
+
+Data (base58):
+${s.data||"(empty)"}`));for(let g of s.inner){let f=i("div","inner-call");f.append(i("strong","",`Inner call: ${g.programName}`),i("p","address",g.programId??"Unresolved address")),g.action&&f.append(i("p","",g.action)),b.append(f)}return x.append(b),m.append(x),m})),t("log-count").textContent=e.logs===null?"Unavailable":`${e.logs.length} lines`;let C=t("logs");if(C.replaceChildren(),e.logs===null||e.logs.length===0)C.append(i("p","logs-empty",e.logs===null?"The RPC did not provide logs for this transaction.":"No execution log lines were recorded."));else for(let s of e.logs){let m=i("div",`log-line log-${s.kind} log-depth-${Math.min(8,s.depth??1)}`);m.append(i("span","log-number",String(s.line)),i("span","log-text",s.text)),C.append(m)}let N=t("explorer");N.hidden=o,N.href=`https://explorer.solana.com/tx/${encodeURIComponent(e.signature)}${e.network==="devnet"?"?cluster=devnet":""}`,w.hidden=!0,T.hidden=!1}async function $(e,o){h.hidden=!0,u.textContent=o?"Looking up transaction\u2026":"Loading offline example\u2026",T.hidden=!0,w.hidden=!0;let a=document.querySelectorAll("#inspect-form button,#inspect-form input,#inspect-form select,#examples button");a.forEach(n=>n.disabled=!0);try{let n=await fetch(e,{...o?{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(o)}:{},signal:AbortSignal.timeout(16e3)}),r=await n.json();if(!n.ok)throw new Error(r.error?.message??"Lookup failed. Try again.");I(r),u.textContent=""}catch(n){c=null,h.textContent=n instanceof Error&&n.name==="TimeoutError"?"Lookup timed out. Please try again.":n instanceof Error?n.message:"Could not reach the local server.",h.hidden=!1,w.hidden=!1,u.textContent=""}finally{a.forEach(n=>n.disabled=!1)}}R.addEventListener("submit",e=>{e.preventDefault();let o=v.value.trim();if(!L(o)){h.textContent="Enter a valid Solana transaction signature: a base58 value representing 64 bytes.",h.hidden=!1,v.setAttribute("aria-invalid","true"),v.focus();return}v.removeAttribute("aria-invalid"),$("/api/transactions",{signature:o,network:M.value})});t("copy").addEventListener("click",()=>{c&&(navigator.clipboard?.writeText(c.summaryText).then(()=>{u.textContent="Report copied."}).catch(()=>{u.textContent="Clipboard unavailable. Export JSON to save this report."}),navigator.clipboard||(u.textContent="Clipboard unavailable. Export JSON to save this report."))});t("export").addEventListener("click",()=>{if(!c)return;let e=new Blob([JSON.stringify(c,null,2)+`
+`],{type:"application/json"}),o=URL.createObjectURL(e),a=i("a");a.href=o,a.download=`txray-${c.source==="example"?"example-"+c.exampleId:c.signature.slice(0,12)}.json`,document.body.append(a),a.click(),a.remove(),setTimeout(()=>URL.revokeObjectURL(o),1e3),u.textContent="JSON export downloaded."});async function O(){try{let e=await fetch("/api/examples");if(!e.ok)throw new Error("Examples unavailable");let o=await e.json();for(let a of o){let n=i("button","",a.title);n.type="button",n.title=a.description,n.addEventListener("click",()=>{$(`/api/examples/${encodeURIComponent(a.id)}`)}),t("examples").append(n)}}catch{u.textContent="Offline examples could not be loaded. Refresh the page or inspect a signature."}}O();