{"version":3,"sources":["../src/max-instructions.ts","../src/instruction-plan.ts","../src/append-instruction-plan.ts","../src/transaction-plan.ts","../src/instruction-plan-input.ts","../src/transaction-plan-result.ts","../src/transaction-plan-errors.ts","../src/transaction-plan-executor.ts","../src/transaction-planner.ts"],"names":["SolanaError","SOLANA_ERROR__INSTRUCTION_PLANS__INVALID_MAX_INSTRUCTIONS_PER_TRANSACTION","SOLANA_ERROR__INSTRUCTION_PLANS__MAX_INSTRUCTIONS_PER_TRANSACTION_EXCEEDED","SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN","SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE","getTransactionMessageSize","appendTransactionMessageInstruction","getTransactionMessageSizeLimit","SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN","SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND","SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN","SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT","SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT","SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND","SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION","SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTION","SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS","SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTIONS","SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN","SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE","SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT","isSolanaError","getAbortablePromise","SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND","SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED","traverse","SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN","traverseSequential","traverseParallel","traverseSingle","candidate","message","appendTransactionMessageInstructions","SOLANA_ERROR__TRANSACTION__TOO_MANY_ACCOUNT_ADDRESSES","SOLANA_ERROR__TRANSACTION__TOO_MANY_ACCOUNTS_IN_INSTRUCTION","SOLANA_ERROR__TRANSACTION__TOO_MANY_INSTRUCTIONS","SOLANA_ERROR__TRANSACTION__TOO_MANY_SIGNER_ADDRESSES"],"mappings":"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","file":"index.browser.cjs","sourcesContent":["import {\n    SOLANA_ERROR__INSTRUCTION_PLANS__INVALID_MAX_INSTRUCTIONS_PER_TRANSACTION,\n    SOLANA_ERROR__INSTRUCTION_PLANS__MAX_INSTRUCTIONS_PER_TRANSACTION_EXCEEDED,\n    SolanaError,\n} from '@solana/errors';\n\n/**\n * The default maximum number of top-level instructions per planned transaction message.\n *\n * This is intentionally lower than the transaction format's instruction limit (see\n * {@link TRANSACTION_INSTRUCTION_LIMIT}) to leave headroom for inner instructions\n * (CPIs), which are not visible at planning time.\n */\nexport const DEFAULT_MAX_INSTRUCTIONS_PER_TRANSACTION = 16;\n\n/**\n * The hard maximum number of top-level instructions the transaction format can encode.\n *\n * Every current transaction version shares this limit. It is intentionally duplicated here —\n * rather than derived from `@solana/transactions` — so a configured maximum can be validated\n * without compiling a transaction message. If a future transaction version raises the limit,\n * update this constant (and consider making it version-aware).\n */\nconst TRANSACTION_INSTRUCTION_LIMIT = 64;\n\n/**\n * Resolves the effective maximum number of instructions allowed in a transaction message.\n *\n * Falls back to 16 when no value is provided. The\n * provided value is expected to be a positive integer no greater than the transaction format's\n * instruction limit; validate it first with {@link assertValidMaxInstructionsPerTransaction}.\n */\nexport function resolveMaxInstructions(maxInstructions: number | undefined): number {\n    return maxInstructions ?? DEFAULT_MAX_INSTRUCTIONS_PER_TRANSACTION;\n}\n\n/**\n * Asserts that a configured maximum number of instructions per transaction is valid.\n *\n * A configured maximum must be a positive integer no greater than the number of top-level\n * instructions the transaction format can encode (see {@link TRANSACTION_INSTRUCTION_LIMIT}).\n * Rejects values that are not positive integers. `undefined` is allowed and falls back to\n * the default.\n *\n * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__INVALID_MAX_INSTRUCTIONS_PER_TRANSACTION}\n */\nexport function assertValidMaxInstructionsPerTransaction(maxInstructions: number | undefined): void {\n    if (\n        maxInstructions !== undefined &&\n        (maxInstructions <= 0 || !Number.isInteger(maxInstructions) || maxInstructions > TRANSACTION_INSTRUCTION_LIMIT)\n    ) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__INVALID_MAX_INSTRUCTIONS_PER_TRANSACTION, {\n            maxInstructions,\n            transactionInstructionLimit: TRANSACTION_INSTRUCTION_LIMIT,\n        });\n    }\n}\n\n/**\n * Throws if `numInstructions` exceeds `maxInstructions`.\n *\n * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__MAX_INSTRUCTIONS_PER_TRANSACTION_EXCEEDED}\n */\nexport function assertMaxInstructionsPerTransaction(numInstructions: number, maxInstructions: number): void {\n    if (numInstructions > maxInstructions) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MAX_INSTRUCTIONS_PER_TRANSACTION_EXCEEDED, {\n            maxInstructions,\n            numInstructions,\n        });\n    }\n}\n","import {\n    SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN,\n    SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE,\n    SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN,\n    SolanaError,\n} from '@solana/errors';\nimport { Instruction } from '@solana/instructions';\nimport {\n    appendTransactionMessageInstruction,\n    TransactionMessage,\n    TransactionMessageWithFeePayer,\n} from '@solana/transaction-messages';\nimport { getTransactionMessageSize, getTransactionMessageSizeLimit } from '@solana/transactions';\n\nimport {\n    assertMaxInstructionsPerTransaction,\n    assertValidMaxInstructionsPerTransaction,\n    resolveMaxInstructions,\n} from './max-instructions';\n\n/**\n * A set of instructions with constraints on how they can be executed.\n *\n * This is structured as a recursive tree of plans in order to allow for\n * parallel execution, sequential execution and combinations of both.\n *\n * Namely the following plans are supported:\n * - {@link SingleInstructionPlan} - A plan that contains a single instruction.\n *   This is a simple instruction wrapper and the simplest leaf in this tree.\n * - {@link ParallelInstructionPlan} - A plan that contains other plans that\n *   can be executed in parallel.\n * - {@link SequentialInstructionPlan} - A plan that contains other plans that\n *   must be executed sequentially. It also defines whether the plan is divisible\n *   meaning that instructions inside it can be split into separate transactions.\n * - {@link MessagePackerInstructionPlan} - A plan that can dynamically pack\n *  instructions into transaction messages.\n *\n * Helpers are provided for each of these plans to make it easier to create them.\n *\n * @example\n * ```ts\n * const myInstructionPlan: InstructionPlan = parallelInstructionPlan([\n *    sequentialInstructionPlan([instructionA, instructionB]),\n *    instructionC,\n *    instructionD,\n * ]);\n * ```\n *\n * @see {@link SingleInstructionPlan}\n * @see {@link ParallelInstructionPlan}\n * @see {@link SequentialInstructionPlan}\n * @see {@link MessagePackerInstructionPlan}\n */\nexport type InstructionPlan =\n    | MessagePackerInstructionPlan\n    | ParallelInstructionPlan\n    | SequentialInstructionPlan\n    | SingleInstructionPlan;\n\n/**\n * A plan wrapping other plans that must be executed sequentially.\n *\n * It also defines whether nested plans are divisible — meaning that\n * the instructions inside them can be split into separate transactions.\n * When `divisible` is `false`, the instructions inside the plan should\n * all be executed atomically — either in a single transaction or in a\n * transaction bundle.\n *\n * You may use the {@link sequentialInstructionPlan} and {@link nonDivisibleSequentialInstructionPlan}\n * helpers to create objects of this type.\n *\n * @example Simple sequential plan with two instructions.\n * ```ts\n * const plan = sequentialInstructionPlan([instructionA, instructionB]);\n * plan satisfies SequentialInstructionPlan;\n * ```\n *\n * @example Non-divisible sequential plan with two instructions.\n * ```ts\n * const plan = nonDivisibleSequentialInstructionPlan([instructionA, instructionB]);\n * plan satisfies SequentialInstructionPlan & { divisible: false };\n * ```\n *\n * @example Sequential plan with nested parallel plans.\n * Here, instructions A and B can be executed in parallel, but they must both be finalized\n * before instructions C and D can be sent — which can also be executed in parallel.\n * ```ts\n * const plan = sequentialInstructionPlan([\n *   parallelInstructionPlan([instructionA, instructionB]),\n *   parallelInstructionPlan([instructionC, instructionD]),\n * ]);\n * plan satisfies SequentialInstructionPlan & { divisible: false };\n * ```\n *\n * @see {@link sequentialInstructionPlan}\n * @see {@link nonDivisibleSequentialInstructionPlan}\n */\nexport type SequentialInstructionPlan = Readonly<{\n    divisible: boolean;\n    kind: 'sequential';\n    planType: 'instructionPlan';\n    plans: InstructionPlan[];\n}>;\n\n/**\n * A plan wrapping other plans that can be executed in parallel.\n *\n * This means direct children of this plan can be executed in separate\n * parallel transactions without consequence.\n * However, the children themselves can define additional constraints\n * for that specific branch of the tree — such as the {@link SequentialInstructionPlan}.\n *\n * You may use the {@link parallelInstructionPlan} helper to create objects of this type.\n *\n * @example Simple parallel plan with two instructions.\n * ```ts\n * const plan = parallelInstructionPlan([instructionA, instructionB]);\n * plan satisfies ParallelInstructionPlan;\n * ```\n *\n * @example Parallel plan with nested sequential plans.\n * Here, instructions A and B must be executed sequentially and so must instructions C and D,\n * but both pairs can be executed in parallel.\n * ```ts\n * const plan = parallelInstructionPlan([\n *   sequentialInstructionPlan([instructionA, instructionB]),\n *   sequentialInstructionPlan([instructionC, instructionD]),\n * ]);\n * plan satisfies ParallelInstructionPlan;\n * ```\n *\n * @see {@link parallelInstructionPlan}\n */\nexport type ParallelInstructionPlan = Readonly<{\n    kind: 'parallel';\n    planType: 'instructionPlan';\n    plans: InstructionPlan[];\n}>;\n\n/**\n * A plan that contains a single instruction.\n *\n * This is a simple instruction wrapper that transforms an instruction into a plan.\n *\n * You may use the {@link singleInstructionPlan} helper to create objects of this type.\n *\n * @example\n * ```ts\n * const plan = singleInstructionPlan(instructionA);\n * plan satisfies SingleInstructionPlan;\n * ```\n *\n * @see {@link singleInstructionPlan}\n */\nexport type SingleInstructionPlan<TInstruction extends Instruction = Instruction> = Readonly<{\n    instruction: TInstruction;\n    kind: 'single';\n    planType: 'instructionPlan';\n}>;\n\n/**\n * A plan that can dynamically pack instructions into transaction messages.\n *\n * This plan provides a {@link MessagePacker} via the `getMessagePacker`\n * method, which enables instructions to be dynamically packed into the\n * provided transaction message until there are no more instructions to pack.\n * The returned {@link MessagePacker} offers a `packMessageToCapacity(message)`\n * method that packs the provided message — when possible — and a `done()` method\n * that checks whether there are more instructions to pack.\n *\n * Several helper functions are provided to create objects of this type such as\n * {@link getLinearMessagePackerInstructionPlan} or {@link getMessagePackerInstructionPlanFromInstructions}.\n *\n * @example An message packer plan for a write instruction that uses as many bytes as possible.\n * ```ts\n * const plan = getLinearMessagePackerInstructionPlan({\n *   totalLength: dataToWrite.length,\n *   getInstruction: (offset, length) =>\n *     getWriteInstruction({\n *       offset,\n *       data: dataToWrite.slice(offset, offset + length),\n *     }),\n * });\n * plan satisfies MessagePackerInstructionPlan;\n * ```\n *\n * @example A message packer plan for multiple realloc instructions.\n * ```ts\n * const plan = getReallocMessagePackerInstructionPlan({\n *   totalSize: additionalDataSize,\n *   getInstruction: (size) => getExtendInstruction({ length: size }),\n * });\n * plan satisfies MessagePackerInstructionPlan;\n * ```\n *\n * @example Using a message packer plan.\n * ```ts\n * let plan: MessagePackerInstructionPlan;\n * const messagePacker = plan.getMessagePacker();\n *\n * while (!messagePacker.done()) {\n *   try {\n *     transactionMessage = messagePacker.packMessageToCapacity(transactionMessage);\n *   } catch (error) {\n *     // The current transaction message cannot be used to pack this plan.\n *     // We should create a new one and try again.\n *   }\n * }\n * ```\n *\n * @see {@link getLinearMessagePackerInstructionPlan}\n * @see {@link getMessagePackerInstructionPlanFromInstructions}\n * @see {@link getReallocMessagePackerInstructionPlan}\n */\nexport type MessagePackerInstructionPlan = Readonly<{\n    getMessagePacker: () => MessagePacker;\n    kind: 'messagePacker';\n    planType: 'instructionPlan';\n}>;\n\n/**\n * The message packer returned by the {@link MessagePackerInstructionPlan}.\n *\n * It offers a `packMessageToCapacity(transactionMessage)` method that packs as many instructions\n * as possible into the provided transaction message, while still being able to fit into the\n * transaction size limit and the default or configured instruction-count limit. It returns the updated\n * transaction message with the packed instructions or throws an error if the current transaction\n * message cannot accommodate this plan.\n *\n * The `done()` method checks whether there are more instructions to pack into\n * transaction messages.\n *\n * @example\n * ```ts\n * let plan: MessagePackerInstructionPlan;\n * const messagePacker = plan.getMessagePacker();\n *\n * while (!messagePacker.done()) {\n *   try {\n *     transactionMessage = messagePacker.packMessageToCapacity(transactionMessage);\n *   } catch (error) {\n *     // The current transaction message cannot be used to pack this plan.\n *     // We should create a new one and try again.\n *   }\n * }\n * ```\n *\n * @see {@link MessagePackerInstructionPlan}\n */\nexport type MessagePacker = Readonly<{\n    /** Checks whether the message packer has more instructions to pack into transaction messages. */\n    done: () => boolean;\n    /**\n     * Packs the provided transaction message with instructions or throws if not possible.\n     *\n     * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN}\n     *   if the provided transaction message cannot be used to fill the next instructions.\n     * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE}\n     *   if the message packer is already done and no more instructions can be packed.\n     * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__MAX_INSTRUCTIONS_PER_TRANSACTION_EXCEEDED}\n     *   if the provided transaction message has already reached the configured `maxInstructions`\n     *   ceiling, so no further instruction can be packed into it.\n     * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__INVALID_MAX_INSTRUCTIONS_PER_TRANSACTION}\n     *   if `maxInstructions` exceeds the number of top-level instructions the transaction format\n     *   can encode.\n     */\n    packMessageToCapacity: (\n        transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,\n        config?: {\n            /**\n             * Maximum number of instructions allowed in the returned transaction message.\n             *\n             * Must be a positive integer no greater than `64` — the number of top-level instructions\n             * the transaction format can encode. Larger values throw. Defaults to 16. This is the\n             * message-packer equivalent of the transaction planner's `maxInstructionsPerTransaction`\n             * option.\n             */\n            maxInstructions?: number;\n        },\n    ) => TransactionMessage & TransactionMessageWithFeePayer;\n}>;\n\n/**\n * Creates a {@link ParallelInstructionPlan} from an array of nested plans.\n *\n * It can accept {@link Instruction} objects directly, which will be wrapped\n * in {@link SingleInstructionPlan | SingleInstructionPlans} automatically.\n *\n * @example Using explicit {@link SingleInstructionPlan | SingleInstructionPlans}.\n * ```ts\n * const plan = parallelInstructionPlan([\n *   singleInstructionPlan(instructionA),\n *   singleInstructionPlan(instructionB),\n * ]);\n * ```\n *\n * @example Using {@link Instruction | Instructions} directly.\n * ```ts\n * const plan = parallelInstructionPlan([instructionA, instructionB]);\n * ```\n *\n * @see {@link ParallelInstructionPlan}\n */\nexport function parallelInstructionPlan(plans: (Instruction | InstructionPlan)[]): ParallelInstructionPlan {\n    return Object.freeze({\n        kind: 'parallel',\n        planType: 'instructionPlan',\n        plans: parseSingleInstructionPlans(plans),\n    });\n}\n\n/**\n * Creates a divisible {@link SequentialInstructionPlan} from an array of nested plans.\n *\n * It can accept {@link Instruction} objects directly, which will be wrapped\n * in {@link SingleInstructionPlan | SingleInstructionPlans} automatically.\n *\n * @example Using explicit {@link SingleInstructionPlan | SingleInstructionPlans}.\n * ```ts\n * const plan = sequentialInstructionPlan([\n *   singleInstructionPlan(instructionA),\n *   singleInstructionPlan(instructionB),\n * ]);\n * ```\n *\n * @example Using {@link Instruction | Instructions} directly.\n * ```ts\n * const plan = sequentialInstructionPlan([instructionA, instructionB]);\n * ```\n *\n * @see {@link SequentialInstructionPlan}\n */\nexport function sequentialInstructionPlan(\n    plans: (Instruction | InstructionPlan)[],\n): SequentialInstructionPlan & { divisible: true } {\n    return Object.freeze({\n        divisible: true,\n        kind: 'sequential',\n        planType: 'instructionPlan',\n        plans: parseSingleInstructionPlans(plans),\n    });\n}\n\n/**\n * Creates a non-divisible {@link SequentialInstructionPlan} from an array of nested plans.\n *\n * It can accept {@link Instruction} objects directly, which will be wrapped\n * in {@link SingleInstructionPlan | SingleInstructionPlans} automatically.\n *\n * @example Using explicit {@link SingleInstructionPlan | SingleInstructionPlans}.\n * ```ts\n * const plan = nonDivisibleSequentialInstructionPlan([\n *   singleInstructionPlan(instructionA),\n *   singleInstructionPlan(instructionB),\n * ]);\n * ```\n *\n * @example Using {@link Instruction | Instructions} directly.\n * ```ts\n * const plan = nonDivisibleSequentialInstructionPlan([instructionA, instructionB]);\n * ```\n *\n * @see {@link SequentialInstructionPlan}\n */\nexport function nonDivisibleSequentialInstructionPlan(\n    plans: (Instruction | InstructionPlan)[],\n): SequentialInstructionPlan & { divisible: false } {\n    return Object.freeze({\n        divisible: false,\n        kind: 'sequential',\n        planType: 'instructionPlan',\n        plans: parseSingleInstructionPlans(plans),\n    });\n}\n\n/**\n * Creates a {@link SingleInstructionPlan} from an {@link Instruction} object.\n *\n * @example\n * ```ts\n * const plan = singleInstructionPlan(instructionA);\n * ```\n *\n * @see {@link SingleInstructionPlan}\n */\nexport function singleInstructionPlan(instruction: Instruction): SingleInstructionPlan {\n    return Object.freeze({ instruction, kind: 'single', planType: 'instructionPlan' });\n}\n\nfunction parseSingleInstructionPlans(plans: (Instruction | InstructionPlan)[]): InstructionPlan[] {\n    return plans.map(plan => ('kind' in plan ? plan : singleInstructionPlan(plan)));\n}\n\n/**\n * Checks if the given value is an {@link InstructionPlan}.\n *\n * This type guard checks the `planType` property to determine if the value\n * is an instruction plan. This is useful when you have a value that could be\n * an {@link InstructionPlan}, {@link TransactionPlan}, or {@link TransactionPlanResult}\n * and need to narrow the type.\n *\n * @param value - The value to check.\n * @return `true` if the value is an instruction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * function processItem(item: InstructionPlan | TransactionPlan | TransactionPlanResult) {\n *   if (isInstructionPlan(item)) {\n *     // item is narrowed to InstructionPlan\n *     console.log(item.kind);\n *   }\n * }\n * ```\n *\n * @see {@link InstructionPlan}\n * @see {@link isTransactionPlan}\n * @see {@link isTransactionPlanResult}\n */\nexport function isInstructionPlan(value: unknown): value is InstructionPlan {\n    return (\n        typeof value === 'object' &&\n        value !== null &&\n        'planType' in value &&\n        typeof value.planType === 'string' &&\n        value.planType === 'instructionPlan'\n    );\n}\n\n/**\n * Checks if the given instruction plan is a {@link SingleInstructionPlan}.\n *\n * @param plan - The instruction plan to check.\n * @return `true` if the plan is a single instruction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = singleInstructionPlan(myInstruction);\n *\n * if (isSingleInstructionPlan(plan)) {\n *   console.log(plan.instruction); // TypeScript knows this is a SingleInstructionPlan.\n * }\n * ```\n *\n * @see {@link SingleInstructionPlan}\n * @see {@link assertIsSingleInstructionPlan}\n */\nexport function isSingleInstructionPlan(plan: InstructionPlan): plan is SingleInstructionPlan {\n    return plan.kind === 'single';\n}\n\n/**\n * Asserts that the given instruction plan is a {@link SingleInstructionPlan}.\n *\n * @param plan - The instruction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN` if the plan is not a single instruction plan.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = singleInstructionPlan(myInstruction);\n *\n * assertIsSingleInstructionPlan(plan);\n * console.log(plan.instruction); // TypeScript knows this is a SingleInstructionPlan.\n * ```\n *\n * @see {@link SingleInstructionPlan}\n * @see {@link isSingleInstructionPlan}\n */\nexport function assertIsSingleInstructionPlan(plan: InstructionPlan): asserts plan is SingleInstructionPlan {\n    if (!isSingleInstructionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN, {\n            actualKind: plan.kind,\n            expectedKind: 'single',\n            instructionPlan: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given instruction plan is a {@link MessagePackerInstructionPlan}.\n *\n * @param plan - The instruction plan to check.\n * @return `true` if the plan is a message packer instruction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = getLinearMessagePackerInstructionPlan({ /* ... *\\/ });\n *\n * if (isMessagePackerInstructionPlan(plan)) {\n *   const packer = plan.getMessagePacker(); // TypeScript knows this is a MessagePackerInstructionPlan.\n * }\n * ```\n *\n * @see {@link MessagePackerInstructionPlan}\n * @see {@link assertIsMessagePackerInstructionPlan}\n */\nexport function isMessagePackerInstructionPlan(plan: InstructionPlan): plan is MessagePackerInstructionPlan {\n    return plan.kind === 'messagePacker';\n}\n\n/**\n * Asserts that the given instruction plan is a {@link MessagePackerInstructionPlan}.\n *\n * @param plan - The instruction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN` if the plan is not a message packer instruction plan.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = getLinearMessagePackerInstructionPlan({ /* ... *\\/ });\n *\n * assertIsMessagePackerInstructionPlan(plan);\n * const packer = plan.getMessagePacker(); // TypeScript knows this is a MessagePackerInstructionPlan.\n * ```\n *\n * @see {@link MessagePackerInstructionPlan}\n * @see {@link isMessagePackerInstructionPlan}\n */\nexport function assertIsMessagePackerInstructionPlan(\n    plan: InstructionPlan,\n): asserts plan is MessagePackerInstructionPlan {\n    if (!isMessagePackerInstructionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN, {\n            actualKind: plan.kind,\n            expectedKind: 'messagePacker',\n            instructionPlan: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given instruction plan is a {@link SequentialInstructionPlan}.\n *\n * @param plan - The instruction plan to check.\n * @return `true` if the plan is a sequential instruction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = sequentialInstructionPlan([instructionA, instructionB]);\n *\n * if (isSequentialInstructionPlan(plan)) {\n *   console.log(plan.divisible); // TypeScript knows this is a SequentialInstructionPlan.\n * }\n * ```\n *\n * @see {@link SequentialInstructionPlan}\n * @see {@link assertIsSequentialInstructionPlan}\n */\nexport function isSequentialInstructionPlan(plan: InstructionPlan): plan is SequentialInstructionPlan {\n    return plan.kind === 'sequential';\n}\n\n/**\n * Asserts that the given instruction plan is a {@link SequentialInstructionPlan}.\n *\n * @param plan - The instruction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN` if the plan is not a sequential instruction plan.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = sequentialInstructionPlan([instructionA, instructionB]);\n *\n * assertIsSequentialInstructionPlan(plan);\n * console.log(plan.divisible); // TypeScript knows this is a SequentialInstructionPlan.\n * ```\n *\n * @see {@link SequentialInstructionPlan}\n * @see {@link isSequentialInstructionPlan}\n */\nexport function assertIsSequentialInstructionPlan(plan: InstructionPlan): asserts plan is SequentialInstructionPlan {\n    if (!isSequentialInstructionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN, {\n            actualKind: plan.kind,\n            expectedKind: 'sequential',\n            instructionPlan: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given instruction plan is a non-divisible {@link SequentialInstructionPlan}.\n *\n * A non-divisible sequential plan requires all its instructions to be executed\n * atomically — either in a single transaction or in a transaction bundle.\n *\n * @param plan - The instruction plan to check.\n * @return `true` if the plan is a non-divisible sequential instruction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = nonDivisibleSequentialInstructionPlan([instructionA, instructionB]);\n *\n * if (isNonDivisibleSequentialInstructionPlan(plan)) {\n *   // All instructions must be executed atomically.\n * }\n * ```\n *\n * @see {@link SequentialInstructionPlan}\n * @see {@link assertIsNonDivisibleSequentialInstructionPlan}\n */\nexport function isNonDivisibleSequentialInstructionPlan(\n    plan: InstructionPlan,\n): plan is SequentialInstructionPlan & { divisible: false } {\n    return plan.kind === 'sequential' && plan.divisible === false;\n}\n\n/**\n * Asserts that the given instruction plan is a non-divisible {@link SequentialInstructionPlan}.\n *\n * A non-divisible sequential plan requires all its instructions to be executed\n * atomically — either in a single transaction or in a transaction bundle.\n *\n * @param plan - The instruction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN` if the plan is not a non-divisible sequential instruction plan.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = nonDivisibleSequentialInstructionPlan([instructionA, instructionB]);\n *\n * assertIsNonDivisibleSequentialInstructionPlan(plan);\n * // All instructions must be executed atomically.\n * ```\n *\n * @see {@link SequentialInstructionPlan}\n * @see {@link isNonDivisibleSequentialInstructionPlan}\n */\nexport function assertIsNonDivisibleSequentialInstructionPlan(\n    plan: InstructionPlan,\n): asserts plan is SequentialInstructionPlan & { divisible: false } {\n    if (!isNonDivisibleSequentialInstructionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN, {\n            actualKind: plan.kind === 'sequential' ? 'divisible sequential' : plan.kind,\n            expectedKind: 'non-divisible sequential',\n            instructionPlan: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given instruction plan is a {@link ParallelInstructionPlan}.\n *\n * @param plan - The instruction plan to check.\n * @return `true` if the plan is a parallel instruction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = parallelInstructionPlan([instructionA, instructionB]);\n *\n * if (isParallelInstructionPlan(plan)) {\n *   console.log(plan.plans.length); // TypeScript knows this is a ParallelInstructionPlan.\n * }\n * ```\n *\n * @see {@link ParallelInstructionPlan}\n * @see {@link assertIsParallelInstructionPlan}\n */\nexport function isParallelInstructionPlan(plan: InstructionPlan): plan is ParallelInstructionPlan {\n    return plan.kind === 'parallel';\n}\n\n/**\n * Asserts that the given instruction plan is a {@link ParallelInstructionPlan}.\n *\n * @param plan - The instruction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN` if the plan is not a parallel instruction plan.\n *\n * @example\n * ```ts\n * const plan: InstructionPlan = parallelInstructionPlan([instructionA, instructionB]);\n *\n * assertIsParallelInstructionPlan(plan);\n * console.log(plan.plans.length); // TypeScript knows this is a ParallelInstructionPlan.\n * ```\n *\n * @see {@link ParallelInstructionPlan}\n * @see {@link isParallelInstructionPlan}\n */\nexport function assertIsParallelInstructionPlan(plan: InstructionPlan): asserts plan is ParallelInstructionPlan {\n    if (!isParallelInstructionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN, {\n            actualKind: plan.kind,\n            expectedKind: 'parallel',\n            instructionPlan: plan,\n        });\n    }\n}\n\n/**\n * Finds the first instruction plan in the tree that matches the given predicate.\n *\n * This function performs a depth-first search through the instruction plan tree,\n * returning the first plan that satisfies the predicate. It checks the root plan\n * first, then recursively searches through nested plans.\n *\n * @param instructionPlan - The instruction plan tree to search.\n * @param predicate - A function that returns `true` for the plan to find.\n * @returns The first matching instruction plan, or `undefined` if no match is found.\n *\n * @example\n * Finding a non-divisible sequential plan.\n * ```ts\n * const plan = parallelInstructionPlan([\n *   sequentialInstructionPlan([instructionA, instructionB]),\n *   nonDivisibleSequentialInstructionPlan([instructionC, instructionD]),\n * ]);\n *\n * const nonDivisible = findInstructionPlan(\n *   plan,\n *   (p) => p.kind === 'sequential' && !p.divisible,\n * );\n * // Returns the non-divisible sequential plan containing instructionC and instructionD.\n * ```\n *\n * @example\n * Finding a specific single instruction plan.\n * ```ts\n * const plan = sequentialInstructionPlan([instructionA, instructionB, instructionC]);\n *\n * const found = findInstructionPlan(\n *   plan,\n *   (p) => p.kind === 'single' && p.instruction === instructionB,\n * );\n * // Returns the SingleInstructionPlan wrapping instructionB.\n * ```\n *\n * @see {@link InstructionPlan}\n * @see {@link everyInstructionPlan}\n * @see {@link transformInstructionPlan}\n * @see {@link flattenInstructionPlan}\n */\nexport function findInstructionPlan(\n    instructionPlan: InstructionPlan,\n    predicate: (plan: InstructionPlan) => boolean,\n): InstructionPlan | undefined {\n    if (predicate(instructionPlan)) {\n        return instructionPlan;\n    }\n    if (instructionPlan.kind === 'single' || instructionPlan.kind === 'messagePacker') {\n        return undefined;\n    }\n    for (const subPlan of instructionPlan.plans) {\n        const foundPlan = findInstructionPlan(subPlan, predicate);\n        if (foundPlan) {\n            return foundPlan;\n        }\n    }\n    return undefined;\n}\n\n/**\n * Checks if every instruction plan in the tree satisfies the given predicate.\n *\n * This function performs a depth-first traversal through the instruction plan tree,\n * returning `true` only if the predicate returns `true` for every plan in the tree\n * (including the root plan and all nested plans).\n *\n * @param instructionPlan - The instruction plan tree to check.\n * @param predicate - A function that returns `true` if the plan satisfies the condition.\n * @return `true` if every plan in the tree satisfies the predicate, `false` otherwise.\n *\n * @example\n * Checking if all plans are divisible.\n * ```ts\n * const plan = sequentialInstructionPlan([\n *   parallelInstructionPlan([instructionA, instructionB]),\n *   sequentialInstructionPlan([instructionC, instructionD]),\n * ]);\n *\n * const allDivisible = everyInstructionPlan(\n *   plan,\n *   (p) => p.kind !== 'sequential' || p.divisible,\n * );\n * // Returns true because all sequential plans are divisible.\n * ```\n *\n * @example\n * Checking if all single instructions use a specific program.\n * ```ts\n * const plan = parallelInstructionPlan([instructionA, instructionB, instructionC]);\n *\n * const allUseSameProgram = everyInstructionPlan(\n *   plan,\n *   (p) => p.kind !== 'single' || p.instruction.programAddress === myProgramAddress,\n * );\n * ```\n *\n * @see {@link InstructionPlan}\n * @see {@link findInstructionPlan}\n * @see {@link transformInstructionPlan}\n * @see {@link flattenInstructionPlan}\n */\nexport function everyInstructionPlan(\n    instructionPlan: InstructionPlan,\n    predicate: (plan: InstructionPlan) => boolean,\n): boolean {\n    if (!predicate(instructionPlan)) {\n        return false;\n    }\n    if (instructionPlan.kind === 'single' || instructionPlan.kind === 'messagePacker') {\n        return true;\n    }\n    return instructionPlan.plans.every(p => everyInstructionPlan(p, predicate));\n}\n\n/**\n * Transforms an instruction plan tree using a bottom-up approach.\n *\n * This function recursively traverses the instruction plan tree, applying the\n * transformation function to each plan. The transformation is applied bottom-up,\n * meaning nested plans are transformed first, then the parent plans receive\n * the already-transformed children before being transformed themselves.\n *\n * All transformed plans are frozen using `Object.freeze` to ensure immutability.\n *\n * @param instructionPlan - The instruction plan tree to transform.\n * @param fn - A function that transforms each plan and returns a new plan.\n * @return A new transformed instruction plan tree.\n *\n * @example\n * Making all sequential plans non-divisible to ensure atomicity.\n * ```ts\n * const plan = sequentialInstructionPlan([instructionA, instructionB]);\n *\n * const transformed = transformInstructionPlan(plan, (p) => {\n *   if (p.kind === 'sequential' && p.divisible) {\n *     return nonDivisibleSequentialInstructionPlan(p.plans);\n *   }\n *   return p;\n * });\n * ```\n *\n * @example\n * Filtering out debug instructions before production execution.\n * ```ts\n * const plan = sequentialInstructionPlan([instructionA, debugInstruction, instructionB]);\n *\n * const transformed = transformInstructionPlan(plan, (p) => {\n *   if (p.kind === 'sequential' || p.kind === 'parallel') {\n *     return { ...p, plans: p.plans.filter((p) => !isDebugInstruction(p)) };\n *   }\n *   return p;\n * });\n * ```\n *\n * @see {@link InstructionPlan}\n * @see {@link findInstructionPlan}\n * @see {@link everyInstructionPlan}\n * @see {@link flattenInstructionPlan}\n */\nexport function transformInstructionPlan(\n    instructionPlan: InstructionPlan,\n    fn: (plan: InstructionPlan) => InstructionPlan,\n): InstructionPlan {\n    if (instructionPlan.kind === 'single' || instructionPlan.kind === 'messagePacker') {\n        return Object.freeze(fn(instructionPlan));\n    }\n    return Object.freeze(\n        fn(\n            Object.freeze({\n                ...instructionPlan,\n                plans: instructionPlan.plans.map(p => transformInstructionPlan(p, fn)),\n            }),\n        ),\n    );\n}\n\n/**\n * Retrieves all individual {@link SingleInstructionPlan} and {@link MessagePackerInstructionPlan}\n * instances from an instruction plan tree.\n *\n * This function recursively traverses any nested structure of instruction plans and extracts\n * all the leaf plans they contain. It's useful when you need to access all the individual\n * instructions or message packers that will be executed, regardless of their organization\n * in the plan tree (parallel or sequential).\n *\n * @param instructionPlan - The instruction plan to extract leaf plans from\n * @returns An array of all single and message packer instruction plans contained in the tree\n *\n * @example\n * ```ts\n * const plan = parallelInstructionPlan([\n *   sequentialInstructionPlan([instructionA, instructionB]),\n *   nonDivisibleSequentialInstructionPlan([instructionC, instructionD]),\n *   instructionE,\n * ]);\n *\n * const leafPlans = flattenInstructionPlan(plan);\n * // Array of `SingleInstructionPlan` containing:\n * // instructionA, instructionB, instructionC, instructionD and instructionE.\n * ```\n *\n * @see {@link InstructionPlan}\n * @see {@link findInstructionPlan}\n * @see {@link everyInstructionPlan}\n * @see {@link transformInstructionPlan}\n */\nexport function flattenInstructionPlan(\n    instructionPlan: InstructionPlan,\n): (MessagePackerInstructionPlan | SingleInstructionPlan)[] {\n    if (instructionPlan.kind === 'single' || instructionPlan.kind === 'messagePacker') {\n        return [instructionPlan];\n    }\n    return instructionPlan.plans.flatMap(flattenInstructionPlan);\n}\n\n/**\n * Creates a {@link MessagePackerInstructionPlan} that packs instructions\n * such that each instruction consumes as many bytes as possible from the given\n * `totalLength` while still being able to fit into the given transaction messages.\n *\n * This is particularly useful for instructions that write data to accounts and must\n * span multiple transactions due to their size limit.\n *\n * This message packer will first call `getInstruction` with a length of zero to\n * determine the base size of the instruction before figuring out how many\n * additional bytes can be packed into the transaction message. That remaining space\n * will then be used to call `getInstruction` again with the appropriate length.\n *\n * @param getInstruction - A function that returns an instruction for a given offset and length.\n * @param totalLength - The total length of the data to write, in bytes.\n *\n * @example\n * ```ts\n * const plan = getLinearMessagePackerInstructionPlan({\n *   totalLength: dataToWrite.length,\n *   getInstruction: (offset, length) =>\n *     getWriteInstruction({\n *       offset,\n *       data: dataToWrite.slice(offset, offset + length),\n *     }),\n * });\n * plan satisfies MessagePackerInstructionPlan;\n * ```\n *\n * @see {@link MessagePackerInstructionPlan}\n */\nexport function getLinearMessagePackerInstructionPlan({\n    getInstruction,\n    totalLength: totalBytes,\n}: {\n    getInstruction: (offset: number, length: number) => Instruction;\n    totalLength: number;\n}): MessagePackerInstructionPlan {\n    return Object.freeze({\n        getMessagePacker: () => {\n            let offset = 0;\n            return Object.freeze({\n                done: () => offset >= totalBytes,\n                packMessageToCapacity: (\n                    message: TransactionMessage & TransactionMessageWithFeePayer,\n                    config?: { maxInstructions?: number },\n                ) => {\n                    if (offset >= totalBytes) {\n                        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE);\n                    }\n                    assertValidMaxInstructionsPerTransaction(config?.maxInstructions);\n                    const maxInstructions = resolveMaxInstructions(config?.maxInstructions);\n                    assertMaxInstructionsPerTransaction(message.instructions.length + 1, maxInstructions);\n\n                    const messageSizeWithBaseInstruction = getTransactionMessageSize(\n                        appendTransactionMessageInstruction(getInstruction(offset, 0), message),\n                    );\n                    const freeSpace =\n                        getTransactionMessageSizeLimit(message) -\n                        messageSizeWithBaseInstruction /* Includes the base instruction (length: 0). */ -\n                        1; /* Leeway for shortU16 numbers in transaction headers. */\n\n                    if (freeSpace <= 0) {\n                        const messageSize = getTransactionMessageSize(message);\n                        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN, {\n                            // (+1) We need to pack at least one byte of data otherwise\n                            // there is no point packing the base instruction alone.\n                            numBytesRequired: messageSizeWithBaseInstruction - messageSize + 1,\n                            // (-1) Leeway for shortU16 numbers in transaction headers.\n                            numFreeBytes: getTransactionMessageSizeLimit(message) - messageSize - 1,\n                        });\n                    }\n\n                    const length = Math.min(totalBytes - offset, freeSpace);\n                    const instruction = getInstruction(offset, length);\n                    offset += length;\n                    return appendTransactionMessageInstruction(instruction, message);\n                },\n            });\n        },\n        kind: 'messagePacker',\n        planType: 'instructionPlan',\n    });\n}\n\n/**\n * Creates a {@link MessagePackerInstructionPlan} from a list of instructions.\n *\n * This can be useful to prepare a set of instructions that can be iterated over\n * — e.g. to pack a list of instructions that gradually reallocate the size of an account\n * one `REALLOC_LIMIT` (10'240 bytes) at a time.\n *\n * @example\n * ```ts\n * const plan = getMessagePackerInstructionPlanFromInstructions([\n *   instructionA,\n *   instructionB,\n *   instructionC,\n * ]);\n *\n * const messagePacker = plan.getMessagePacker();\n * firstTransactionMessage = messagePacker.packMessageToCapacity(firstTransactionMessage);\n * // Contains instruction A and instruction B.\n * secondTransactionMessage = messagePacker.packMessageToCapacity(secondTransactionMessage);\n * // Contains instruction C.\n * messagePacker.done(); // true\n * ```\n *\n * @see {@link MessagePackerInstructionPlan}\n * @see {@link getReallocMessagePackerInstructionPlan}\n */\nexport function getMessagePackerInstructionPlanFromInstructions<TInstruction extends Instruction = Instruction>(\n    instructions: TInstruction[],\n): MessagePackerInstructionPlan {\n    return Object.freeze({\n        getMessagePacker: () => {\n            let instructionIndex = 0;\n            return Object.freeze({\n                done: () => instructionIndex >= instructions.length,\n                packMessageToCapacity: (\n                    message: TransactionMessage & TransactionMessageWithFeePayer,\n                    config?: { maxInstructions?: number },\n                ) => {\n                    if (instructionIndex >= instructions.length) {\n                        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE);\n                    }\n\n                    const originalMessageSize = getTransactionMessageSize(message);\n                    assertValidMaxInstructionsPerTransaction(config?.maxInstructions);\n                    const maxInstructions = resolveMaxInstructions(config?.maxInstructions);\n\n                    // We must be able to fit at least the next instruction; throw otherwise. Once at\n                    // least one has been packed, hitting the limit simply stops packing into this message.\n                    assertMaxInstructionsPerTransaction(message.instructions.length + 1, maxInstructions);\n\n                    for (let index = instructionIndex; index < instructions.length; index++) {\n                        // Stop once the message is full, before compiling a message that exceeds the\n                        // instruction limit (which would throw). The assertion above guarantees at least\n                        // the first instruction fits, so reaching the limit here means a graceful stop.\n                        if (message.instructions.length >= maxInstructions) {\n                            instructionIndex = index;\n                            return message;\n                        }\n\n                        const nextMessage = appendTransactionMessageInstruction(instructions[index], message);\n                        const messageSize = getTransactionMessageSize(nextMessage);\n\n                        if (messageSize > getTransactionMessageSizeLimit(nextMessage)) {\n                            if (index === instructionIndex) {\n                                // The count was already asserted above, so reaching here on the first\n                                // instruction can only be due to the transaction size limit.\n                                throw new SolanaError(\n                                    SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN,\n                                    {\n                                        numBytesRequired: messageSize - originalMessageSize,\n                                        numFreeBytes: getTransactionMessageSizeLimit(nextMessage) - originalMessageSize,\n                                    },\n                                );\n                            }\n                            instructionIndex = index;\n                            return message;\n                        }\n                        message = nextMessage;\n                    }\n\n                    instructionIndex = instructions.length;\n                    return message;\n                },\n            });\n        },\n        kind: 'messagePacker',\n        planType: 'instructionPlan',\n    });\n}\n\nconst REALLOC_LIMIT = 10_240;\n\n/**\n * Creates a {@link MessagePackerInstructionPlan} that packs a list of realloc instructions.\n *\n * That is, it splits instruction by chunks of `REALLOC_LIMIT` (10'240) bytes until\n * the given total size is reached.\n *\n * @example\n * ```ts\n * const plan = getReallocMessagePackerInstructionPlan({\n *   totalSize: additionalDataSize,\n *   getInstruction: (size) => getExtendInstruction({ length: size }),\n * });\n * ```\n *\n * @see {@link MessagePackerInstructionPlan}\n */\nexport function getReallocMessagePackerInstructionPlan({\n    getInstruction,\n    totalSize,\n}: {\n    getInstruction: (size: number) => Instruction;\n    totalSize: number;\n}): MessagePackerInstructionPlan {\n    const numberOfInstructions = Math.ceil(totalSize / REALLOC_LIMIT);\n    const lastInstructionSize = totalSize % REALLOC_LIMIT;\n    const instructions = new Array(numberOfInstructions)\n        .fill(0)\n        .map((_, i) => getInstruction(i === numberOfInstructions - 1 ? lastInstructionSize : REALLOC_LIMIT));\n\n    return getMessagePackerInstructionPlanFromInstructions(instructions);\n}\n","import { SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND, SolanaError } from '@solana/errors';\nimport { type Instruction } from '@solana/instructions';\nimport {\n    appendTransactionMessageInstruction,\n    appendTransactionMessageInstructions,\n    TransactionMessage,\n    TransactionMessageWithFeePayer,\n} from '@solana/transaction-messages';\n\nimport { flattenInstructionPlan, InstructionPlan } from './instruction-plan';\n\n/**\n * A helper type to append instructions to a transaction message\n * without losing type information about the current instructions.\n */\n\ntype AppendTransactionMessageInstructions<TTransactionMessage extends TransactionMessage> = ReturnType<\n    typeof appendTransactionMessageInstructions<TTransactionMessage, Instruction[]>\n>;\n\n/**\n * Appends all instructions from an instruction plan to a transaction message.\n *\n * This function flattens the instruction plan into its leaf plans and sequentially\n * appends each instruction to the provided transaction message. It handles both\n * single instructions and message packer plans.\n *\n * Note that any {@link MessagePackerInstructionPlan} is assumed to only append\n * instructions. If it modifies other properties of the transaction message, the\n * type of the returned transaction message may not accurately reflect those changes.\n *\n * @typeParam TTransactionMessage - The type of transaction message being modified.\n *\n * @param transactionMessage - The transaction message to append instructions to.\n * @param instructionPlan - The instruction plan containing the instructions to append.\n * @returns The transaction message with all instructions from the plan appended.\n *\n * @example\n * Appending a simple instruction plan to a transaction message.\n * ```ts\n * import { appendTransactionMessageInstructionPlan } from '@solana/instruction-plans';\n * import { createTransactionMessage, setTransactionMessageFeePayer } from '@solana/transaction-messages';\n *\n * const message = setTransactionMessageFeePayer(feePayer, createTransactionMessage({ version: 0 }));\n * const plan = singleInstructionPlan(myInstruction);\n *\n * const messageWithInstructions = appendTransactionMessageInstructionPlan(message, plan);\n * ```\n *\n * @example\n * Appending a sequential instruction plan.\n * ```ts\n * const plan = sequentialInstructionPlan([instructionA, instructionB, instructionC]);\n * const messageWithInstructions = appendTransactionMessageInstructionPlan(message, plan);\n * ```\n *\n * @see {@link InstructionPlan}\n * @see {@link flattenInstructionPlan}\n */\nexport function appendTransactionMessageInstructionPlan<\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer,\n>(\n    instructionPlan: InstructionPlan,\n    transactionMessage: TTransactionMessage,\n): AppendTransactionMessageInstructions<TTransactionMessage> {\n    type Out = AppendTransactionMessageInstructions<TTransactionMessage>;\n\n    const leafInstructionPlans = flattenInstructionPlan(instructionPlan);\n\n    return leafInstructionPlans.reduce(\n        (messageSoFar, plan) => {\n            const kind = plan.kind;\n            if (kind === 'single') {\n                return appendTransactionMessageInstruction(plan.instruction, messageSoFar) as unknown as Out;\n            }\n            if (kind === 'messagePacker') {\n                const messagerPacker = plan.getMessagePacker();\n                let nextMessage: Out = messageSoFar;\n                while (!messagerPacker.done()) {\n                    nextMessage = messagerPacker.packMessageToCapacity(nextMessage) as Out;\n                }\n                return nextMessage;\n            }\n            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND, {\n                kind,\n            });\n        },\n        transactionMessage as unknown as Out,\n    );\n}\n","import { SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN, SolanaError } from '@solana/errors';\nimport { TransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\n\n/**\n * A set of transaction messages with constraints on how they can be executed.\n *\n * This is structured as a recursive tree of plans to allow for\n * parallel execution, sequential execution and combinations of both.\n *\n * Namely, the following plans are supported:\n * - {@link SingleTransactionPlan} - A plan that contains a single transaction message.\n *   This is the simplest leaf in this tree.\n * - {@link ParallelTransactionPlan} - A plan that contains other plans that\n *   can be executed in parallel.\n * - {@link SequentialTransactionPlan} - A plan that contains other plans that\n *   must be executed sequentially. It also defines whether the plan is divisible\n *   meaning that transaction messages inside it can be split into separate batches.\n *\n * Helpers are provided for each of these plans to make it easier to create them.\n *\n * @example\n * ```ts\n * const myTransactionPlan: TransactionPlan = parallelTransactionPlan([\n *   sequentialTransactionPlan([messageA, messageB]),\n *   messageC,\n * ]);\n * ```\n *\n * @see {@link SingleTransactionPlan}\n * @see {@link ParallelTransactionPlan}\n * @see {@link SequentialTransactionPlan}\n */\nexport type TransactionPlan = ParallelTransactionPlan | SequentialTransactionPlan | SingleTransactionPlan;\n\n/**\n * A plan wrapping other plans that must be executed sequentially.\n *\n * It also defines whether nested plans are divisible — meaning that\n * the transaction messages inside them can be split into separate batches.\n * When `divisible` is `false`, the transaction messages inside the plan should\n * all be executed atomically — usually in a transaction bundle.\n *\n * You may use the {@link sequentialTransactionPlan} and {@link nonDivisibleSequentialTransactionPlan}\n * helpers to create objects of this type.\n *\n * @example\n * Simple sequential plan with two transaction messages.\n * ```ts\n * const plan = sequentialTransactionPlan([messageA, messageB]);\n * plan satisfies SequentialTransactionPlan;\n * ```\n *\n * @example\n * Non-divisible sequential plan with two transaction messages.\n * ```ts\n * const plan = nonDivisibleSequentialTransactionPlan([messageA, messageB]);\n * plan satisfies SequentialTransactionPlan & { divisible: false };\n * ```\n *\n * @example\n * Sequential plan with nested parallel plans.\n * Here, messages A and B can be executed in parallel, but they must both be finalized\n * before messages C and D can be sent — which can also be executed in parallel.\n * ```ts\n * const plan = sequentialTransactionPlan([\n *   parallelTransactionPlan([messageA, messageB]),\n *   parallelTransactionPlan([messageC, messageD]),\n * ]);\n * ```\n *\n * @see {@link sequentialTransactionPlan}\n * @see {@link nonDivisibleSequentialTransactionPlan}\n */\nexport type SequentialTransactionPlan = Readonly<{\n    divisible: boolean;\n    kind: 'sequential';\n    planType: 'transactionPlan';\n    plans: TransactionPlan[];\n}>;\n\n/**\n * A plan wrapping other plans that can be executed in parallel.\n *\n * This means direct children of this plan can be executed in separate\n * parallel transactions without causing any side effects.\n * However, the children themselves can define additional constraints\n * for that specific branch of the tree — such as the {@link SequentialTransactionPlan}.\n *\n * You may use the {@link parallelTransactionPlan} helper to create objects of this type.\n *\n * @example\n * Simple parallel plan with two transaction messages.\n * ```ts\n * const plan = parallelTransactionPlan([messageA, messageB]);\n * plan satisfies ParallelTransactionPlan;\n * ```\n *\n * @example\n * Parallel plan with nested sequential plans.\n * Here, messages A and B must be executed sequentially and so must messages C and D,\n * but both pairs can be executed in parallel.\n * ```ts\n * const plan = parallelTransactionPlan([\n *   sequentialTransactionPlan([messageA, messageB]),\n *   sequentialTransactionPlan([messageC, messageD]),\n * ]);\n * plan satisfies ParallelTransactionPlan;\n * ```\n *\n * @see {@link parallelTransactionPlan}\n */\nexport type ParallelTransactionPlan = Readonly<{\n    kind: 'parallel';\n    planType: 'transactionPlan';\n    plans: TransactionPlan[];\n}>;\n\n/**\n * A plan that contains a single transaction message.\n *\n * This is a simple transaction message wrapper that transforms a message into a plan.\n *\n * You may use the {@link singleTransactionPlan} helper to create objects of this type.\n *\n * @example\n * ```ts\n * const plan = singleTransactionPlan(transactionMessage);\n * plan satisfies SingleTransactionPlan;\n * ```\n *\n * @see {@link singleTransactionPlan}\n */\nexport type SingleTransactionPlan<\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n> = Readonly<{\n    kind: 'single';\n    message: TTransactionMessage;\n    planType: 'transactionPlan';\n}>;\n\n/**\n * Creates a {@link ParallelTransactionPlan} from an array of nested plans.\n *\n * It can accept {@link TransactionMessage} objects directly, which will be wrapped\n * in {@link SingleTransactionPlan | SingleTransactionPlans} automatically.\n *\n * @example\n * Using explicit {@link SingleTransactionPlan | SingleTransactionPlans}.\n * ```ts\n * const plan = parallelTransactionPlan([\n *   singleTransactionPlan(messageA),\n *   singleTransactionPlan(messageB),\n * ]);\n * ```\n *\n * @example\n * Using {@link TransactionMessage | TransactionMessages} directly.\n * ```ts\n * const plan = parallelTransactionPlan([messageA, messageB]);\n * ```\n *\n * @see {@link ParallelTransactionPlan}\n */\nexport function parallelTransactionPlan(\n    plans: (TransactionPlan | (TransactionMessage & TransactionMessageWithFeePayer))[],\n): ParallelTransactionPlan {\n    return Object.freeze({ kind: 'parallel', planType: 'transactionPlan', plans: parseSingleTransactionPlans(plans) });\n}\n\n/**\n * Creates a divisible {@link SequentialTransactionPlan} from an array of nested plans.\n *\n * It can accept {@link TransactionMessage} objects directly, which will be wrapped\n * in {@link SingleTransactionPlan | SingleTransactionPlans} automatically.\n *\n * @example\n * Using explicit {@link SingleTransactionPlan | SingleTransactionPlans}.\n * ```ts\n * const plan = sequentialTransactionPlan([\n *   singleTransactionPlan(messageA),\n *   singleTransactionPlan(messageB),\n * ]);\n * ```\n *\n * @example\n * Using {@link TransactionMessage | TransactionMessages} directly.\n * ```ts\n * const plan = sequentialTransactionPlan([messageA, messageB]);\n * ```\n *\n * @see {@link SequentialTransactionPlan}\n */\nexport function sequentialTransactionPlan(\n    plans: (TransactionPlan | (TransactionMessage & TransactionMessageWithFeePayer))[],\n): SequentialTransactionPlan & { divisible: true } {\n    return Object.freeze({\n        divisible: true,\n        kind: 'sequential',\n        planType: 'transactionPlan',\n        plans: parseSingleTransactionPlans(plans),\n    });\n}\n\n/**\n * Creates a non-divisible {@link SequentialTransactionPlan} from an array of nested plans.\n *\n * It can accept {@link TransactionMessage} objects directly, which will be wrapped\n * in {@link SingleTransactionPlan | SingleTransactionPlans} automatically.\n *\n * @example\n * Using explicit {@link SingleTransactionPlan | SingleTransactionPlans}.\n * ```ts\n * const plan = nonDivisibleSequentialTransactionPlan([\n *   singleTransactionPlan(messageA),\n *   singleTransactionPlan(messageB),\n * ]);\n * ```\n *\n * @example\n * Using {@link TransactionMessage | TransactionMessages} directly.\n * ```ts\n * const plan = nonDivisibleSequentialTransactionPlan([messageA, messageB]);\n * ```\n *\n * @see {@link SequentialTransactionPlan}\n */\nexport function nonDivisibleSequentialTransactionPlan(\n    plans: (TransactionPlan | (TransactionMessage & TransactionMessageWithFeePayer))[],\n): SequentialTransactionPlan & { divisible: false } {\n    return Object.freeze({\n        divisible: false,\n        kind: 'sequential',\n        planType: 'transactionPlan',\n        plans: parseSingleTransactionPlans(plans),\n    });\n}\n\n/**\n * Creates a {@link SingleTransactionPlan} from a {@link TransactionMessage} object.\n *\n * @example\n * ```ts\n * const plan = singleTransactionPlan(transactionMessage);\n * plan satisfies SingleTransactionPlan;\n * ```\n *\n * @see {@link SingleTransactionPlan}\n */\nexport function singleTransactionPlan<\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(transactionMessage: TTransactionMessage): SingleTransactionPlan<TTransactionMessage> {\n    return Object.freeze({ kind: 'single', message: transactionMessage, planType: 'transactionPlan' });\n}\n\nfunction parseSingleTransactionPlans(\n    plans: (TransactionPlan | (TransactionMessage & TransactionMessageWithFeePayer))[],\n): TransactionPlan[] {\n    return plans.map(plan => ('kind' in plan ? plan : singleTransactionPlan(plan)));\n}\n\n/**\n * Checks if the given value is a {@link TransactionPlan}.\n *\n * This type guard checks the `planType` property to determine if the value\n * is a transaction plan. This is useful when you have a value that could be\n * an {@link InstructionPlan}, {@link TransactionPlan}, or {@link TransactionPlanResult}\n * and need to narrow the type.\n *\n * @param value - The value to check.\n * @return `true` if the value is a transaction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * function processItem(item: InstructionPlan | TransactionPlan | TransactionPlanResult) {\n *   if (isTransactionPlan(item)) {\n *     // item is narrowed to TransactionPlan\n *     console.log(item.kind);\n *   }\n * }\n * ```\n *\n * @see {@link TransactionPlan}\n * @see {@link isInstructionPlan}\n * @see {@link isTransactionPlanResult}\n */\nexport function isTransactionPlan(value: unknown): value is TransactionPlan {\n    return (\n        typeof value === 'object' &&\n        value !== null &&\n        'planType' in value &&\n        typeof value.planType === 'string' &&\n        value.planType === 'transactionPlan'\n    );\n}\n\n/**\n * Checks if the given transaction plan is a {@link SingleTransactionPlan}.\n *\n * @param plan - The transaction plan to check.\n * @return `true` if the plan is a single transaction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: TransactionPlan = singleTransactionPlan(transactionMessage);\n *\n * if (isSingleTransactionPlan(plan)) {\n *   console.log(plan.message); // TypeScript knows this is a SingleTransactionPlan.\n * }\n * ```\n *\n * @see {@link SingleTransactionPlan}\n * @see {@link assertIsSingleTransactionPlan}\n */\nexport function isSingleTransactionPlan(plan: TransactionPlan): plan is SingleTransactionPlan {\n    return plan.kind === 'single';\n}\n\n/**\n * Asserts that the given transaction plan is a {@link SingleTransactionPlan}.\n *\n * @param plan - The transaction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN` if the plan is not a single transaction plan.\n *\n * @example\n * ```ts\n * const plan: TransactionPlan = singleTransactionPlan(transactionMessage);\n *\n * assertIsSingleTransactionPlan(plan);\n * console.log(plan.message); // TypeScript knows this is a SingleTransactionPlan.\n * ```\n *\n * @see {@link SingleTransactionPlan}\n * @see {@link isSingleTransactionPlan}\n */\nexport function assertIsSingleTransactionPlan(plan: TransactionPlan): asserts plan is SingleTransactionPlan {\n    if (!isSingleTransactionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN, {\n            actualKind: plan.kind,\n            expectedKind: 'single',\n            transactionPlan: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan is a {@link SequentialTransactionPlan}.\n *\n * @param plan - The transaction plan to check.\n * @return `true` if the plan is a sequential transaction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: TransactionPlan = sequentialTransactionPlan([messageA, messageB]);\n *\n * if (isSequentialTransactionPlan(plan)) {\n *   console.log(plan.divisible); // TypeScript knows this is a SequentialTransactionPlan.\n * }\n * ```\n *\n * @see {@link SequentialTransactionPlan}\n * @see {@link assertIsSequentialTransactionPlan}\n */\nexport function isSequentialTransactionPlan(plan: TransactionPlan): plan is SequentialTransactionPlan {\n    return plan.kind === 'sequential';\n}\n\n/**\n * Asserts that the given transaction plan is a {@link SequentialTransactionPlan}.\n *\n * @param plan - The transaction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN` if the plan is not a sequential transaction plan.\n *\n * @example\n * ```ts\n * const plan: TransactionPlan = sequentialTransactionPlan([messageA, messageB]);\n *\n * assertIsSequentialTransactionPlan(plan);\n * console.log(plan.divisible); // TypeScript knows this is a SequentialTransactionPlan.\n * ```\n *\n * @see {@link SequentialTransactionPlan}\n * @see {@link isSequentialTransactionPlan}\n */\nexport function assertIsSequentialTransactionPlan(plan: TransactionPlan): asserts plan is SequentialTransactionPlan {\n    if (!isSequentialTransactionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN, {\n            actualKind: plan.kind,\n            expectedKind: 'sequential',\n            transactionPlan: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan is a non-divisible {@link SequentialTransactionPlan}.\n *\n * A non-divisible sequential plan requires all its transaction messages to be executed\n * atomically — usually in a transaction bundle.\n *\n * @param plan - The transaction plan to check.\n * @return `true` if the plan is a non-divisible sequential transaction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: TransactionPlan = nonDivisibleSequentialTransactionPlan([messageA, messageB]);\n *\n * if (isNonDivisibleSequentialTransactionPlan(plan)) {\n *   // All transaction messages must be executed atomically.\n * }\n * ```\n *\n * @see {@link SequentialTransactionPlan}\n * @see {@link assertIsNonDivisibleSequentialTransactionPlan}\n */\nexport function isNonDivisibleSequentialTransactionPlan(\n    plan: TransactionPlan,\n): plan is SequentialTransactionPlan & { divisible: false } {\n    return plan.kind === 'sequential' && plan.divisible === false;\n}\n\n/**\n * Asserts that the given transaction plan is a non-divisible {@link SequentialTransactionPlan}.\n *\n * A non-divisible sequential plan requires all its transaction messages to be executed\n * atomically — usually in a transaction bundle.\n *\n * @param plan - The transaction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN` if the plan is not a non-divisible sequential transaction plan.\n *\n * @example\n * ```ts\n * const plan: TransactionPlan = nonDivisibleSequentialTransactionPlan([messageA, messageB]);\n *\n * assertIsNonDivisibleSequentialTransactionPlan(plan);\n * // All transaction messages must be executed atomically.\n * ```\n *\n * @see {@link SequentialTransactionPlan}\n * @see {@link isNonDivisibleSequentialTransactionPlan}\n */\nexport function assertIsNonDivisibleSequentialTransactionPlan(\n    plan: TransactionPlan,\n): asserts plan is SequentialTransactionPlan & { divisible: false } {\n    if (!isNonDivisibleSequentialTransactionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN, {\n            actualKind: plan.kind === 'sequential' ? 'divisible sequential' : plan.kind,\n            expectedKind: 'non-divisible sequential',\n            transactionPlan: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan is a {@link ParallelTransactionPlan}.\n *\n * @param plan - The transaction plan to check.\n * @return `true` if the plan is a parallel transaction plan, `false` otherwise.\n *\n * @example\n * ```ts\n * const plan: TransactionPlan = parallelTransactionPlan([messageA, messageB]);\n *\n * if (isParallelTransactionPlan(plan)) {\n *   console.log(plan.plans.length); // TypeScript knows this is a ParallelTransactionPlan.\n * }\n * ```\n *\n * @see {@link ParallelTransactionPlan}\n * @see {@link assertIsParallelTransactionPlan}\n */\nexport function isParallelTransactionPlan(plan: TransactionPlan): plan is ParallelTransactionPlan {\n    return plan.kind === 'parallel';\n}\n\n/**\n * Asserts that the given transaction plan is a {@link ParallelTransactionPlan}.\n *\n * @param plan - The transaction plan to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN` if the plan is not a parallel transaction plan.\n *\n * @example\n * ```ts\n * const plan: TransactionPlan = parallelTransactionPlan([messageA, messageB]);\n *\n * assertIsParallelTransactionPlan(plan);\n * console.log(plan.plans.length); // TypeScript knows this is a ParallelTransactionPlan.\n * ```\n *\n * @see {@link ParallelTransactionPlan}\n * @see {@link isParallelTransactionPlan}\n */\nexport function assertIsParallelTransactionPlan(plan: TransactionPlan): asserts plan is ParallelTransactionPlan {\n    if (!isParallelTransactionPlan(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN, {\n            actualKind: plan.kind,\n            expectedKind: 'parallel',\n            transactionPlan: plan,\n        });\n    }\n}\n\n/**\n * Retrieves all individual {@link SingleTransactionPlan} instances from a transaction plan tree.\n *\n * This function recursively traverses any nested structure of transaction plans and extracts\n * all the single transaction plans they contain. It's useful when you need to access all\n * the actual transaction messages that will be executed, regardless of their organization\n * in the plan tree (parallel or sequential).\n *\n * @param transactionPlan - The transaction plan to extract single plans from\n * @returns An array of all single transaction plans contained in the tree\n *\n * @example\n * ```ts\n * const plan = parallelTransactionPlan([\n *   sequentialTransactionPlan([messageA, messageB]),\n *   nonDivisibleSequentialTransactionPlan([messageC, messageD]),\n *   messageE,\n * ]);\n *\n * const singlePlans = flattenTransactionPlan(plan);\n * // Array of `SingleTransactionPlan` containing:\n * // messageA, messageB, messageC and messageD.\n *\n * @see {@link TransactionPlan}\n * @see {@link findTransactionPlan}\n * @see {@link everyTransactionPlan}\n * @see {@link transformTransactionPlan}\n * ```\n */\nexport function flattenTransactionPlan(transactionPlan: TransactionPlan): SingleTransactionPlan[] {\n    if (transactionPlan.kind === 'single') {\n        return [transactionPlan];\n    }\n    return transactionPlan.plans.flatMap(flattenTransactionPlan);\n}\n\n/**\n * Finds the first transaction plan in the tree that matches the given predicate.\n *\n * This function performs a depth-first search through the transaction plan tree,\n * returning the first plan that satisfies the predicate. It checks the root plan\n * first, then recursively searches through nested plans.\n *\n * @param transactionPlan - The transaction plan tree to search.\n * @param predicate - A function that returns `true` for the plan to find.\n * @return The first matching transaction plan, or `undefined` if no match is found.\n *\n * @example\n * Finding a non-divisible sequential plan.\n * ```ts\n * const plan = parallelTransactionPlan([\n *   sequentialTransactionPlan([messageA, messageB]),\n *   nonDivisibleSequentialTransactionPlan([messageC, messageD]),\n * ]);\n *\n * const nonDivisible = findTransactionPlan(\n *   plan,\n *   (p) => p.kind === 'sequential' && !p.divisible,\n * );\n * // Returns the non-divisible sequential plan containing messageC and messageD.\n * ```\n *\n * @example\n * Finding a specific single transaction plan.\n * ```ts\n * const plan = sequentialTransactionPlan([messageA, messageB, messageC]);\n *\n * const found = findTransactionPlan(\n *   plan,\n *   (p) => p.kind === 'single' && p.message === messageB,\n * );\n * // Returns the SingleTransactionPlan wrapping messageB.\n * ```\n *\n * @see {@link TransactionPlan}\n * @see {@link everyTransactionPlan}\n * @see {@link transformTransactionPlan}\n * @see {@link flattenTransactionPlan}\n */\nexport function findTransactionPlan(\n    transactionPlan: TransactionPlan,\n    predicate: (plan: TransactionPlan) => boolean,\n): TransactionPlan | undefined {\n    if (predicate(transactionPlan)) {\n        return transactionPlan;\n    }\n    if (transactionPlan.kind === 'single') {\n        return undefined;\n    }\n    for (const subPlan of transactionPlan.plans) {\n        const foundPlan = findTransactionPlan(subPlan, predicate);\n        if (foundPlan) {\n            return foundPlan;\n        }\n    }\n    return undefined;\n}\n\n/**\n * Checks if every transaction plan in the tree satisfies the given predicate.\n *\n * This function performs a depth-first traversal through the transaction plan tree,\n * returning `true` only if the predicate returns `true` for every plan in the tree\n * (including the root plan and all nested plans).\n *\n * @param transactionPlan - The transaction plan tree to check.\n * @param predicate - A function that returns `true` if the plan satisfies the condition.\n * @return `true` if every plan in the tree satisfies the predicate, `false` otherwise.\n *\n * @example\n * Checking if all plans are divisible.\n * ```ts\n * const plan = sequentialTransactionPlan([\n *   parallelTransactionPlan([messageA, messageB]),\n *   sequentialTransactionPlan([messageC, messageD]),\n * ]);\n *\n * const allDivisible = everyTransactionPlan(\n *   plan,\n *   (p) => p.kind !== 'sequential' || p.divisible,\n * );\n * // Returns true because all sequential plans are divisible.\n * ```\n *\n * @example\n * Checking if all single plans have a specific fee payer.\n * ```ts\n * const plan = parallelTransactionPlan([messageA, messageB, messageC]);\n *\n * const allUseSameFeePayer = everyTransactionPlan(\n *   plan,\n *   (p) => p.kind !== 'single' || p.message.feePayer.address === myFeePayer,\n * );\n * ```\n *\n * @see {@link TransactionPlan}\n * @see {@link findTransactionPlan}\n * @see {@link transformTransactionPlan}\n * @see {@link flattenTransactionPlan}\n */\nexport function everyTransactionPlan(\n    transactionPlan: TransactionPlan,\n    predicate: (plan: TransactionPlan) => boolean,\n): boolean {\n    if (!predicate(transactionPlan)) {\n        return false;\n    }\n    if (transactionPlan.kind === 'single') {\n        return true;\n    }\n    return transactionPlan.plans.every(p => everyTransactionPlan(p, predicate));\n}\n\n/**\n * Transforms a transaction plan tree using a bottom-up approach.\n *\n * This function recursively traverses the transaction plan tree, applying the\n * transformation function to each plan. The transformation is applied bottom-up,\n * meaning nested plans are transformed first, then the parent plans receive\n * the already-transformed children before being transformed themselves.\n *\n * All transformed plans are frozen using `Object.freeze` to ensure immutability.\n *\n * @param transactionPlan - The transaction plan tree to transform.\n * @param fn - A function that transforms each plan and returns a new plan.\n * @return A new transformed transaction plan tree.\n *\n * @example\n * Removing parallelism by converting parallel plans to sequential.\n * ```ts\n * const plan = parallelTransactionPlan([messageA, messageB, messageC]);\n *\n * const transformed = transformTransactionPlan(plan, (p) => {\n *   if (p.kind === 'parallel') {\n *     return sequentialTransactionPlan(p.plans);\n *   }\n *   return p;\n * });\n * ```\n *\n * @example\n * Updating the fee payer on all transaction messages.\n * ```ts\n * const plan = parallelTransactionPlan([messageA, messageB]);\n *\n * const transformed = transformTransactionPlan(plan, (p) => {\n *   if (p.kind === 'single') {\n *     return singleTransactionPlan({ ...p.message, feePayer: newFeePayer });\n *   }\n *   return p;\n * });\n * ```\n *\n * @see {@link TransactionPlan}\n * @see {@link findTransactionPlan}\n * @see {@link everyTransactionPlan}\n * @see {@link flattenTransactionPlan}\n */\nexport function transformTransactionPlan(\n    transactionPlan: TransactionPlan,\n    fn: (plan: TransactionPlan) => TransactionPlan,\n): TransactionPlan {\n    if (transactionPlan.kind === 'single') {\n        return Object.freeze(fn(transactionPlan));\n    }\n    return Object.freeze(\n        fn(\n            Object.freeze({\n                ...transactionPlan,\n                plans: transactionPlan.plans.map(p => transformTransactionPlan(p, fn)),\n            }),\n        ),\n    );\n}\n","import type { Instruction } from '@solana/instructions';\n\nimport {\n    type InstructionPlan,\n    isInstructionPlan,\n    sequentialInstructionPlan,\n    singleInstructionPlan,\n} from './instruction-plan';\nimport {\n    isTransactionPlan,\n    sequentialTransactionPlan,\n    SingleTransactionPlan,\n    singleTransactionPlan,\n    TransactionPlan,\n} from './transaction-plan';\n\n/**\n * A flexible input type that can be used to create an {@link InstructionPlan}.\n *\n * This type accepts:\n * - A single {@link Instruction}.\n * - An existing {@link InstructionPlan}.\n * - An array of instructions and/or instruction plans.\n *\n * Use the {@link parseInstructionPlanInput} function to convert this input\n * into a proper {@link InstructionPlan}.\n *\n * @example\n * Using a single instruction.\n * ```ts\n * const input: InstructionPlanInput = myInstruction;\n * ```\n *\n * @example\n * Use as argument type in a function that will parse it into an InstructionPlan.\n * ```ts\n * function myFunction(input: InstructionPlanInput) {\n *   const plan = parseInstructionPlanInput(input);\n *   // Use the plan...\n * }\n * ```\n *\n * @see {@link parseInstructionPlanInput}\n * @see {@link InstructionPlan}\n */\nexport type InstructionPlanInput = Instruction | InstructionPlan | readonly (Instruction | InstructionPlan)[];\n\n/**\n * Parses an {@link InstructionPlanInput} and returns an {@link InstructionPlan}.\n *\n * This function handles the following input types:\n * - A single {@link Instruction} is wrapped in a {@link SingleInstructionPlan}.\n * - An existing {@link InstructionPlan} is returned as-is.\n * - An array with a single element is unwrapped and parsed recursively.\n * - An array with multiple elements is wrapped in a divisible {@link SequentialInstructionPlan}.\n *\n * @param input - The input to parse into an instruction plan.\n * @return The parsed instruction plan.\n *\n * @example\n * Parsing a single instruction.\n * ```ts\n * const plan = parseInstructionPlanInput(myInstruction);\n * // Equivalent to: singleInstructionPlan(myInstruction)\n * ```\n *\n * @example\n * Parsing an array of instructions.\n * ```ts\n * const plan = parseInstructionPlanInput([instructionA, instructionB]);\n * // Equivalent to: sequentialInstructionPlan([instructionA, instructionB])\n * ```\n *\n * @example\n * Parsing a mixed array with nested plans.\n * ```ts\n * const plan = parseInstructionPlanInput([\n *   instructionA,\n *   parallelInstructionPlan([instructionB, instructionC]),\n * ]);\n * // Returns a sequential plan containing:\n * // - A single instruction plan for instructionA.\n * // - The parallel plan for instructionB and instructionC.\n * ```\n *\n * @example\n * Single-element arrays are unwrapped.\n * ```ts\n * const plan = parseInstructionPlanInput([myInstruction]);\n * // Equivalent to: singleInstructionPlan(myInstruction)\n * ```\n *\n * @see {@link InstructionPlanInput}\n * @see {@link InstructionPlan}\n */\nexport function parseInstructionPlanInput(input: InstructionPlanInput): InstructionPlan {\n    if (Array.isArray(input) && input.length === 1) {\n        return parseInstructionPlanInput(input[0]);\n    }\n    if (Array.isArray(input)) {\n        return sequentialInstructionPlan(input.map(parseInstructionPlanInput));\n    }\n    return isInstructionPlan(input) ? input : singleInstructionPlan(input as Instruction);\n}\n\n/**\n * A flexible input type that can be used to create a {@link TransactionPlan}.\n *\n * This type accepts:\n * - A single {@link TransactionMessage} with a fee payer.\n * - An existing {@link TransactionPlan}.\n * - An array of transaction messages and/or transaction plans.\n *\n * Use the {@link parseTransactionPlanInput} function to convert this input\n * into a proper {@link TransactionPlan}.\n *\n * @example\n * Using a single transaction message.\n * ```ts\n * const input: TransactionPlanInput = myTransactionMessage;\n * ```\n *\n * @example\n * Use as argument type in a function that will parse it into a TransactionPlan.\n * ```ts\n * function myFunction(input: TransactionPlanInput) {\n *   const plan = parseTransactionPlanInput(input);\n *   // Use the plan...\n * }\n * ```\n *\n * @see {@link parseTransactionPlanInput}\n * @see {@link TransactionPlan}\n */\nexport type TransactionPlanInput =\n    | SingleTransactionPlan['message']\n    | TransactionPlan\n    | readonly (SingleTransactionPlan['message'] | TransactionPlan)[];\n\n/**\n * Parses a {@link TransactionPlanInput} and returns a {@link TransactionPlan}.\n *\n * This function handles the following input types:\n * - A single {@link TransactionMessage} is wrapped in a {@link SingleTransactionPlan}.\n * - An existing {@link TransactionPlan} is returned as-is.\n * - An array with a single element is unwrapped and parsed recursively.\n * - An array with multiple elements is wrapped in a divisible {@link SequentialTransactionPlan}.\n *\n * @param input - The input to parse into a transaction plan.\n * @return The parsed transaction plan.\n *\n * @example\n * Parsing a single transaction message.\n * ```ts\n * const plan = parseTransactionPlanInput(myTransactionMessage);\n * // Equivalent to: singleTransactionPlan(myTransactionMessage)\n * ```\n *\n * @example\n * Parsing an array of transaction messages.\n * ```ts\n * const plan = parseTransactionPlanInput([messageA, messageB]);\n * // Equivalent to: sequentialTransactionPlan([messageA, messageB])\n * ```\n *\n * @example\n * Parsing a mixed array with nested plans.\n * ```ts\n * const plan = parseTransactionPlanInput([\n *   messageA,\n *   parallelTransactionPlan([messageB, messageC]),\n * ]);\n * // Returns a sequential plan containing:\n * // - A single transaction plan for messageA.\n * // - The parallel plan for messageB and messageC.\n * ```\n *\n * @example\n * Single-element arrays are unwrapped.\n * ```ts\n * const plan = parseTransactionPlanInput([myTransactionMessage]);\n * // Equivalent to: singleTransactionPlan(myTransactionMessage)\n * ```\n *\n * @see {@link TransactionPlanInput}\n * @see {@link TransactionPlan}\n */\nexport function parseTransactionPlanInput(input: TransactionPlanInput): TransactionPlan {\n    if (Array.isArray(input) && input.length === 1) {\n        return parseTransactionPlanInput(input[0]);\n    }\n    if (Array.isArray(input)) {\n        return sequentialTransactionPlan(input.map(item => parseTransactionPlanInput(item)));\n    }\n    return isTransactionPlan(input) ? input : singleTransactionPlan(input as SingleTransactionPlan['message']);\n}\n\n/**\n * Parses an {@link InstructionPlanInput} or {@link TransactionPlanInput} and\n * returns the appropriate plan type.\n *\n * This function automatically detects whether the input represents instructions\n * or transactions and delegates to the appropriate parser:\n * - If the input is a transaction message or transaction plan, it delegates\n *   to {@link parseTransactionPlanInput}.\n * - Otherwise, it delegates to {@link parseInstructionPlanInput}.\n *\n * @param input - The input to parse, which can be either an instruction-based\n *   or transaction-based input.\n * @returns The parsed plan, either an {@link InstructionPlan} or a {@link TransactionPlan}.\n *\n * @example\n * Parsing an instruction input.\n * ```ts\n * const plan = parseInstructionOrTransactionPlanInput(myInstruction);\n * // Returns an InstructionPlan\n * ```\n *\n * @example\n * Parsing a transaction message input.\n * ```ts\n * const plan = parseInstructionOrTransactionPlanInput(myTransactionMessage);\n * // Returns a TransactionPlan\n * ```\n *\n * @see {@link parseInstructionPlanInput}\n * @see {@link parseTransactionPlanInput}\n * @see {@link InstructionPlanInput}\n * @see {@link TransactionPlanInput}\n */\nexport function parseInstructionOrTransactionPlanInput(\n    input: InstructionPlanInput | TransactionPlanInput,\n): InstructionPlan | TransactionPlan {\n    if (Array.isArray(input) && input.length === 0) {\n        return parseTransactionPlanInput(input);\n    }\n    if (Array.isArray(input) && isTransactionPlanInput(input[0])) {\n        return parseTransactionPlanInput(input as TransactionPlanInput);\n    }\n    if (isTransactionPlanInput(input)) {\n        return parseTransactionPlanInput(input as TransactionPlanInput);\n    }\n    return parseInstructionPlanInput(input as InstructionPlanInput);\n}\n\nfunction isTransactionPlanInput(value: unknown): value is SingleTransactionPlan['message'] | TransactionPlan {\n    return isTransactionPlan(value) || isTransactionMessage(value);\n}\n\nfunction isTransactionMessage(value: unknown): value is SingleTransactionPlan['message'] {\n    return (\n        typeof value === 'object' &&\n        value !== null &&\n        'instructions' in value &&\n        Array.isArray(value.instructions) &&\n        'version' in value\n    );\n}\n","import {\n    SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT,\n    SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND,\n    SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT,\n    SolanaError,\n} from '@solana/errors';\nimport { Signature } from '@solana/keys';\nimport { TransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\nimport { Transaction } from '@solana/transactions';\n\n/**\n * The result of executing a transaction plan.\n *\n * This is structured as a recursive tree of results that mirrors the structure\n * of the original transaction plan, capturing the execution status at each level.\n *\n * Namely, the following result types are supported:\n * - {@link SingleTransactionPlanResult} - A result for a single transaction message\n *   containing its execution status.\n * - {@link ParallelTransactionPlanResult} - A result containing other results that\n *   were executed in parallel.\n * - {@link SequentialTransactionPlanResult} - A result containing other results that\n *   were executed sequentially. It also retains the divisibility property from the\n *   original plan.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n * @typeParam TSingle - The type of single transaction plan results in this tree\n *\n * @see {@link SingleTransactionPlanResult}\n * @see {@link ParallelTransactionPlanResult}\n * @see {@link SequentialTransactionPlanResult}\n */\nexport type TransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n> =\n    | ParallelTransactionPlanResult<TContext, TTransactionMessage, TSingle>\n    | SequentialTransactionPlanResult<TContext, TTransactionMessage, TSingle>\n    | TSingle;\n\n/**\n * A {@link TransactionPlanResult} where all single transaction results are successful.\n *\n * This type represents a transaction plan result tree where every\n * {@link SingleTransactionPlanResult} has a 'successful' status. It can be used\n * to ensure that an entire execution completed without any failures or cancellations.\n *\n * Note: This is different from {@link SuccessfulSingleTransactionPlanResult} which\n * represents a single successful transaction, whereas this type represents an entire\n * plan result tree (which may contain parallel/sequential structures) where all\n * leaf nodes are successful.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n *\n * @see {@link isSuccessfulTransactionPlanResult}\n * @see {@link assertIsSuccessfulTransactionPlanResult}\n * @see {@link SuccessfulSingleTransactionPlanResult}\n */\nexport type SuccessfulTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n> = TransactionPlanResult<\n    TContext,\n    TTransactionMessage,\n    SuccessfulSingleTransactionPlanResult<TContext, TTransactionMessage>\n>;\n\n/**\n * The context object associated with a {@link SingleTransactionPlanResult}.\n *\n * This type defines the shape of custom context that can be attached to\n * transaction plan results. It allows arbitrary additional properties that\n * consumers can use to pass along extra data with their results.\n *\n * Note that base context fields such as `message`, `signature`, and `transaction` are not part of\n * this type. They come from the context a result is parameterised with, which defaults to\n * {@link TransactionPlanResultContextWithSignature}. Supply a different context to change or drop\n * those guarantees.\n *\n * @see {@link SingleTransactionPlanResult}\n * @see {@link SuccessfulSingleTransactionPlanResult}\n * @see {@link FailedSingleTransactionPlanResult}\n * @see {@link CanceledSingleTransactionPlanResult}\n * @see {@link TransactionPlanResultContextWithSignature}\n */\nexport type TransactionPlanResultContext = { [key: number | string | symbol]: unknown };\n\n/**\n * A {@link TransactionPlanResultContext} that is guaranteed to include a {@link Signature}.\n *\n * This is the default context for every transaction plan result type, which is why a successful\n * result exposes a required `context.signature` unless a different context is supplied.\n *\n * @example\n * Intersect this type into a custom context to keep the signature guarantee alongside your own\n * properties.\n * ```ts\n * const executor = createTransactionPlanExecutor<\n *     TransactionPlanResultContextWithSignature & { startedAt: number }\n * >({\n *     executeTransactionMessage: async (context, message) => {\n *         const startedAt = Date.now();\n *         context.startedAt = startedAt;\n *         const signature = await sendAndConfirm(message);\n *         return { signature, startedAt };\n *     },\n * });\n * ```\n *\n * @see {@link TransactionPlanResultContext}\n */\nexport type TransactionPlanResultContextWithSignature = TransactionPlanResultContext & {\n    message?: TransactionMessage & TransactionMessageWithFeePayer;\n    signature: Signature;\n    transaction?: Transaction;\n};\n\n/**\n * A result for a sequential transaction plan.\n *\n * This represents the execution result of a {@link SequentialTransactionPlan} and\n * contains child results that were executed sequentially. It also retains the\n * divisibility property from the original plan.\n *\n * You may use the {@link sequentialTransactionPlanResult} and\n * {@link nonDivisibleSequentialTransactionPlanResult} helpers to create objects of this type.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n * @typeParam TSingle - The type of single transaction plan results in this tree\n *\n * @example\n * ```ts\n * const result = sequentialTransactionPlanResult([\n *   singleResultA,\n *   singleResultB,\n * ]);\n * result satisfies SequentialTransactionPlanResult;\n * ```\n *\n * @example\n * Non-divisible sequential result.\n * ```ts\n * const result = nonDivisibleSequentialTransactionPlanResult([\n *   singleResultA,\n *   singleResultB,\n * ]);\n * result satisfies SequentialTransactionPlanResult & { divisible: false };\n * ```\n *\n * @see {@link sequentialTransactionPlanResult}\n * @see {@link nonDivisibleSequentialTransactionPlanResult}\n */\nexport type SequentialTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n> = Readonly<{\n    divisible: boolean;\n    kind: 'sequential';\n    planType: 'transactionPlanResult';\n    plans: TransactionPlanResult<TContext, TTransactionMessage, TSingle>[];\n}>;\n\n/**\n * A result for a parallel transaction plan.\n *\n * This represents the execution result of a {@link ParallelTransactionPlan} and\n * contains child results that were executed in parallel.\n *\n * You may use the {@link parallelTransactionPlanResult} helper to create objects of this type.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n * @typeParam TSingle - The type of single transaction plan results in this tree\n *\n * @example\n * ```ts\n * const result = parallelTransactionPlanResult([\n *   singleResultA,\n *   singleResultB,\n * ]);\n * result satisfies ParallelTransactionPlanResult;\n * ```\n *\n * @see {@link parallelTransactionPlanResult}\n */\nexport type ParallelTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n> = Readonly<{\n    kind: 'parallel';\n    planType: 'transactionPlanResult';\n    plans: TransactionPlanResult<TContext, TTransactionMessage, TSingle>[];\n}>;\n\n/**\n * A result for a single transaction plan.\n *\n * This represents the execution result of a {@link SingleTransactionPlan} and\n * contains the original transaction message along with its execution status.\n *\n * You may use the {@link successfulSingleTransactionPlanResult},\n * {@link failedSingleTransactionPlanResult}, or {@link canceledSingleTransactionPlanResult}\n * helpers to create objects of this type.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n *\n * @example\n * Successful result with a signature in its context.\n * ```ts\n * const result = successfulSingleTransactionPlanResult(\n *   transactionMessage,\n *   { signature },\n * );\n * result satisfies SingleTransactionPlanResult;\n * ```\n *\n * @example\n * Failed result with an error.\n * ```ts\n * const result = failedSingleTransactionPlanResult(\n *   transactionMessage,\n *   new SolanaError(SOLANA_ERROR__TRANSACTION_ERROR__INSUFFICIENT_FUNDS_FOR_FEE),\n * );\n * result satisfies SingleTransactionPlanResult;\n * ```\n *\n * @example\n * Canceled result.\n * ```ts\n * const result = canceledSingleTransactionPlanResult(transactionMessage);\n * result satisfies SingleTransactionPlanResult;\n * ```\n *\n * @see {@link successfulSingleTransactionPlanResult}\n * @see {@link failedSingleTransactionPlanResult}\n * @see {@link canceledSingleTransactionPlanResult}\n */\nexport type SingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n> =\n    | CanceledSingleTransactionPlanResult<TContext, TTransactionMessage>\n    | FailedSingleTransactionPlanResult<TContext, TTransactionMessage>\n    | SuccessfulSingleTransactionPlanResult<TContext, TTransactionMessage>;\n\n/**\n * A {@link SingleTransactionPlanResult} with a 'successful' status.\n *\n * This type represents a single transaction that was successfully executed.\n * It includes the original planned message and a context object. That context defaults to\n * {@link TransactionPlanResultContextWithSignature} — a required transaction {@link Signature},\n * and optionally the {@link TransactionMessage} and the full {@link Transaction} object — but a\n * different `TContext` may drop the signature requirement entirely.\n *\n * You may use the {@link successfulSingleTransactionPlanResult} helper to\n * create objects of this type.\n *\n * @typeParam TContext - The type of the context object that may be passed along with the result.\n * @typeParam TTransactionMessage - The type of the transaction message.\n *\n * @example\n * Creating a successful result from a transaction message and signature.\n * ```ts\n * const result = successfulSingleTransactionPlanResult(\n *   transactionMessage,\n *   { signature },\n * );\n * result satisfies SuccessfulSingleTransactionPlanResult;\n * result.context.signature; // The transaction signature.\n * ```\n *\n * @see {@link successfulSingleTransactionPlanResult}\n * @see {@link isSuccessfulSingleTransactionPlanResult}\n * @see {@link assertIsSuccessfulSingleTransactionPlanResult}\n */\nexport type SuccessfulSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n> = {\n    context: Readonly<TContext>;\n    kind: 'single';\n    planType: 'transactionPlanResult';\n    plannedMessage: TTransactionMessage;\n    status: 'successful';\n};\n\n/**\n * A {@link SingleTransactionPlanResult} with a 'failed' status.\n *\n * This type represents a single transaction that failed during execution.\n * It includes the original planned message, the {@link Error} that caused\n * the failure, and a context object in which every field is optional — including\n * {@link TransactionMessage}, {@link Signature}, and {@link Transaction}\n * fields that may or may not be populated depending on how far execution\n * progressed before the failure.\n *\n * You may use the {@link failedSingleTransactionPlanResult} helper to\n * create objects of this type.\n *\n * @typeParam TContext - The type of the context object that may be passed along with the result.\n * @typeParam TTransactionMessage - The type of the transaction message.\n *\n * @example\n * Creating a failed result from a transaction message and error.\n * ```ts\n * const result = failedSingleTransactionPlanResult(\n *   transactionMessage,\n *   new Error('Transaction simulation failed'),\n * );\n * result satisfies FailedSingleTransactionPlanResult;\n * result.error; // The error that caused the failure.\n * ```\n *\n * @see {@link failedSingleTransactionPlanResult}\n * @see {@link isFailedSingleTransactionPlanResult}\n * @see {@link assertIsFailedSingleTransactionPlanResult}\n */\nexport type FailedSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n> = {\n    context: Readonly<Partial<TContext>>;\n    error: Error;\n    kind: 'single';\n    planType: 'transactionPlanResult';\n    plannedMessage: TTransactionMessage;\n    status: 'failed';\n};\n\n/**\n * A {@link SingleTransactionPlanResult} with a 'canceled' status.\n *\n * This type represents a single transaction whose execution was canceled\n * before it could complete. It includes the original planned message and\n * a context object in which every field is optional — including\n * {@link TransactionMessage}, {@link Signature}, and {@link Transaction}\n * fields that may or may not be populated depending on how far execution\n * progressed before cancellation.\n *\n * You may use the {@link canceledSingleTransactionPlanResult} helper to\n * create objects of this type.\n *\n * @typeParam TContext - The type of the context object that may be passed along with the result.\n * @typeParam TTransactionMessage - The type of the transaction message.\n *\n * @example\n * Creating a canceled result from a transaction message.\n * ```ts\n * const result = canceledSingleTransactionPlanResult(transactionMessage);\n * result satisfies CanceledSingleTransactionPlanResult;\n * ```\n *\n * @see {@link canceledSingleTransactionPlanResult}\n * @see {@link isCanceledSingleTransactionPlanResult}\n * @see {@link assertIsCanceledSingleTransactionPlanResult}\n */\nexport type CanceledSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n> = {\n    context: Readonly<Partial<TContext>>;\n    kind: 'single';\n    planType: 'transactionPlanResult';\n    plannedMessage: TTransactionMessage;\n    status: 'canceled';\n};\n\n/**\n * Creates a divisible {@link SequentialTransactionPlanResult} from an array of nested results.\n *\n * This function creates a sequential result with the `divisible` property set to `true`,\n * indicating that the nested plans were executed sequentially but could have been\n * split into separate transactions or batches.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @param plans - The child results that were executed sequentially\n *\n * @example\n * ```ts\n * const result = sequentialTransactionPlanResult([\n *   singleResultA,\n *   singleResultB,\n * ]);\n * result satisfies SequentialTransactionPlanResult & { divisible: true };\n * ```\n *\n * @see {@link SequentialTransactionPlanResult}\n */\nexport function sequentialTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(plans: TransactionPlanResult<TContext>[]): SequentialTransactionPlanResult<TContext> & { divisible: true } {\n    return Object.freeze({ divisible: true, kind: 'sequential', planType: 'transactionPlanResult', plans });\n}\n\n/**\n * Creates a non-divisible {@link SequentialTransactionPlanResult} from an array of nested results.\n *\n * This function creates a sequential result with the `divisible` property set to `false`,\n * indicating that the nested plans were executed sequentially and could not have been\n * split into separate transactions or batches (e.g., they were executed as a transaction bundle).\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @param plans - The child results that were executed sequentially\n *\n * @example\n * ```ts\n * const result = nonDivisibleSequentialTransactionPlanResult([\n *   singleResultA,\n *   singleResultB,\n * ]);\n * result satisfies SequentialTransactionPlanResult & { divisible: false };\n * ```\n *\n * @see {@link SequentialTransactionPlanResult}\n */\nexport function nonDivisibleSequentialTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(plans: TransactionPlanResult<TContext>[]): SequentialTransactionPlanResult<TContext> & { divisible: false } {\n    return Object.freeze({ divisible: false, kind: 'sequential', planType: 'transactionPlanResult', plans });\n}\n\n/**\n * Creates a {@link ParallelTransactionPlanResult} from an array of nested results.\n *\n * This function creates a parallel result indicating that the nested plans\n * were executed in parallel.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @param plans - The child results that were executed in parallel\n *\n * @example\n * ```ts\n * const result = parallelTransactionPlanResult([\n *   singleResultA,\n *   singleResultB,\n * ]);\n * result satisfies ParallelTransactionPlanResult;\n * ```\n *\n * @see {@link ParallelTransactionPlanResult}\n */\nexport function parallelTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(plans: TransactionPlanResult<TContext>[]): ParallelTransactionPlanResult<TContext> {\n    return Object.freeze({ kind: 'parallel', planType: 'transactionPlanResult', plans });\n}\n\n/**\n * Creates a successful {@link SingleTransactionPlanResult} from a transaction message and context.\n *\n * This function creates a single result with a 'successful' status, indicating that\n * the transaction was successfully executed. It also includes the original transaction\n * message and a context object, which becomes the result's `context` as-is, typed as\n * `TContext`. Passing a context containing a `signature` — the common case — yields the\n * default {@link TransactionPlanResultContextWithSignature} shape; supply a different\n * context shape when the transaction has no fee payer signature to report.\n *\n * @typeParam TContext - The type of the context object\n * @typeParam TTransactionMessage - The type of the transaction message\n * @param plannedMessage - The original transaction message\n * @param context - The context object to be included with the result, as `TContext`\n *\n * @example\n * ```ts\n * const result = successfulSingleTransactionPlanResult(\n *   transactionMessage,\n *   { signature },\n * );\n * result satisfies SingleTransactionPlanResult;\n * ```\n *\n * @see {@link SingleTransactionPlanResult}\n */\nexport function successfulSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plannedMessage: TTransactionMessage,\n    context: TContext,\n): SuccessfulSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    return Object.freeze({\n        context: Object.freeze({ ...context }),\n        kind: 'single',\n        planType: 'transactionPlanResult',\n        plannedMessage,\n        status: 'successful',\n    });\n}\n\n/**\n * Creates a failed {@link SingleTransactionPlanResult} from a transaction message and error.\n *\n * This function creates a single result with a 'failed' status, indicating that\n * the transaction execution failed. It includes the original transaction message\n * and the error that caused the failure.\n *\n * @typeParam TContext - The type of the context object\n * @typeParam TTransactionMessage - The type of the transaction message\n * @param plannedMessage - The original transaction message\n * @param error - The error that caused the transaction to fail\n *\n * @example\n * ```ts\n * const result = failedSingleTransactionPlanResult(\n *   transactionMessage,\n *   new SolanaError({\n *     code: 123,\n *     message: 'Transaction simulation failed',\n *   }),\n * );\n * result satisfies SingleTransactionPlanResult;\n * ```\n *\n * @see {@link SingleTransactionPlanResult}\n */\nexport function failedSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plannedMessage: TTransactionMessage,\n    error: Error,\n    context?: Partial<TContext>,\n): FailedSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    return Object.freeze({\n        context: Object.freeze({ ...((context ?? {}) as Partial<TContext>) }),\n        error,\n        kind: 'single',\n        planType: 'transactionPlanResult',\n        plannedMessage,\n        status: 'failed',\n    });\n}\n\n/**\n * Creates a canceled {@link SingleTransactionPlanResult} from a transaction message.\n *\n * This function creates a single result with a 'canceled' status, indicating that\n * the transaction execution was canceled. It includes the original transaction message.\n *\n * @typeParam TContext - The type of the context object\n * @typeParam TTransactionMessage - The type of the transaction message\n * @param plannedMessage - The original transaction message\n *\n * @example\n * ```ts\n * const result = canceledSingleTransactionPlanResult(transactionMessage);\n * result satisfies SingleTransactionPlanResult;\n * ```\n *\n * @see {@link SingleTransactionPlanResult}\n */\nexport function canceledSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plannedMessage: TTransactionMessage,\n    context?: Partial<TContext>,\n): CanceledSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    return Object.freeze({\n        context: Object.freeze({ ...((context ?? {}) as Partial<TContext>) }),\n        kind: 'single',\n        planType: 'transactionPlanResult',\n        plannedMessage,\n        status: 'canceled',\n    });\n}\n\n/**\n * Checks if the given value is a {@link TransactionPlanResult}.\n *\n * This type guard checks the `planType` property to determine if the value\n * is a transaction plan result. This is useful when you have a value that could be\n * an {@link InstructionPlan}, {@link TransactionPlan}, or {@link TransactionPlanResult}\n * and need to narrow the type.\n *\n * @param value - The value to check.\n * @return `true` if the value is a transaction plan result, `false` otherwise.\n *\n * @example\n * ```ts\n * function processItem(item: InstructionPlan | TransactionPlan | TransactionPlanResult) {\n *   if (isTransactionPlanResult(item)) {\n *     // item is narrowed to TransactionPlanResult\n *     console.log(item.kind);\n *   }\n * }\n * ```\n *\n * @see {@link TransactionPlanResult}\n * @see {@link isInstructionPlan}\n * @see {@link isTransactionPlan}\n */\nexport function isTransactionPlanResult(value: unknown): value is TransactionPlanResult {\n    return (\n        typeof value === 'object' &&\n        value !== null &&\n        'planType' in value &&\n        typeof value.planType === 'string' &&\n        value.planType === 'transactionPlanResult'\n    );\n}\n\n/**\n * Checks if the given transaction plan result is a {@link SingleTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to check.\n * @return `true` if the result is a single transaction plan result, `false` otherwise.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = successfulSingleTransactionPlanResult(message, { signature });\n *\n * if (isSingleTransactionPlanResult(result)) {\n *   console.log(result.status); // TypeScript knows this is a SingleTransactionPlanResult.\n * }\n * ```\n *\n * @see {@link SingleTransactionPlanResult}\n * @see {@link assertIsSingleTransactionPlanResult}\n */\nexport function isSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>): plan is TSingle {\n    return plan.kind === 'single';\n}\n\n/**\n * Asserts that the given transaction plan result is a {@link SingleTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT` if the result is not a single transaction plan result.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = successfulSingleTransactionPlanResult(message, { signature });\n *\n * assertIsSingleTransactionPlanResult(result);\n * console.log(result.status); // TypeScript knows this is a SingleTransactionPlanResult.\n * ```\n *\n * @see {@link SingleTransactionPlanResult}\n * @see {@link isSingleTransactionPlanResult}\n */\nexport function assertIsSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>): asserts plan is TSingle {\n    if (!isSingleTransactionPlanResult(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT, {\n            actualKind: plan.kind,\n            expectedKind: 'single',\n            transactionPlanResult: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan result is a successful {@link SingleTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to check.\n * @return `true` if the result is a successful single transaction plan result, `false` otherwise.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = successfulSingleTransactionPlanResult(message, { signature });\n *\n * if (isSuccessfulSingleTransactionPlanResult(result)) {\n *   console.log(result.context.signature); // TypeScript knows this is a successful result.\n * }\n * ```\n *\n * @see {@link SuccessfulSingleTransactionPlanResult}\n * @see {@link assertIsSuccessfulSingleTransactionPlanResult}\n */\nexport function isSuccessfulSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage>,\n): plan is SuccessfulSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    return plan.kind === 'single' && plan.status === 'successful';\n}\n\n/**\n * Asserts that the given transaction plan result is a successful {@link SingleTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT` if the result is not a successful single transaction plan result.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = successfulSingleTransactionPlanResult(message, { signature });\n *\n * assertIsSuccessfulSingleTransactionPlanResult(result);\n * console.log(result.context.signature); // TypeScript knows this is a successful result.\n * ```\n *\n * @see {@link SuccessfulSingleTransactionPlanResult}\n * @see {@link isSuccessfulSingleTransactionPlanResult}\n */\nexport function assertIsSuccessfulSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage>,\n): asserts plan is SuccessfulSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    if (!isSuccessfulSingleTransactionPlanResult(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT, {\n            actualKind: plan.kind === 'single' ? `${plan.status} single` : plan.kind,\n            expectedKind: 'successful single',\n            transactionPlanResult: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan result is a failed {@link SingleTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to check.\n * @return `true` if the result is a failed single transaction plan result, `false` otherwise.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = failedSingleTransactionPlanResult(message, error);\n *\n * if (isFailedSingleTransactionPlanResult(result)) {\n *   console.log(result.error); // TypeScript knows this is a failed result.\n * }\n * ```\n *\n * @see {@link FailedSingleTransactionPlanResult}\n * @see {@link assertIsFailedSingleTransactionPlanResult}\n */\nexport function isFailedSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage>,\n): plan is FailedSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    return plan.kind === 'single' && plan.status === 'failed';\n}\n\n/**\n * Asserts that the given transaction plan result is a failed {@link SingleTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT` if the result is not a failed single transaction plan result.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = failedSingleTransactionPlanResult(message, error);\n *\n * assertIsFailedSingleTransactionPlanResult(result);\n * console.log(result.error); // TypeScript knows this is a failed result.\n * ```\n *\n * @see {@link FailedSingleTransactionPlanResult}\n * @see {@link isFailedSingleTransactionPlanResult}\n */\nexport function assertIsFailedSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage>,\n): asserts plan is FailedSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    if (!isFailedSingleTransactionPlanResult(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT, {\n            actualKind: plan.kind === 'single' ? `${plan.status} single` : plan.kind,\n            expectedKind: 'failed single',\n            transactionPlanResult: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan result is a canceled {@link SingleTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to check.\n * @return `true` if the result is a canceled single transaction plan result, `false` otherwise.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = canceledSingleTransactionPlanResult(message);\n *\n * if (isCanceledSingleTransactionPlanResult(result)) {\n *   console.log('Transaction was canceled'); // TypeScript knows this is a canceled result.\n * }\n * ```\n *\n * @see {@link CanceledSingleTransactionPlanResult}\n * @see {@link assertIsCanceledSingleTransactionPlanResult}\n */\nexport function isCanceledSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage>,\n): plan is CanceledSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    return plan.kind === 'single' && plan.status === 'canceled';\n}\n\n/**\n * Asserts that the given transaction plan result is a canceled {@link SingleTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT` if the result is not a canceled single transaction plan result.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = canceledSingleTransactionPlanResult(message);\n *\n * assertIsCanceledSingleTransactionPlanResult(result);\n * console.log('Transaction was canceled'); // TypeScript knows this is a canceled result.\n * ```\n *\n * @see {@link CanceledSingleTransactionPlanResult}\n * @see {@link isCanceledSingleTransactionPlanResult}\n */\nexport function assertIsCanceledSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage>,\n): asserts plan is CanceledSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    if (!isCanceledSingleTransactionPlanResult(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT, {\n            actualKind: plan.kind === 'single' ? `${plan.status} single` : plan.kind,\n            expectedKind: 'canceled single',\n            transactionPlanResult: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan result is a {@link SequentialTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to check.\n * @return `true` if the result is a sequential transaction plan result, `false` otherwise.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = sequentialTransactionPlanResult([resultA, resultB]);\n *\n * if (isSequentialTransactionPlanResult(result)) {\n *   console.log(result.divisible); // TypeScript knows this is a SequentialTransactionPlanResult.\n * }\n * ```\n *\n * @see {@link SequentialTransactionPlanResult}\n * @see {@link assertIsSequentialTransactionPlanResult}\n */\nexport function isSequentialTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>,\n): plan is SequentialTransactionPlanResult<TContext, TTransactionMessage, TSingle> {\n    return plan.kind === 'sequential';\n}\n\n/**\n * Asserts that the given transaction plan result is a {@link SequentialTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT` if the result is not a sequential transaction plan result.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = sequentialTransactionPlanResult([resultA, resultB]);\n *\n * assertIsSequentialTransactionPlanResult(result);\n * console.log(result.divisible); // TypeScript knows this is a SequentialTransactionPlanResult.\n * ```\n *\n * @see {@link SequentialTransactionPlanResult}\n * @see {@link isSequentialTransactionPlanResult}\n */\nexport function assertIsSequentialTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>,\n): asserts plan is SequentialTransactionPlanResult<TContext, TTransactionMessage, TSingle> {\n    if (!isSequentialTransactionPlanResult(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT, {\n            actualKind: plan.kind,\n            expectedKind: 'sequential',\n            transactionPlanResult: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan result is a non-divisible {@link SequentialTransactionPlanResult}.\n *\n * A non-divisible sequential result indicates that the transactions were executed\n * atomically — usually in a transaction bundle.\n *\n * @param plan - The transaction plan result to check.\n * @return `true` if the result is a non-divisible sequential transaction plan result, `false` otherwise.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = nonDivisibleSequentialTransactionPlanResult([resultA, resultB]);\n *\n * if (isNonDivisibleSequentialTransactionPlanResult(result)) {\n *   // Transactions were executed atomically.\n * }\n * ```\n *\n * @see {@link SequentialTransactionPlanResult}\n * @see {@link assertIsNonDivisibleSequentialTransactionPlanResult}\n */\nexport function isNonDivisibleSequentialTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>,\n): plan is SequentialTransactionPlanResult<TContext, TTransactionMessage, TSingle> & { divisible: false } {\n    return plan.kind === 'sequential' && plan.divisible === false;\n}\n\n/**\n * Asserts that the given transaction plan result is a non-divisible {@link SequentialTransactionPlanResult}.\n *\n * A non-divisible sequential result indicates that the transactions were executed\n * atomically — usually in a transaction bundle.\n *\n * @param plan - The transaction plan result to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT` if the result is not a non-divisible sequential transaction plan result.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = nonDivisibleSequentialTransactionPlanResult([resultA, resultB]);\n *\n * assertIsNonDivisibleSequentialTransactionPlanResult(result);\n * // Transactions were executed atomically.\n * ```\n *\n * @see {@link SequentialTransactionPlanResult}\n * @see {@link isNonDivisibleSequentialTransactionPlanResult}\n */\nexport function assertIsNonDivisibleSequentialTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>,\n): asserts plan is SequentialTransactionPlanResult<TContext, TTransactionMessage, TSingle> & { divisible: false } {\n    if (!isNonDivisibleSequentialTransactionPlanResult(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT, {\n            actualKind: plan.kind === 'sequential' ? 'divisible sequential' : plan.kind,\n            expectedKind: 'non-divisible sequential',\n            transactionPlanResult: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan result is a {@link ParallelTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to check.\n * @return `true` if the result is a parallel transaction plan result, `false` otherwise.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = parallelTransactionPlanResult([resultA, resultB]);\n *\n * if (isParallelTransactionPlanResult(result)) {\n *   console.log(result.plans.length); // TypeScript knows this is a ParallelTransactionPlanResult.\n * }\n * ```\n *\n * @see {@link ParallelTransactionPlanResult}\n * @see {@link assertIsParallelTransactionPlanResult}\n */\nexport function isParallelTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>,\n): plan is ParallelTransactionPlanResult<TContext, TTransactionMessage, TSingle> {\n    return plan.kind === 'parallel';\n}\n\n/**\n * Asserts that the given transaction plan result is a {@link ParallelTransactionPlanResult}.\n *\n * @param plan - The transaction plan result to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT` if the result is not a parallel transaction plan result.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = parallelTransactionPlanResult([resultA, resultB]);\n *\n * assertIsParallelTransactionPlanResult(result);\n * console.log(result.plans.length); // TypeScript knows this is a ParallelTransactionPlanResult.\n * ```\n *\n * @see {@link ParallelTransactionPlanResult}\n * @see {@link isParallelTransactionPlanResult}\n */\nexport function assertIsParallelTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>,\n): asserts plan is ParallelTransactionPlanResult<TContext, TTransactionMessage, TSingle> {\n    if (!isParallelTransactionPlanResult(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT, {\n            actualKind: plan.kind,\n            expectedKind: 'parallel',\n            transactionPlanResult: plan,\n        });\n    }\n}\n\n/**\n * Checks if the given transaction plan result is a {@link SuccessfulTransactionPlanResult}.\n *\n * This function verifies that the entire transaction plan result tree contains only\n * successful single transaction results. It recursively checks all nested results\n * to ensure every {@link SingleTransactionPlanResult} has a 'successful' status.\n *\n * Note: This is different from {@link isSuccessfulSingleTransactionPlanResult} which\n * checks if a single result is successful. This function checks that the entire\n * plan result tree (including all nested parallel/sequential structures) contains\n * only successful transactions.\n *\n * @param plan - The transaction plan result to check.\n * @return `true` if all single transaction results in the tree are successful, `false` otherwise.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = parallelTransactionPlanResult([\n *   successfulSingleTransactionPlanResult(messageA, { signature: signatureA }),\n *   successfulSingleTransactionPlanResult(messageB, { signature: signatureB }),\n * ]);\n *\n * if (isSuccessfulTransactionPlanResult(result)) {\n *   // All transactions were successful.\n *   result satisfies SuccessfulTransactionPlanResult;\n * }\n * ```\n *\n * @see {@link SuccessfulTransactionPlanResult}\n * @see {@link assertIsSuccessfulTransactionPlanResult}\n * @see {@link isSuccessfulSingleTransactionPlanResult}\n */\nexport function isSuccessfulTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage>,\n): plan is SuccessfulTransactionPlanResult<TContext, TTransactionMessage> {\n    return everyTransactionPlanResult(\n        plan,\n        r => !isSingleTransactionPlanResult(r) || isSuccessfulSingleTransactionPlanResult(r),\n    );\n}\n\n/**\n * Asserts that the given transaction plan result is a {@link SuccessfulTransactionPlanResult}.\n *\n * This function verifies that the entire transaction plan result tree contains only\n * successful single transaction results. It throws if any {@link SingleTransactionPlanResult}\n * in the tree has a 'failed' or 'canceled' status.\n *\n * Note: This is different from {@link assertIsSuccessfulSingleTransactionPlanResult} which\n * asserts that a single result is successful. This function asserts that the entire\n * plan result tree (including all nested parallel/sequential structures) contains\n * only successful transactions.\n *\n * @param plan - The transaction plan result to assert.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT` if\n * any single transaction result in the tree is not successful.\n *\n * @example\n * ```ts\n * const result: TransactionPlanResult = parallelTransactionPlanResult([\n *   successfulSingleTransactionPlanResult(messageA, { signature: signatureA }),\n *   successfulSingleTransactionPlanResult(messageB, { signature: signatureB }),\n * ]);\n *\n * assertIsSuccessfulTransactionPlanResult(result);\n * // All transactions were successful.\n * result satisfies SuccessfulTransactionPlanResult;\n * ```\n *\n * @see {@link SuccessfulTransactionPlanResult}\n * @see {@link isSuccessfulTransactionPlanResult}\n * @see {@link assertIsSuccessfulSingleTransactionPlanResult}\n */\nexport function assertIsSuccessfulTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    plan: TransactionPlanResult<TContext, TTransactionMessage>,\n): asserts plan is SuccessfulTransactionPlanResult<TContext, TTransactionMessage> {\n    if (!isSuccessfulTransactionPlanResult(plan)) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT, {\n            transactionPlanResult: plan,\n        });\n    }\n}\n\n/**\n * Finds the first transaction plan result in the tree that matches the given predicate.\n *\n * This function performs a depth-first search through the transaction plan result tree,\n * returning the first result that satisfies the predicate. It checks the root result\n * first, then recursively searches through nested results.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n * @typeParam TSingle - The type of single transaction plan results in this tree\n * @param transactionPlanResult - The transaction plan result tree to search.\n * @param predicate - A function that returns `true` for the result to find.\n * @returns The first matching transaction plan result, or `undefined` if no match is found.\n *\n * @example\n * Finding a failed transaction result.\n * ```ts\n * const result = parallelTransactionPlanResult([\n *   successfulSingleTransactionPlanResult(messageA, { signature: signatureA }),\n *   failedSingleTransactionPlanResult(messageB, error),\n * ]);\n *\n * const failed = findTransactionPlanResult(\n *   result,\n *   (r) => r.kind === 'single' && r.status === 'failed',\n * );\n * // Returns the failed single transaction plan result for messageB.\n * ```\n *\n * @see {@link TransactionPlanResult}\n * @see {@link everyTransactionPlanResult}\n * @see {@link transformTransactionPlanResult}\n * @see {@link flattenTransactionPlanResult}\n */\nexport function findTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(\n    transactionPlanResult: TransactionPlanResult<TContext, TTransactionMessage, TSingle>,\n    predicate: (result: TransactionPlanResult<TContext, TTransactionMessage, TSingle>) => boolean,\n): TransactionPlanResult<TContext, TTransactionMessage, TSingle> | undefined {\n    if (predicate(transactionPlanResult)) {\n        return transactionPlanResult;\n    }\n    if (transactionPlanResult.kind === 'single') {\n        return undefined;\n    }\n    for (const subResult of transactionPlanResult.plans) {\n        const foundResult = findTransactionPlanResult(subResult, predicate);\n        if (foundResult) {\n            return foundResult;\n        }\n    }\n    return undefined;\n}\n\n/**\n * Retrieves the first failed transaction plan result from a transaction plan result tree.\n *\n * This function searches the transaction plan result tree using a depth-first traversal\n * and returns the first single transaction result with a 'failed' status. If no failed\n * result is found, it throws a {@link SolanaError}.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n * @param transactionPlanResult - The transaction plan result tree to search.\n * @return The first failed single transaction plan result.\n * @throws Throws a {@link SolanaError} with code\n * `SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND` if no\n * failed transaction plan result is found. The error context contains a non-enumerable\n * `transactionPlanResult` property for recovery purposes.\n *\n * @example\n * Retrieving the first failed result from a parallel execution.\n * ```ts\n * const result = parallelTransactionPlanResult([\n *   successfulSingleTransactionPlanResult(messageA, { signature: signatureA }),\n *   failedSingleTransactionPlanResult(messageB, error),\n *   failedSingleTransactionPlanResult(messageC, anotherError),\n * ]);\n *\n * const firstFailed = getFirstFailedSingleTransactionPlanResult(result);\n * // Returns the failed result for messageB.\n * ```\n *\n * @see {@link FailedSingleTransactionPlanResult}\n * @see {@link findTransactionPlanResult}\n */\nexport function getFirstFailedSingleTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    transactionPlanResult: TransactionPlanResult<TContext, TTransactionMessage>,\n): FailedSingleTransactionPlanResult<TContext, TTransactionMessage> {\n    const result = findTransactionPlanResult(transactionPlanResult, r => r.kind === 'single' && r.status === 'failed');\n\n    if (!result) {\n        // Here we want the `transactionPlanResult` to be available in the error context\n        // so applications can recover but we don't want this object to be\n        // serialized with the error. This is why we set it as a non-enumerable property.\n        const context = {};\n        Object.defineProperty(context, 'transactionPlanResult', {\n            configurable: false,\n            enumerable: false,\n            value: transactionPlanResult,\n            writable: false,\n        });\n        throw new SolanaError(\n            SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND,\n            context,\n        );\n    }\n\n    return result as FailedSingleTransactionPlanResult<TContext, TTransactionMessage>;\n}\n\n/**\n * Checks if every transaction plan result in the tree satisfies the given predicate.\n *\n * This function performs a depth-first traversal through the transaction plan result tree,\n * returning `true` only if the predicate returns `true` for every result in the tree\n * (including the root result and all nested results).\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n * @typeParam TSingle - The type of single transaction plan results in this tree\n * @param transactionPlanResult - The transaction plan result tree to check.\n * @param predicate - A function that returns `true` if the result satisfies the condition.\n * @return `true` if every result in the tree satisfies the predicate, `false` otherwise.\n *\n * @example\n * Checking if all transactions were successful.\n * ```ts\n * const result = parallelTransactionPlanResult([\n *   successfulSingleTransactionPlanResult(messageA, { signature: signatureA }),\n *   successfulSingleTransactionPlanResult(messageB, { signature: signatureB }),\n * ]);\n *\n * const allSuccessful = everyTransactionPlanResult(\n *   result,\n *   (r) => r.kind !== 'single' || r.status === 'successful',\n * );\n * // Returns true because all single results are successful.\n * ```\n *\n * @example\n * Checking if no transactions were canceled.\n * ```ts\n * const result = sequentialTransactionPlanResult([resultA, resultB, resultC]);\n *\n * const noCanceled = everyTransactionPlanResult(\n *   result,\n *   (r) => r.kind !== 'single' || r.status !== 'canceled',\n * );\n * ```\n *\n * @see {@link TransactionPlanResult}\n * @see {@link findTransactionPlanResult}\n * @see {@link transformTransactionPlanResult}\n * @see {@link flattenTransactionPlanResult}\n */\nexport function everyTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(\n    transactionPlanResult: TransactionPlanResult<TContext, TTransactionMessage, TSingle>,\n    predicate: (plan: TransactionPlanResult<TContext, TTransactionMessage, TSingle>) => boolean,\n): boolean {\n    if (!predicate(transactionPlanResult)) {\n        return false;\n    }\n    if (transactionPlanResult.kind === 'single') {\n        return true;\n    }\n    return transactionPlanResult.plans.every(p => everyTransactionPlanResult(p, predicate));\n}\n\n/**\n * Transforms a transaction plan result tree using a bottom-up approach.\n *\n * This function recursively traverses the transaction plan result tree, applying the\n * transformation function to each result. The transformation is applied bottom-up,\n * meaning nested results are transformed first, then the parent results receive\n * the already-transformed children before being transformed themselves.\n *\n * All transformed results are frozen using `Object.freeze` to ensure immutability.\n *\n * @param transactionPlanResult - The transaction plan result tree to transform.\n * @param fn - A function that transforms each result and returns a new result.\n * @return A new transformed transaction plan result tree.\n *\n * @example\n * Converting all canceled results to failed results.\n * ```ts\n * const result = parallelTransactionPlanResult([\n *   successfulSingleTransactionPlanResult(messageA, { signature: signatureA }),\n *   canceledSingleTransactionPlanResult(messageB),\n * ]);\n *\n * const transformed = transformTransactionPlanResult(result, (r) => {\n *   if (r.kind === 'single' && r.status === 'canceled') {\n *     return failedSingleTransactionPlanResult(r.plannedMessage, new Error('Execution canceled'));\n *   }\n *   return r;\n * });\n * ```\n *\n * @see {@link TransactionPlanResult}\n * @see {@link findTransactionPlanResult}\n * @see {@link everyTransactionPlanResult}\n * @see {@link flattenTransactionPlanResult}\n */\nexport function transformTransactionPlanResult(\n    transactionPlanResult: TransactionPlanResult,\n    fn: (plan: TransactionPlanResult) => TransactionPlanResult,\n): TransactionPlanResult {\n    if (transactionPlanResult.kind === 'single') {\n        return Object.freeze(fn(transactionPlanResult));\n    }\n    return Object.freeze(\n        fn(\n            Object.freeze({\n                ...transactionPlanResult,\n                plans: transactionPlanResult.plans.map(p => transformTransactionPlanResult(p, fn)),\n            }),\n        ),\n    );\n}\n\n/**\n * Retrieves all individual {@link SingleTransactionPlanResult} instances from a transaction plan result tree.\n *\n * This function recursively traverses any nested structure of transaction plan results and extracts\n * all the single results they contain. It's useful when you need to access all the individual\n * transaction results, regardless of their organization in the result tree (parallel or sequential).\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n * @typeParam TSingle - The type of single transaction plan results in this tree\n * @param result - The transaction plan result to extract single results from\n * @returns An array of all single transaction plan results contained in the tree\n *\n * @example\n * ```ts\n * const result = parallelTransactionPlanResult([\n *   sequentialTransactionPlanResult([resultA, resultB]),\n *   nonDivisibleSequentialTransactionPlanResult([resultC, resultD]),\n *   resultE,\n * ]);\n *\n * const singleResults = flattenTransactionPlanResult(result);\n * // Array of `SingleTransactionPlanResult` containing:\n * // resultA, resultB, resultC, resultD and resultE.\n * ```\n *\n * @see {@link TransactionPlanResult}\n * @see {@link findTransactionPlanResult}\n * @see {@link everyTransactionPlanResult}\n * @see {@link transformTransactionPlanResult}\n */\nexport function flattenTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n    TSingle extends SingleTransactionPlanResult<TContext, TTransactionMessage> = SingleTransactionPlanResult<\n        TContext,\n        TTransactionMessage\n    >,\n>(result: TransactionPlanResult<TContext, TTransactionMessage, TSingle>): TSingle[] {\n    if (result.kind === 'single') {\n        return [result];\n    }\n    return result.plans.flatMap(flattenTransactionPlanResult);\n}\n\n/**\n * A summary of a {@link TransactionPlanResult}, categorizing transactions by their execution status.\n * - `successful`: Indicates whether all transactions were successful (i.e., no failed or canceled transactions).\n * - `successfulTransactions`: An array of successful transactions, each including its signature.\n * - `failedTransactions`: An array of failed transactions, each including the error that caused the failure.\n * - `canceledTransactions`: An array of canceled transactions.\n */\nexport type TransactionPlanResultSummary<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n> = Readonly<{\n    canceledTransactions: CanceledSingleTransactionPlanResult<TContext, TTransactionMessage>[];\n    failedTransactions: FailedSingleTransactionPlanResult<TContext, TTransactionMessage>[];\n    successful: boolean;\n    successfulTransactions: SuccessfulSingleTransactionPlanResult<TContext, TTransactionMessage>[];\n}>;\n\n/**\n * Summarize a {@link TransactionPlanResult} into a {@link TransactionPlanResultSummary}.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results\n * @typeParam TTransactionMessage - The type of the transaction message\n * @param result The transaction plan result to summarize\n * @returns A summary of the transaction plan result\n */\nexport function summarizeTransactionPlanResult<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n    TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n        TransactionMessageWithFeePayer,\n>(\n    result: TransactionPlanResult<TContext, TTransactionMessage>,\n): TransactionPlanResultSummary<TContext, TTransactionMessage> {\n    type Out = TransactionPlanResultSummary<TContext, TTransactionMessage>;\n    const successfulTransactions: Out['successfulTransactions'] = [];\n    const failedTransactions: Out['failedTransactions'] = [];\n    const canceledTransactions: Out['canceledTransactions'] = [];\n\n    const flattenedResults = flattenTransactionPlanResult(result);\n\n    for (const singleResult of flattenedResults) {\n        switch (singleResult.status) {\n            case 'successful': {\n                successfulTransactions.push(singleResult);\n                break;\n            }\n            case 'failed': {\n                failedTransactions.push(singleResult);\n                break;\n            }\n            case 'canceled': {\n                canceledTransactions.push(singleResult);\n                break;\n            }\n        }\n    }\n\n    return Object.freeze({\n        canceledTransactions,\n        failedTransactions,\n        successful: failedTransactions.length === 0 && canceledTransactions.length === 0,\n        successfulTransactions,\n    });\n}\n","import {\n    isSolanaError,\n    type RpcSimulateTransactionResult,\n    SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION,\n    SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS,\n    SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTION,\n    SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTIONS,\n    SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN,\n    SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE,\n    SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT,\n    SolanaError,\n    type SolanaErrorCode,\n} from '@solana/errors';\n\nimport {\n    type CanceledSingleTransactionPlanResult,\n    type FailedSingleTransactionPlanResult,\n    flattenTransactionPlanResult,\n    type TransactionPlanResult,\n    type TransactionPlanResultContext,\n    type TransactionPlanResultContextWithSignature,\n} from './transaction-plan-result';\n\ntype PreflightData = Omit<RpcSimulateTransactionResult, 'err'>;\n\n/**\n * Creates a {@link SolanaError} with the {@link SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION}\n * error code from a failed or canceled {@link SingleTransactionPlanResult}.\n *\n * This is a high-level error designed for user-facing transaction send failures.\n * It unwraps simulation errors (such as preflight failures) to expose the\n * underlying transaction error as the `cause`, and extracts preflight data\n * and logs into the error context for easy access.\n *\n * The error message includes an indicator showing whether the failure was a\n * preflight error or includes the on-chain transaction signature for easy\n * copy-pasting into block explorers.\n *\n * @typeParam TContext - The type of the context object attached to the result. Any context is\n * accepted; the signature is read from it only if one happens to be there.\n * @param result - A failed or canceled single transaction plan result.\n * @param abortReason - An optional abort reason if the transaction was canceled.\n * @return A {@link SolanaError} with the appropriate error code, context, and cause.\n *\n * @example\n * Creating an error from a failed transaction plan result.\n * ```ts\n * import { createFailedToSendTransactionError } from '@solana/instruction-plans';\n *\n * const error = createFailedToSendTransactionError(failedResult);\n * console.log(error.message);\n * // \"Failed to send transaction (preflight): Insufficient funds for fee\"\n * console.log(error.cause);\n * // The unwrapped transaction error\n * console.log(error.context.logs);\n * // Transaction logs from the preflight simulation\n * ```\n *\n * @see {@link createFailedToSendTransactionsError}\n * @see {@link createFailedToSignTransactionError}\n */\nexport function createFailedToSendTransactionError<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(\n    result: CanceledSingleTransactionPlanResult<TContext> | FailedSingleTransactionPlanResult<TContext>,\n    abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION> {\n    return new SolanaError(\n        SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION,\n        getSingleFailureContext(result, abortReason, true /* includeSubmissionIndicator */),\n    );\n}\n\n/**\n * Creates a {@link SolanaError} with the {@link SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTION}\n * error code from a failed or canceled {@link SingleTransactionPlanResult}.\n *\n * This is the signing counterpart to {@link createFailedToSendTransactionError}, designed\n * for user-facing failures raised by executors that sign a transaction without submitting\n * it. It behaves identically — unwrapping simulation errors to expose the underlying\n * transaction error as the `cause`, and extracting preflight data and logs into the error\n * context — because signing executors typically estimate resource limits by simulating\n * before they sign.\n *\n * Unlike the sending variant, the message carries no indicator of where the failure\n * happened. That indicator locates a failure relative to network submission — `(preflight)`\n * before it, or the transaction signature after it — and signing never submits, so neither\n * applies. The `logs` and `preflightData` context properties are still populated whenever a\n * simulation was responsible, and those logs still appear in the message, so nothing is lost\n * beyond the prefix.\n *\n * @typeParam TContext - The type of the context object attached to the result. Any context is\n * accepted, since this helper never reads from it.\n * @param result - A failed or canceled single transaction plan result.\n * @param abortReason - An optional abort reason if the transaction was canceled.\n * @return A {@link SolanaError} with the appropriate error code, context, and cause.\n *\n * @example\n * Creating an error from a failed transaction plan result.\n * ```ts\n * import { createFailedToSignTransactionError } from '@solana/instruction-plans';\n *\n * const error = createFailedToSignTransactionError(failedResult);\n * console.log(error.message);\n * // \"Failed to sign transaction: The user rejected the signing request\"\n * console.log(error.cause);\n * // The unwrapped signing error\n * ```\n *\n * @see {@link createFailedToSignTransactionsError}\n * @see {@link createFailedToSendTransactionError}\n */\nexport function createFailedToSignTransactionError<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n>(\n    result: CanceledSingleTransactionPlanResult<TContext> | FailedSingleTransactionPlanResult<TContext>,\n    abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTION> {\n    return new SolanaError(\n        SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTION,\n        getSingleFailureContext(result, abortReason, false /* includeSubmissionIndicator */),\n    );\n}\n\n/**\n * Creates a {@link SolanaError} with the {@link SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS}\n * error code from a {@link TransactionPlanResult}.\n *\n * This is a high-level error designed for user-facing transaction send failures\n * involving multiple transactions. It walks the result tree, unwraps simulation\n * errors from each failure, and builds a `failedTransactions` array pairing each\n * failure with its unwrapped error, logs, and preflight data.\n *\n * The error message lists each failure with its position in the plan and an\n * indicator showing whether it was a preflight error or includes the transaction\n * signature. When all transactions were canceled, the message is a single line.\n *\n * @typeParam TContext - The type of the context object attached to the results. Any context is\n * accepted; each signature is read from it only if one happens to be there.\n * @param result - The full transaction plan result tree.\n * @param abortReason - An optional abort reason if the plan was aborted.\n * @return A {@link SolanaError} with the appropriate error code, context, and cause.\n *\n * @example\n * Creating an error from a failed transaction plan result.\n * ```ts\n * import { createFailedToSendTransactionsError } from '@solana/instruction-plans';\n *\n * const error = createFailedToSendTransactionsError(planResult);\n * console.log(error.message);\n * // \"Failed to send transactions.\n * // [Tx #1 (preflight)] Insufficient funds for fee\n * // [Tx #3 (5abc...)] Custom program error: 0x1\"\n * console.log(error.context.failedTransactions);\n * // [{ index: 0, error: ..., logs: [...], preflightData: {...} }, ...]\n * ```\n *\n * @see {@link createFailedToSendTransactionError}\n * @see {@link createFailedToSignTransactionsError}\n */\nexport function createFailedToSendTransactionsError<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(\n    result: TransactionPlanResult<TContext>,\n    abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS> {\n    return new SolanaError(\n        SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS,\n        getMultipleFailuresContext(result, abortReason, true /* includeSubmissionIndicator */),\n    );\n}\n\n/**\n * Creates a {@link SolanaError} with the {@link SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTIONS}\n * error code from a {@link TransactionPlanResult}.\n *\n * This is the signing counterpart to {@link createFailedToSendTransactionsError}, designed\n * for user-facing failures raised by executors that sign several transactions without\n * submitting them. It walks the result tree, unwraps simulation errors from each failure,\n * and builds the same `failedTransactions` array pairing each failure with its unwrapped\n * error, logs, and preflight data.\n *\n * As with {@link createFailedToSignTransactionError}, each line names only the position of\n * the failure in the plan. Nothing was submitted, so there is no preflight to flag and no\n * transaction signature worth quoting.\n *\n * @typeParam TContext - The type of the context object attached to the results. Any context is\n * accepted, since this helper never reads from it.\n * @param result - The full transaction plan result tree.\n * @param abortReason - An optional abort reason if the plan was aborted.\n * @return A {@link SolanaError} with the appropriate error code, context, and cause.\n *\n * @example\n * Creating an error from a failed transaction plan result.\n * ```ts\n * import { createFailedToSignTransactionsError } from '@solana/instruction-plans';\n *\n * const error = createFailedToSignTransactionsError(planResult);\n * console.log(error.message);\n * // \"Failed to sign transactions.\n * // [Tx #1] Insufficient funds for fee\n * // [Tx #3] The user rejected the signing request\"\n * console.log(error.context.failedTransactions);\n * // [{ index: 0, error: ..., logs: [...], preflightData: {...} }, ...]\n * ```\n *\n * @see {@link createFailedToSignTransactionError}\n * @see {@link createFailedToSendTransactionsError}\n */\nexport function createFailedToSignTransactionsError<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n>(\n    result: TransactionPlanResult<TContext>,\n    abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTIONS> {\n    return new SolanaError(\n        SOLANA_ERROR__FAILED_TO_SIGN_TRANSACTIONS,\n        getMultipleFailuresContext(result, abortReason, false /* includeSubmissionIndicator */),\n    );\n}\n\n/**\n * Builds the shared error context for the singular failed-to-send and failed-to-sign errors.\n *\n * @param includeSubmissionIndicator - Whether the message should indicate where the failure\n * occurred relative to network submission: `(preflight)` before it, or the transaction\n * signature after it. Signing never submits, so neither is meaningful there.\n */\nfunction getSingleFailureContext<TContext extends TransactionPlanResultContext>(\n    result: CanceledSingleTransactionPlanResult<TContext> | FailedSingleTransactionPlanResult<TContext>,\n    abortReason: unknown,\n    includeSubmissionIndicator: boolean,\n): Record<string, unknown> {\n    let causeMessage: string;\n    let cause: unknown;\n    let logs: readonly string[] | undefined;\n    let preflightData: PreflightData | undefined;\n\n    if (result.status === 'failed') {\n        const unwrapped = unwrapErrorWithPreflightData(result.error);\n        logs = unwrapped.logs;\n        preflightData = unwrapped.preflightData;\n        cause = unwrapped.unwrappedError;\n        const indicator = includeSubmissionIndicator\n            ? getFailedIndicator(!!preflightData, getSignatureFromContext(result.context))\n            : '';\n        causeMessage = `${indicator}: ${(cause as Error).message}${formatLogSnippet(logs)}`;\n    } else {\n        cause = abortReason;\n        causeMessage = abortReason != null ? `. Canceled with abort reason: ${String(abortReason)}` : ': Canceled';\n    }\n\n    const context: Record<string, unknown> = {\n        cause,\n        causeMessage,\n        logs,\n        preflightData,\n    };\n    Object.defineProperty(context, 'transactionPlanResult', {\n        configurable: false,\n        enumerable: false,\n        value: result,\n        writable: false,\n    });\n    return context;\n}\n\n/**\n * Builds the shared error context for the plural failed-to-send and failed-to-sign errors.\n *\n * @param includeSubmissionIndicator - Whether each line should indicate where that failure\n * occurred relative to network submission: `(preflight)` before it, or the transaction\n * signature after it. Signing never submits, so neither is meaningful there.\n */\nfunction getMultipleFailuresContext<TContext extends TransactionPlanResultContext>(\n    result: TransactionPlanResult<TContext>,\n    abortReason: unknown,\n    includeSubmissionIndicator: boolean,\n): Record<string, unknown> {\n    const flattenedResults = flattenTransactionPlanResult(result);\n\n    const failedTransactions = flattenedResults.flatMap((singleResult, index) => {\n        if (singleResult.status !== 'failed') return [];\n        const unwrapped = unwrapErrorWithPreflightData(singleResult.error);\n        return [\n            {\n                error: unwrapped.unwrappedError as Error,\n                index,\n                logs: unwrapped.logs,\n                preflightData: unwrapped.preflightData,\n            },\n        ];\n    });\n\n    let causeMessages: string;\n    let cause: unknown;\n\n    if (failedTransactions.length > 0) {\n        cause = failedTransactions.length === 1 ? failedTransactions[0].error : undefined;\n        const failureLines = failedTransactions.map(({ error, index, preflightData }) => {\n            const indicator = includeSubmissionIndicator\n                ? getFailedIndicator(!!preflightData, getSignatureFromContext(flattenedResults[index].context))\n                : '';\n            return `\\n[Tx #${index + 1}${indicator}] ${error.message}`;\n        });\n        const logSnippet = failedTransactions.length === 1 ? formatLogSnippet(failedTransactions[0].logs) : '';\n        causeMessages = `.${failureLines.join('')}${logSnippet}${logSnippet ? '' : '\\n'}`;\n    } else {\n        cause = abortReason;\n        causeMessages = abortReason != null ? `. Canceled with abort reason: ${String(abortReason)}` : ': Canceled';\n    }\n\n    const context: Record<string, unknown> = {\n        cause,\n        causeMessages,\n        failedTransactions,\n    };\n    Object.defineProperty(context, 'transactionPlanResult', {\n        configurable: false,\n        enumerable: false,\n        value: result,\n        writable: false,\n    });\n    return context;\n}\n\n/**\n * Creates a {@link SolanaError} with the\n * {@link SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN}\n * error code from a {@link TransactionPlanResult}.\n *\n * This is a low-level error intended for custom transaction plan executor\n * authors. It attaches the full `transactionPlanResult` as a non-enumerable\n * property so that callers can inspect execution details without the result\n * being serialized with the error.\n *\n * @typeParam TContext - The type of the context object attached to the results. Any context is\n * accepted, since this helper never reads from it.\n * @param result - The full transaction plan result tree.\n * @param abortReason - An optional abort reason if the plan was aborted.\n * @return A {@link SolanaError} with the appropriate error code and context.\n *\n * @example\n * Throwing a failed-to-execute error from a custom executor.\n * ```ts\n * import { createFailedToExecuteTransactionPlanError } from '@solana/instruction-plans';\n *\n * throw createFailedToExecuteTransactionPlanError(transactionPlanResult, abortSignal?.reason);\n * ```\n *\n * @see {@link createFailedToSendTransactionError}\n * @see {@link createFailedToSendTransactionsError}\n */\nexport function createFailedToExecuteTransactionPlanError<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(\n    result: TransactionPlanResult<TContext>,\n    abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN> {\n    const context: Record<string, unknown> = {\n        abortReason,\n        // Deprecated: will be removed in a future version.\n        cause: findErrorFromTransactionPlanResult(result) ?? abortReason,\n    };\n    Object.defineProperty(context, 'transactionPlanResult', {\n        configurable: false,\n        enumerable: false,\n        value: result,\n        writable: false,\n    });\n    return new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN, context);\n}\n\nfunction unwrapErrorWithPreflightData(error: Error): {\n    logs: readonly string[] | undefined;\n    preflightData: PreflightData | undefined;\n    unwrappedError: unknown;\n} {\n    const simulationCodes: SolanaErrorCode[] = [\n        SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE,\n        SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT,\n    ];\n    if (isSolanaError(error) && simulationCodes.includes(error.context.__code)) {\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        const { __code, ...preflightData } = error.context;\n        return {\n            logs: (preflightData as PreflightData).logs ?? undefined,\n            preflightData: preflightData as PreflightData,\n            unwrappedError: error.cause ?? error,\n        };\n    }\n    return { logs: undefined, preflightData: undefined, unwrappedError: error };\n}\n\nfunction findErrorFromTransactionPlanResult<TContext extends TransactionPlanResultContext>(\n    result: TransactionPlanResult<TContext>,\n): Error | undefined {\n    if (result.kind === 'single') {\n        return result.status === 'failed' ? result.error : undefined;\n    }\n    for (const plan of result.plans) {\n        const error = findErrorFromTransactionPlanResult(plan);\n        if (error) {\n            return error;\n        }\n    }\n}\n\nfunction formatLogSnippet(logs: readonly string[] | undefined): string {\n    if (!logs || logs.length === 0) return '';\n    const maxLines = 8;\n    const lastLines = logs.slice(-maxLines);\n    const header = logs.length > maxLines ? `\\n\\nLogs (last ${maxLines} of ${logs.length}):` : '\\n\\nLogs:';\n    return `${header}\\n${lastLines.map(line => `  > ${line}\\n`).join('')}`;\n}\n\n/**\n * Reads a signature out of an arbitrary result context.\n *\n * Nothing guarantees that a context has a signature — an executor may produce results for\n * transactions it never submitted — so this narrows at runtime rather than trusting the type.\n */\nfunction getSignatureFromContext(context: TransactionPlanResultContext): string | undefined {\n    return typeof context.signature === 'string' ? context.signature : undefined;\n}\n\nfunction getFailedIndicator(isPreflight: boolean, signature: string | undefined): string {\n    if (isPreflight) return ' (preflight)';\n    if (signature) return ` (${signature})`;\n    return '';\n}\n","import {\n    isSolanaError,\n    SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN,\n    SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED,\n    SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND,\n    SolanaError,\n} from '@solana/errors';\nimport { getAbortablePromise } from '@solana/promises';\nimport type { TransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\n\nimport type {\n    ParallelTransactionPlan,\n    SequentialTransactionPlan,\n    SingleTransactionPlan,\n    TransactionPlan,\n} from './transaction-plan';\nimport { createFailedToExecuteTransactionPlanError } from './transaction-plan-errors';\nimport {\n    canceledSingleTransactionPlanResult,\n    failedSingleTransactionPlanResult,\n    isSuccessfulTransactionPlanResult,\n    nonDivisibleSequentialTransactionPlanResult,\n    parallelTransactionPlanResult,\n    sequentialTransactionPlanResult,\n    SingleTransactionPlanResult,\n    successfulSingleTransactionPlanResult,\n    type TransactionPlanResult,\n    type TransactionPlanResultContext,\n    type TransactionPlanResultContextWithSignature,\n} from './transaction-plan-result';\n\n/**\n * Executes a transaction plan and returns the execution results.\n *\n * This function traverses the transaction plan tree, executing each transaction\n * message and collecting results that mirror the structure of the original plan.\n *\n * The zero-argument spelling defaults `TContext` to {@link TransactionPlanResultContextWithSignature},\n * so its results guarantee a `context.signature` on every successful single result — but a different\n * `TContext` may drop that guarantee entirely.\n *\n * @typeParam TContext - The type of the context object that may be passed along with results.\n * @param transactionPlan - The transaction plan to execute.\n * @param config - Optional configuration object that can include an `AbortSignal` to cancel execution.\n * @return A promise that resolves to the execution results.\n *\n * @see {@link TransactionPlan}\n * @see {@link TransactionPlanResult}\n * @see {@link createTransactionPlanExecutor}\n */\nexport type TransactionPlanExecutor<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n> = (\n    transactionPlan: TransactionPlan,\n    config?: { abortSignal?: AbortSignal },\n) => Promise<TransactionPlanResult<TContext>>;\n\ntype ExecuteTransactionMessage<TContext extends TransactionPlanResultContext> = (\n    context: Partial<TContext>,\n    transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,\n    config?: { abortSignal?: AbortSignal },\n) => Promise<TContext>;\n\n/**\n * Configuration object for creating a new transaction plan executor.\n *\n * @see {@link createTransactionPlanExecutor}\n * @see {@link createTransactionPlanExecutorWithConcurrentLeaves}\n */\nexport type TransactionPlanExecutorConfig<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n> = {\n    /**\n     * Called whenever a transaction message must be executed.\n     *\n     * It should return the context that the successful result must carry — every property\n     * `TContext` promises, which by default includes a `signature`.\n     */\n    executeTransactionMessage: ExecuteTransactionMessage<TContext>;\n};\n\n/**\n * Creates a new transaction plan executor based on the provided configuration.\n *\n * The executor will traverse the provided `TransactionPlan` sequentially or in parallel,\n * executing each transaction message using the `executeTransactionMessage` function.\n *\n * The `executeTransactionMessage` callback receives a mutable context object as its first\n * argument, which can be used to incrementally store useful data as execution progresses\n * (e.g. the latest version of the transaction message after setting its lifetime, the\n * compiled and signed transaction, the transaction signature, or any custom properties).\n * This context is included in the resulting {@link SingleTransactionPlanResult} regardless\n * of the outcome. This means that if an error is thrown at any point in the callback, any\n * attributes already saved to the context will still be available in the plan result, which\n * can be useful for debugging failures or building recovery plans.\n *\n * The callback then returns the context a successful result should carry, as a complete\n * `TContext`. The executor writes nothing to it on the callback's behalf — notably, it does not\n * derive a `signature` from a stored transaction. Producing `signature` is therefore the callback's\n * job, and an executor that produces transactions its fee payer has not signed can simply leave the\n * property out and declare a `TContext` that does not require it.\n *\n * Requiring that return value is what keeps `TContext` honest: a callback that declares a context\n * with a required `signature` and never produces one fails to compile, rather than yielding a\n * result whose `context.signature` is typed but `undefined` at runtime. Note that the mutable\n * context cannot itself be returned — every property on it is optional, so it does not satisfy\n * `TContext`. Return an object built from the values you have instead:\n *\n * ```ts\n * executeTransactionMessage: async (context, message) => {\n *     const transaction = await signTransactionMessageWithSigners(message);\n *     context.transaction = transaction; // Recorded now, in case the next step throws.\n *     const signature = getSignatureFromTransaction(transaction);\n *     await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n *     return { signature, transaction };\n * }\n * ```\n *\n * The two channels serve different outcomes. Mutating the context makes a value available to a\n * *failed* result; returning it makes a value available to a *successful* one. On success the two\n * are merged, with the returned value taking precedence, so a property stored on the context but\n * omitted from the return value is still reported.\n *\n * `TContext` is the only thing that says what a context contains — the executor adds nothing of its\n * own on top, in either direction. It defaults to {@link TransactionPlanResultContextWithSignature},\n * which is why the zero-type-argument spelling hands the callback the familiar `message`,\n * `transaction` and `signature` properties and guarantees a `context.signature` on every successful\n * result. Supply a different `TContext` and you get exactly that instead, so intersect one of the\n * base context types in if you want those properties alongside your own:\n *\n * ```ts\n * createTransactionPlanExecutor<TransactionPlanResultContextWithSignature & { startedAt: number }>(config);\n * ```\n *\n * Note the asymmetry between the callback's two context types. A fresh context is created for\n * every single transaction plan, so on entry it is empty and *every* property of `TContext` is\n * optional on the parameter — populating them is the callback's job, not a guarantee the executor\n * makes. The value it returns is a complete `TContext`, which is what lets the\n * `TransactionPlanExecutor` this factory returns report a successful result's context as fully\n * populated. Declare the properties you intend to produce as an explicit type argument to this\n * function; a callback cannot annotate its own context parameter with required properties, because\n * none of them are present when it is called.\n *\n * - If that function is successful, the executor will return a successful `TransactionPlanResult`\n * for that message, carrying the context the callback returned merged over the one it mutated.\n * - If that function throws an error, the executor will stop processing and cancel all\n * remaining transaction messages in the plan. The context accumulated up to the point of\n * failure is preserved in the resulting {@link FailedSingleTransactionPlanResult}.\n * - If the `abortSignal` is triggered, the executor will immediately stop processing the plan and\n * return a `TransactionPlanResult` with the status set to `canceled`.\n *\n * @param config - Configuration object containing the transaction message executor function.\n * @return A {@link TransactionPlanExecutor} function that can execute transaction plans.\n *\n * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN}\n *   if any transaction in the plan fails to execute. The error context contains a\n *   `transactionPlanResult` property with the partial results up to the point of failure.\n * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED}\n *   if the transaction plan contains non-divisible sequential plans, which are not\n *   supported by this executor.\n *\n * @example\n * ```ts\n * const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });\n *\n * const transactionPlanExecutor = createTransactionPlanExecutor({\n *   executeTransactionMessage: async (context, message) => {\n *     const transaction = await signTransactionMessageWithSigners(message);\n *     context.transaction = transaction;\n *     const signature = getSignatureFromTransaction(transaction);\n *     await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n *     return { signature, transaction };\n *   }\n * });\n * ```\n *\n * @see {@link TransactionPlanExecutorConfig}\n */\nexport function createTransactionPlanExecutor<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(config: TransactionPlanExecutorConfig<TContext>): TransactionPlanExecutor<TContext> {\n    return async (plan, { abortSignal } = {}): Promise<TransactionPlanResult<TContext>> => {\n        const traverseConfig: TraverseConfig<TContext> = {\n            ...config,\n            abortSignal: abortSignal,\n            canceled: abortSignal?.aborted ?? false,\n        };\n\n        // Fail early if there are non-divisible sequential plans in the\n        // transaction plan as they are not supported by this executor.\n        assertDivisibleSequentialPlansOnly(plan);\n\n        const cancelHandler = () => {\n            traverseConfig.canceled = true;\n        };\n        abortSignal?.addEventListener('abort', cancelHandler);\n        const transactionPlanResult = await traverse<TContext>(plan, traverseConfig);\n        abortSignal?.removeEventListener('abort', cancelHandler);\n\n        if (traverseConfig.canceled) {\n            const abortReason = abortSignal?.aborted ? abortSignal.reason : undefined;\n            throw createFailedToExecuteTransactionPlanError(transactionPlanResult, abortReason);\n        }\n\n        return transactionPlanResult;\n    };\n}\n\n/**\n * Creates a transaction plan executor that processes every leaf concurrently.\n *\n * It takes the same configuration as {@link createTransactionPlanExecutor} and its\n * `executeTransactionMessage` callback follows the same contract: it receives a fresh mutable\n * context object for every leaf and returns the complete `TContext` a successful result must\n * carry. On success the two are merged with the returned value taking precedence; on a throw\n * the context accumulated so far is preserved in the failed result.\n *\n * The difference is the traversal. This executor preserves the input plan's nesting, order, and\n * divisibility in the returned result, but it does not enforce the execution dependencies\n * expressed by sequential plans: every leaf callback is started immediately, without a concurrency\n * limit. This makes it suitable for operations such as signing or serializing transactions that\n * can be performed independently. For the same reason, a callback that throws does not cancel the\n * other leaves — each one runs to completion — and non-divisible sequential plans are supported.\n *\n * The optional abort signal is forwarded to every leaf callback and enforced by the executor.\n * When the signal is already aborted, leaves are canceled without invoking their callbacks. When\n * it is aborted during execution, the executor stops waiting for active callbacks and records\n * failed results carrying the abort reason and the context accumulated so far — a value the\n * callback resolves with afterwards is discarded.\n *\n * After all leaves settle, a plan containing failed or canceled results throws a failed execution\n * error containing the complete result tree.\n *\n * @typeParam TContext - The context carried by each single transaction plan result.\n * @param config - Configuration object containing the transaction message executor function.\n * @return A {@link TransactionPlanExecutor} that processes all transaction plan leaves concurrently.\n * @throws {@link SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN}\n *   if any leaf callback throws, any leaf is canceled, or the abort signal fires. The error\n *   context contains a `transactionPlanResult` property with the complete result tree.\n * @throws {@link SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND} if the plan has an unknown kind.\n *\n * @example\n * Signing every transaction in a plan concurrently.\n * ```ts\n * const executor = createTransactionPlanExecutorWithConcurrentLeaves<{ transaction: Transaction }>({\n *     executeTransactionMessage: async (_context, message) => {\n *         const transaction = await signTransactionMessageWithSigners(message);\n *         return { transaction };\n *     },\n * });\n * const result = await executor(transactionPlan);\n * ```\n *\n * @see {@link TransactionPlanExecutorConfig}\n * @see {@link createTransactionPlanExecutor}\n */\nexport function createTransactionPlanExecutorWithConcurrentLeaves<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(config: TransactionPlanExecutorConfig<TContext>): TransactionPlanExecutor<TContext> {\n    return async (transactionPlan, executorConfig) => {\n        const transactionPlanResult = await traverseTransactionPlanLeavesConcurrently(\n            transactionPlan,\n            config.executeTransactionMessage,\n            executorConfig,\n        );\n        if (executorConfig?.abortSignal?.aborted || !isSuccessfulTransactionPlanResult(transactionPlanResult)) {\n            const abortReason = executorConfig?.abortSignal?.aborted ? executorConfig.abortSignal.reason : undefined;\n            throw createFailedToExecuteTransactionPlanError(transactionPlanResult, abortReason);\n        }\n        return transactionPlanResult;\n    };\n}\n\nasync function traverseTransactionPlanLeavesConcurrently<TContext extends TransactionPlanResultContext>(\n    transactionPlan: TransactionPlan,\n    executeTransactionMessage: ExecuteTransactionMessage<TContext>,\n    executorConfig?: { abortSignal?: AbortSignal },\n): Promise<TransactionPlanResult<TContext>> {\n    const kind = transactionPlan.kind;\n    switch (kind) {\n        case 'single': {\n            // A fresh context is created for every leaf, so nothing is populated yet. Filling it in\n            // is the `executeTransactionMessage` callback's job, which is why every property of\n            // `TContext` is optional here.\n            const context: Partial<TContext> = {};\n            if (executorConfig?.abortSignal?.aborted) {\n                return canceledSingleTransactionPlanResult<TContext>(transactionPlan.message, context);\n            }\n            try {\n                const returnedContext = await getAbortablePromise(\n                    executeTransactionMessage(context, transactionPlan.message, {\n                        abortSignal: executorConfig?.abortSignal,\n                    }),\n                    executorConfig?.abortSignal,\n                );\n                // Anything the callback stored on the mutable context but left out of its return\n                // value is kept, since dropping it would lose data it deliberately recorded.\n                return successfulSingleTransactionPlanResult<TContext>(transactionPlan.message, {\n                    ...context,\n                    ...returnedContext,\n                });\n            } catch (error) {\n                return failedSingleTransactionPlanResult<TContext>(transactionPlan.message, error as Error, context);\n            }\n        }\n        case 'parallel':\n        case 'sequential': {\n            const plans = await Promise.all(\n                transactionPlan.plans.map(plan =>\n                    traverseTransactionPlanLeavesConcurrently(plan, executeTransactionMessage, executorConfig),\n                ),\n            );\n            if (kind === 'parallel') {\n                return parallelTransactionPlanResult(plans);\n            }\n            return transactionPlan.divisible\n                ? sequentialTransactionPlanResult(plans)\n                : nonDivisibleSequentialTransactionPlanResult(plans);\n        }\n        default:\n            kind satisfies never;\n            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND, { kind });\n    }\n}\n\ntype TraverseConfig<TContext extends TransactionPlanResultContext> = TransactionPlanExecutorConfig<TContext> & {\n    abortSignal?: AbortSignal;\n    canceled: boolean;\n};\n\nasync function traverse<TContext extends TransactionPlanResultContext>(\n    transactionPlan: TransactionPlan,\n    traverseConfig: TraverseConfig<TContext>,\n): Promise<TransactionPlanResult<TContext>> {\n    const kind = transactionPlan.kind;\n    switch (kind) {\n        case 'sequential':\n            return await traverseSequential(transactionPlan, traverseConfig);\n        case 'parallel':\n            return await traverseParallel(transactionPlan, traverseConfig);\n        case 'single':\n            return await traverseSingle(transactionPlan, traverseConfig);\n        default:\n            transactionPlan satisfies never;\n            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND, { kind });\n    }\n}\n\nasync function traverseSequential<TContext extends TransactionPlanResultContext>(\n    transactionPlan: SequentialTransactionPlan,\n    traverseConfig: TraverseConfig<TContext>,\n): Promise<TransactionPlanResult<TContext>> {\n    if (!transactionPlan.divisible) {\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED);\n    }\n\n    const results: TransactionPlanResult<TContext>[] = [];\n\n    for (const subPlan of transactionPlan.plans) {\n        const result = await traverse(subPlan, traverseConfig);\n        results.push(result);\n    }\n\n    return sequentialTransactionPlanResult(results);\n}\n\nasync function traverseParallel<TContext extends TransactionPlanResultContext>(\n    transactionPlan: ParallelTransactionPlan,\n    traverseConfig: TraverseConfig<TContext>,\n): Promise<TransactionPlanResult<TContext>> {\n    const results = await Promise.all(transactionPlan.plans.map(plan => traverse(plan, traverseConfig)));\n    return parallelTransactionPlanResult(results);\n}\n\nasync function traverseSingle<TContext extends TransactionPlanResultContext>(\n    transactionPlan: SingleTransactionPlan,\n    traverseConfig: TraverseConfig<TContext>,\n): Promise<TransactionPlanResult<TContext>> {\n    // A fresh context is created for every single transaction plan, so nothing is populated\n    // yet. Filling it in is the `executeTransactionMessage` callback's job, which is why\n    // every property of `TContext` is optional here. Note that `TContext` is the only thing\n    // that says what a context contains; the executor adds no fields of its own.\n    const context: Partial<TContext> = {};\n    if (traverseConfig.canceled) {\n        return canceledSingleTransactionPlanResult<TContext>(transactionPlan.message, context);\n    }\n\n    try {\n        const returnedContext = await getAbortablePromise(\n            traverseConfig.executeTransactionMessage(context, transactionPlan.message, {\n                abortSignal: traverseConfig.abortSignal,\n            }),\n            traverseConfig.abortSignal,\n        );\n        // The callback proved the context is fully populated by returning it, so no assertion is\n        // needed here. Anything it stored on the mutable context but left out of its return value\n        // is kept, since dropping it would lose data the callback deliberately recorded.\n        return successfulSingleTransactionPlanResult<TContext>(transactionPlan.message, {\n            ...context,\n            ...returnedContext,\n        });\n    } catch (error) {\n        traverseConfig.canceled = true;\n        return failedSingleTransactionPlanResult<TContext>(transactionPlan.message, error as Error, context);\n    }\n}\n\nfunction assertDivisibleSequentialPlansOnly(transactionPlan: TransactionPlan): void {\n    const kind = transactionPlan.kind;\n    switch (kind) {\n        case 'sequential':\n            if (!transactionPlan.divisible) {\n                throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED);\n            }\n            for (const subPlan of transactionPlan.plans) {\n                assertDivisibleSequentialPlansOnly(subPlan);\n            }\n            return;\n        case 'parallel':\n            for (const subPlan of transactionPlan.plans) {\n                assertDivisibleSequentialPlansOnly(subPlan);\n            }\n            return;\n        case 'single':\n        default:\n            return;\n    }\n}\n\n/**\n * Wraps a transaction plan execution promise to return a\n * {@link TransactionPlanResult} even on execution failure.\n *\n * When a transaction plan executor throws a\n * {@link SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN}\n * error, this helper catches it and returns the `TransactionPlanResult`\n * from the error context instead of throwing.\n *\n * This allows us to handle the result of an execution in a single unified way\n * instead of using try/catch and examine the `TransactionPlanResult` in both\n * success and failure cases.\n *\n * Any other errors are re-thrown as normal.\n *\n * @typeParam TContext - The type of the context object attached to the results. Any context is\n * accepted, since this helper never reads from it.\n * @param promise - A promise returned by a transaction plan executor.\n * @return A promise that resolves to the transaction plan result, even if some transactions failed.\n *\n * @example\n * Handling failures using a single result object:\n * ```ts\n * const result = await passthroughFailedTransactionPlanExecution(\n *   transactionPlanExecutor(transactionPlan)\n * );\n *\n * const summary = summarizeTransactionPlanResult(result);\n * if (summary.successful) {\n *   console.log('All transactions executed successfully');\n * } else {\n *   console.log(`${summary.successfulTransactions.length} succeeded`);\n *   console.log(`${summary.failedTransactions.length} failed`);\n *   console.log(`${summary.canceledTransactions.length} canceled`);\n * }\n * ```\n *\n * @see {@link TransactionPlanResult}\n * @see {@link createTransactionPlanExecutor}\n * @see {@link summarizeTransactionPlanResult}\n */\nexport async function passthroughFailedTransactionPlanExecution<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(promise: Promise<SingleTransactionPlanResult<TContext>>): Promise<SingleTransactionPlanResult<TContext>>;\nexport async function passthroughFailedTransactionPlanExecution<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(promise: Promise<TransactionPlanResult<TContext>>): Promise<TransactionPlanResult<TContext>>;\nexport async function passthroughFailedTransactionPlanExecution<\n    TContext extends TransactionPlanResultContext = TransactionPlanResultContextWithSignature,\n>(promise: Promise<TransactionPlanResult<TContext>>): Promise<TransactionPlanResult<TContext>> {\n    try {\n        return await promise;\n    } catch (error) {\n        if (isSolanaError(error, SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN)) {\n            return error.context.transactionPlanResult as TransactionPlanResult<TContext>;\n        }\n        throw error;\n    }\n}\n","import {\n    isSolanaError,\n    SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN,\n    SOLANA_ERROR__INSTRUCTION_PLANS__MAX_INSTRUCTIONS_PER_TRANSACTION_EXCEEDED,\n    SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN,\n    SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND,\n    SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND,\n    SOLANA_ERROR__TRANSACTION__TOO_MANY_ACCOUNT_ADDRESSES,\n    SOLANA_ERROR__TRANSACTION__TOO_MANY_ACCOUNTS_IN_INSTRUCTION,\n    SOLANA_ERROR__TRANSACTION__TOO_MANY_INSTRUCTIONS,\n    SOLANA_ERROR__TRANSACTION__TOO_MANY_SIGNER_ADDRESSES,\n    SolanaError,\n} from '@solana/errors';\nimport { getAbortablePromise } from '@solana/promises';\nimport {\n    appendTransactionMessageInstructions,\n    TransactionMessage,\n    TransactionMessageWithFeePayer,\n} from '@solana/transaction-messages';\nimport { getTransactionMessageSize, getTransactionMessageSizeLimit } from '@solana/transactions';\n\nimport {\n    InstructionPlan,\n    MessagePackerInstructionPlan,\n    ParallelInstructionPlan,\n    SequentialInstructionPlan,\n    SingleInstructionPlan,\n} from './instruction-plan';\nimport {\n    assertMaxInstructionsPerTransaction,\n    assertValidMaxInstructionsPerTransaction,\n    resolveMaxInstructions,\n} from './max-instructions';\nimport {\n    flattenTransactionPlan,\n    nonDivisibleSequentialTransactionPlan,\n    parallelTransactionPlan,\n    sequentialTransactionPlan,\n    SingleTransactionPlan,\n    singleTransactionPlan,\n    TransactionPlan,\n} from './transaction-plan';\n\n/**\n * Plans one or more transactions according to the provided instruction plan.\n *\n * @param instructionPlan - The instruction plan to be planned and executed.\n * @param config - Optional configuration object for the planning process.\n *\n * @see {@link InstructionPlan}\n * @see {@link TransactionPlan}\n */\nexport type TransactionPlanner = (\n    instructionPlan: InstructionPlan,\n    config?: {\n        abortSignal?: AbortSignal;\n        /**\n         * Maximum number of instructions allowed in each planned transaction.\n         *\n         * Must be a positive integer no greater than `64` — the number of top-level instructions\n         * the transaction format can encode. Larger values throw\n         * {@link SOLANA_ERROR__INSTRUCTION_PLANS__INVALID_MAX_INSTRUCTIONS_PER_TRANSACTION}.\n         * Defaults to 16.\n         */\n        maxInstructionsPerTransaction?: number;\n    },\n) => Promise<TransactionPlan>;\n\ntype Mutable<T> = { -readonly [P in keyof T]: T[P] };\n\ntype CreateTransactionMessage = (config?: {\n    abortSignal?: AbortSignal;\n}) =>\n    | Promise<TransactionMessage & TransactionMessageWithFeePayer>\n    | (TransactionMessage & TransactionMessageWithFeePayer);\n\ntype OnTransactionMessageUpdated = (\n    transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,\n    config?: { abortSignal?: AbortSignal },\n) =>\n    | Promise<TransactionMessage & TransactionMessageWithFeePayer>\n    | (TransactionMessage & TransactionMessageWithFeePayer);\n\n/**\n * Configuration object for creating a new transaction planner.\n *\n * @see {@link createTransactionPlanner}\n */\nexport type TransactionPlannerConfig = {\n    /** Called whenever a new transaction message is needed. */\n    createTransactionMessage: CreateTransactionMessage;\n    /**\n     * Maximum number of instructions allowed in each planned transaction.\n     *\n     * This includes any instructions already present in messages returned by\n     * `createTransactionMessage` and any instructions added by\n     * `onTransactionMessageUpdated`.\n     *\n     * Must be a positive integer no greater than `64` — the number of top-level instructions\n     * the transaction format can encode. Larger values throw\n     * {@link SOLANA_ERROR__INSTRUCTION_PLANS__INVALID_MAX_INSTRUCTIONS_PER_TRANSACTION}.\n     * Defaults to 16.\n     */\n    maxInstructionsPerTransaction?: number;\n    /**\n     * Called whenever a transaction message is updated — e.g. new instructions were added.\n     * This function must return the updated transaction message back — even if no changes were made.\n     */\n    onTransactionMessageUpdated?: OnTransactionMessageUpdated;\n};\n\n/**\n * Creates a new transaction planner based on the provided configuration.\n *\n * At the very least, the `createTransactionMessage` function must be provided.\n * This function is used to create new transaction messages whenever needed.\n *\n * Additionally, the `onTransactionMessageUpdated` function can be provided\n * to update transaction messages during the planning process. This function will\n * be called whenever a transaction message is updated, e.g. when new instructions\n * are added to a transaction message. It accepts the updated transaction message\n * and must return a transaction message back, even if no changes were made.\n *\n * You may also provide `maxInstructionsPerTransaction` to limit the number of\n * instructions in each planned transaction message. This limit includes any\n * instructions already present in messages returned by `createTransactionMessage`\n * and any instructions added by `onTransactionMessageUpdated`. It must be a positive\n * integer no greater than the hard limit of `64` instructions per transaction; larger\n * values throw. Defaults to 16.\n *\n * @example\n * ```ts\n * const transactionPlanner = createTransactionPlanner({\n *   createTransactionMessage: () => pipe(\n *     createTransactionMessage({ version: 0 }),\n *     message => setTransactionMessageFeePayerSigner(mySigner, message),\n *   )\n * });\n * ```\n *\n * @see {@link TransactionPlannerConfig}\n */\nexport function createTransactionPlanner(config: TransactionPlannerConfig): TransactionPlanner {\n    return async (instructionPlan, { abortSignal, maxInstructionsPerTransaction } = {}): Promise<TransactionPlan> => {\n        const resolvedMaxInstructionsPerTransaction =\n            maxInstructionsPerTransaction ?? config.maxInstructionsPerTransaction;\n        // Reject up front any configured maximum the transaction format could never satisfy, rather\n        // than discovering it mid-plan when a message fails to compile.\n        assertValidMaxInstructionsPerTransaction(resolvedMaxInstructionsPerTransaction);\n        const plan = await traverse(instructionPlan, {\n            abortSignal,\n            createTransactionMessage: config.createTransactionMessage,\n            maxInstructionsPerTransaction: resolvedMaxInstructionsPerTransaction,\n            onTransactionMessageUpdated: config.onTransactionMessageUpdated ?? (msg => msg),\n            parent: null,\n            parentCandidates: [],\n        });\n\n        if (!plan) {\n            throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN);\n        }\n\n        return freezeTransactionPlan(plan);\n    };\n}\n\ntype MutableTransactionPlan = Mutable<TransactionPlan>;\ntype MutableSingleTransactionPlan = Mutable<SingleTransactionPlan>;\n\ntype TraverseContext = {\n    abortSignal?: AbortSignal;\n    createTransactionMessage: CreateTransactionMessage;\n    maxInstructionsPerTransaction: number | undefined;\n    onTransactionMessageUpdated: OnTransactionMessageUpdated;\n    parent: InstructionPlan | null;\n    parentCandidates: MutableSingleTransactionPlan[];\n};\n\nasync function traverse(\n    instructionPlan: InstructionPlan,\n    context: TraverseContext,\n): Promise<MutableTransactionPlan | null> {\n    context.abortSignal?.throwIfAborted();\n    const kind = instructionPlan.kind;\n    switch (kind) {\n        case 'sequential':\n            return await traverseSequential(instructionPlan, context);\n        case 'parallel':\n            return await traverseParallel(instructionPlan, context);\n        case 'single':\n            return await traverseSingle(instructionPlan, context);\n        case 'messagePacker':\n            return await traverseMessagePacker(instructionPlan, context);\n        default:\n            instructionPlan satisfies never;\n            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND, { kind });\n    }\n}\n\nasync function traverseSequential(\n    instructionPlan: SequentialInstructionPlan,\n    context: TraverseContext,\n): Promise<MutableTransactionPlan | null> {\n    let candidate: MutableSingleTransactionPlan | null = null;\n\n    // Check if the sequential plan must fit entirely in its parent candidates\n    // due to constraints like being inside a parallel plan or not being divisible.\n    const mustEntirelyFitInParentCandidate =\n        context.parent && (context.parent.kind === 'parallel' || !instructionPlan.divisible);\n\n    // If so, try to fit the entire plan inside one of the parent candidates.\n    if (mustEntirelyFitInParentCandidate) {\n        const candidate = await selectAndMutateCandidate(context, context.parentCandidates, message =>\n            fitEntirePlanInsideMessage(context, instructionPlan, message),\n        );\n        // If that's possible, we the candidate is mutated and we can return null.\n        // Otherwise, we proceed with the normal traversal and no parent candidate.\n        if (candidate) {\n            return null;\n        }\n    } else {\n        // Otherwise, we can use the first parent candidate, if any,\n        // since we know it must be a divisible sequential plan.\n        candidate = context.parentCandidates.length > 0 ? context.parentCandidates[0] : null;\n    }\n\n    const transactionPlans: TransactionPlan[] = [];\n    for (const plan of instructionPlan.plans) {\n        const transactionPlan = await traverse(plan, {\n            ...context,\n            parent: instructionPlan,\n            parentCandidates: candidate ? [candidate] : [],\n        });\n        if (transactionPlan) {\n            candidate = getSequentialCandidate(transactionPlan);\n            const newPlans =\n                transactionPlan.kind === 'sequential' && (transactionPlan.divisible || !instructionPlan.divisible)\n                    ? transactionPlan.plans\n                    : [transactionPlan];\n            transactionPlans.push(...newPlans);\n        }\n    }\n\n    // Wrap in a sequential plan or simplify.\n    if (transactionPlans.length === 1) {\n        return transactionPlans[0];\n    }\n    if (transactionPlans.length === 0) {\n        return null;\n    }\n    return {\n        divisible: instructionPlan.divisible,\n        kind: 'sequential',\n        planType: 'transactionPlan',\n        plans: transactionPlans,\n    };\n}\n\nasync function traverseParallel(\n    instructionPlan: ParallelInstructionPlan,\n    context: TraverseContext,\n): Promise<MutableTransactionPlan | null> {\n    const candidates: MutableSingleTransactionPlan[] = [...context.parentCandidates];\n    const transactionPlans: TransactionPlan[] = [];\n\n    // Reorder children so message packer plans are last.\n    const sortedChildren = Array.from(instructionPlan.plans).sort(\n        (a, b) => Number(a.kind === 'messagePacker') - Number(b.kind === 'messagePacker'),\n    );\n\n    for (const plan of sortedChildren) {\n        const transactionPlan = await traverse(plan, {\n            ...context,\n            parent: instructionPlan,\n            parentCandidates: candidates,\n        });\n        if (transactionPlan) {\n            candidates.push(...getParallelCandidates(transactionPlan));\n            const newPlans = transactionPlan.kind === 'parallel' ? transactionPlan.plans : [transactionPlan];\n            transactionPlans.push(...newPlans);\n        }\n    }\n\n    // Wrap in a parallel plan or simplify.\n    if (transactionPlans.length === 1) {\n        return transactionPlans[0];\n    }\n    if (transactionPlans.length === 0) {\n        return null;\n    }\n    return { kind: 'parallel', planType: 'transactionPlan', plans: transactionPlans };\n}\n\nasync function traverseSingle(\n    instructionPlan: SingleInstructionPlan,\n    context: TraverseContext,\n): Promise<MutableTransactionPlan | null> {\n    const predicate = (message: TransactionMessage & TransactionMessageWithFeePayer) =>\n        appendTransactionMessageInstructions([instructionPlan.instruction], message);\n    const candidate = await selectAndMutateCandidate(context, context.parentCandidates, predicate);\n    if (candidate) {\n        return null;\n    }\n    const message = await createNewMessage(context, predicate);\n    return { kind: 'single', message, planType: 'transactionPlan' };\n}\n\nasync function traverseMessagePacker(\n    instructionPlan: MessagePackerInstructionPlan,\n    context: TraverseContext,\n): Promise<MutableTransactionPlan | null> {\n    const messagePacker = instructionPlan.getMessagePacker();\n    const transactionPlans: SingleTransactionPlan[] = [];\n    const candidates = [...context.parentCandidates];\n    const packMessageToCapacity = (message: TransactionMessage & TransactionMessageWithFeePayer) =>\n        messagePacker.packMessageToCapacity(message, {\n            maxInstructions: context.maxInstructionsPerTransaction,\n        });\n\n    while (!messagePacker.done()) {\n        const candidate = await selectAndMutateCandidate(context, candidates, packMessageToCapacity);\n        if (!candidate) {\n            const message = await createNewMessage(context, packMessageToCapacity);\n            const newPlan: MutableSingleTransactionPlan = { kind: 'single', message, planType: 'transactionPlan' };\n            transactionPlans.push(newPlan);\n        }\n    }\n\n    if (transactionPlans.length === 1) {\n        return transactionPlans[0];\n    }\n    if (transactionPlans.length === 0) {\n        return null;\n    }\n    if (context.parent?.kind === 'parallel') {\n        return { kind: 'parallel', planType: 'transactionPlan', plans: transactionPlans };\n    }\n    return {\n        divisible: context.parent?.kind === 'sequential' ? context.parent.divisible : true,\n        kind: 'sequential',\n        planType: 'transactionPlan',\n        plans: transactionPlans,\n    };\n}\n\nfunction getSequentialCandidate(latestPlan: MutableTransactionPlan): MutableSingleTransactionPlan | null {\n    if (latestPlan.kind === 'single') {\n        return latestPlan;\n    }\n    if (latestPlan.kind === 'sequential' && latestPlan.plans.length > 0) {\n        return getSequentialCandidate(latestPlan.plans[latestPlan.plans.length - 1]);\n    }\n    return null;\n}\n\nfunction getParallelCandidates(latestPlan: TransactionPlan): MutableSingleTransactionPlan[] {\n    return flattenTransactionPlan(latestPlan);\n}\n\nasync function selectAndMutateCandidate(\n    context: Pick<TraverseContext, 'abortSignal' | 'maxInstructionsPerTransaction' | 'onTransactionMessageUpdated'>,\n    candidates: MutableSingleTransactionPlan[],\n    predicate: (\n        message: TransactionMessage & TransactionMessageWithFeePayer,\n    ) => TransactionMessage & TransactionMessageWithFeePayer,\n): Promise<MutableSingleTransactionPlan | null> {\n    for (const candidate of candidates) {\n        try {\n            const message = await getAbortablePromise(\n                Promise.resolve(\n                    context.onTransactionMessageUpdated(predicate(candidate.message), {\n                        abortSignal: context.abortSignal,\n                    }),\n                ),\n                context.abortSignal,\n            );\n            if (getTransactionMessageSize(message) <= getTransactionMessageSizeLimit(message)) {\n                assertMaxInstructionsPerTransaction(\n                    message.instructions.length,\n                    resolveMaxInstructions(context.maxInstructionsPerTransaction),\n                );\n                candidate.message = message;\n                return candidate;\n            }\n        } catch (error) {\n            if (\n                isSolanaError(error, SOLANA_ERROR__INSTRUCTION_PLANS__MAX_INSTRUCTIONS_PER_TRANSACTION_EXCEEDED) ||\n                isSolanaError(error, SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN) ||\n                isSolanaError(error, SOLANA_ERROR__TRANSACTION__TOO_MANY_ACCOUNT_ADDRESSES) ||\n                isSolanaError(error, SOLANA_ERROR__TRANSACTION__TOO_MANY_ACCOUNTS_IN_INSTRUCTION) ||\n                isSolanaError(error, SOLANA_ERROR__TRANSACTION__TOO_MANY_INSTRUCTIONS) ||\n                isSolanaError(error, SOLANA_ERROR__TRANSACTION__TOO_MANY_SIGNER_ADDRESSES)\n            ) {\n                // Try the next candidate.\n            } else {\n                throw error;\n            }\n        }\n    }\n    return null;\n}\n\nasync function createNewMessage(\n    context: Pick<\n        TraverseContext,\n        'abortSignal' | 'createTransactionMessage' | 'maxInstructionsPerTransaction' | 'onTransactionMessageUpdated'\n    >,\n    predicate: (\n        message: TransactionMessage & TransactionMessageWithFeePayer,\n    ) => TransactionMessage & TransactionMessageWithFeePayer,\n): Promise<TransactionMessage & TransactionMessageWithFeePayer> {\n    const newMessage = await getAbortablePromise(\n        Promise.resolve(context.createTransactionMessage({ abortSignal: context.abortSignal })),\n        context.abortSignal,\n    );\n    const updatedMessage = await getAbortablePromise(\n        Promise.resolve(\n            context.onTransactionMessageUpdated(predicate(newMessage), { abortSignal: context.abortSignal }),\n        ),\n        context.abortSignal,\n    );\n    const updatedMessageSize = getTransactionMessageSize(updatedMessage);\n    if (updatedMessageSize > getTransactionMessageSizeLimit(updatedMessage)) {\n        const newMessageSize = getTransactionMessageSize(newMessage);\n        throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN, {\n            numBytesRequired: updatedMessageSize - newMessageSize,\n            numFreeBytes: getTransactionMessageSizeLimit(newMessage) - newMessageSize,\n        });\n    }\n    assertMaxInstructionsPerTransaction(\n        updatedMessage.instructions.length,\n        resolveMaxInstructions(context.maxInstructionsPerTransaction),\n    );\n    return updatedMessage;\n}\n\nfunction freezeTransactionPlan(plan: MutableTransactionPlan): TransactionPlan {\n    const kind = plan.kind;\n    switch (kind) {\n        case 'single':\n            return singleTransactionPlan(plan.message);\n        case 'sequential':\n            return plan.divisible\n                ? sequentialTransactionPlan(plan.plans.map(freezeTransactionPlan))\n                : nonDivisibleSequentialTransactionPlan(plan.plans.map(freezeTransactionPlan));\n        case 'parallel':\n            return parallelTransactionPlan(plan.plans.map(freezeTransactionPlan));\n        default:\n            plan satisfies never;\n            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND, { kind });\n    }\n}\n\nfunction fitEntirePlanInsideMessage(\n    context: Pick<TraverseContext, 'maxInstructionsPerTransaction'>,\n    instructionPlan: InstructionPlan,\n    message: TransactionMessage & TransactionMessageWithFeePayer,\n): TransactionMessage & TransactionMessageWithFeePayer {\n    let newMessage: TransactionMessage & TransactionMessageWithFeePayer = message;\n\n    const kind = instructionPlan.kind;\n    switch (kind) {\n        case 'sequential':\n        case 'parallel':\n            for (const plan of instructionPlan.plans) {\n                newMessage = fitEntirePlanInsideMessage(context, plan, newMessage);\n            }\n            return newMessage;\n        case 'single':\n            newMessage = appendTransactionMessageInstructions([instructionPlan.instruction], message);\n            // eslint-disable-next-line no-case-declarations\n            const newMessageSize = getTransactionMessageSize(newMessage);\n            if (newMessageSize > getTransactionMessageSizeLimit(newMessage)) {\n                const baseMessageSize = getTransactionMessageSize(message);\n                throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN, {\n                    numBytesRequired: newMessageSize - baseMessageSize,\n                    numFreeBytes: getTransactionMessageSizeLimit(message) - baseMessageSize,\n                });\n            }\n            assertMaxInstructionsPerTransaction(\n                newMessage.instructions.length,\n                resolveMaxInstructions(context.maxInstructionsPerTransaction),\n            );\n            return newMessage;\n        case 'messagePacker':\n            // eslint-disable-next-line no-case-declarations\n            const messagePacker = instructionPlan.getMessagePacker();\n            while (!messagePacker.done()) {\n                newMessage = messagePacker.packMessageToCapacity(newMessage, {\n                    maxInstructions: context.maxInstructionsPerTransaction,\n                });\n                assertMaxInstructionsPerTransaction(\n                    newMessage.instructions.length,\n                    resolveMaxInstructions(context.maxInstructionsPerTransaction),\n                );\n            }\n            return newMessage;\n        default:\n            instructionPlan satisfies never;\n            throw new SolanaError(SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND, { kind });\n    }\n}\n"]}