npm - @solana/instruction-plans - Versions diffs - 6.3.0 → 6.3.1 - Mend

@solana/instruction-plans 6.3.0 → 6.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/index.browser.cjs +13 -2
package/dist/index.browser.cjs.map +1 -1
package/dist/index.browser.mjs +13 -2
package/dist/index.browser.mjs.map +1 -1
package/dist/index.native.mjs +13 -2
package/dist/index.native.mjs.map +1 -1
package/dist/index.node.cjs +13 -2
package/dist/index.node.cjs.map +1 -1
package/dist/index.node.mjs +13 -2
package/dist/index.node.mjs.map +1 -1
package/dist/types/transaction-plan-errors.d.ts.map +1 -1
package/package.json +7 -7

package/dist/index.browser.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../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__UNEXPECTED_INSTRUCTION_PLAN","SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE","getTransactionMessageSize","appendTransactionMessageInstruction","TRANSACTION_SIZE_LIMIT","SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN","SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND","SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN","getSignatureFromTransaction","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_SEND_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","SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND","SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED","getAbortablePromise","traverse","SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN","traverseSequential","traverseParallel","traverseSingle","candidate","message","appendTransactionMessageInstructions"],"mappings":"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","file":"index.browser.cjs","sourcesContent":["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, TRANSACTION_SIZE_LIMIT } from '@solana/transactions';\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. It returns the updated transaction message with the packed instructions\n * or throws an error if the current transaction 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 /\n packMessageToCapacity: (\n transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,\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: (message: TransactionMessage & TransactionMessageWithFeePayer) => {\n if (offset >= totalBytes) {\n throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE);\n }\n\n const messageSizeWithBaseInstruction = getTransactionMessageSize(\n appendTransactionMessageInstruction(getInstruction(offset, 0), message),\n );\n const freeSpace =\n TRANSACTION_SIZE_LIMIT -\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: TRANSACTION_SIZE_LIMIT - 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: (message: TransactionMessage & TransactionMessageWithFeePayer) => {\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\n for (let index = instructionIndex; index < instructions.length; index++) {\n message = appendTransactionMessageInstruction(instructions[index], message);\n const messageSize = getTransactionMessageSize(message);\n\n if (messageSize > TRANSACTION_SIZE_LIMIT) {\n if (index === instructionIndex) {\n throw new SolanaError(\n SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN,\n {\n numBytesRequired: messageSize - originalMessageSize,\n numFreeBytes: TRANSACTION_SIZE_LIMIT - originalMessageSize,\n },\n );\n }\n instructionIndex = index;\n return message;\n }\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 { getSignatureFromTransaction, 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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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\n * `transaction` are provided separately by {@link BaseTransactionPlanResultContext}\n * and {@link SuccessfulBaseTransactionPlanResultContext}, which are intersected\n * with this type in each {@link SingleTransactionPlanResult} variant.\n \n @see {@link SingleTransactionPlanResult}\n * @see {@link SuccessfulSingleTransactionPlanResult}\n * @see {@link FailedSingleTransactionPlanResult}\n * @see {@link CanceledSingleTransactionPlanResult}\n /\nexport type TransactionPlanResultContext = { [key: number \| string \| symbol]: unknown };\n\n/\n The base context fields that are common to all {@link SingleTransactionPlanResult} variants.\n \n This type provides optional fields for the transaction message, signature, and\n * full transaction object. These fields may or may not be populated depending on\n * how far execution progressed before the result was produced.\n \n @see {@link FailedSingleTransactionPlanResult}\n * @see {@link CanceledSingleTransactionPlanResult}\n * @see {@link SuccessfulBaseTransactionPlanResultContext}\n /\nexport interface BaseTransactionPlanResultContext {\n message?: TransactionMessage & TransactionMessageWithFeePayer;\n signature?: Signature;\n transaction?: Transaction;\n}\n\n/\n The base context fields for a {@link SuccessfulSingleTransactionPlanResult}.\n \n This extends the base context by requiring a {@link Signature}, since a\n * successful transaction always produces one. The transaction message and full\n * transaction object remain optional.\n \n @see {@link SuccessfulSingleTransactionPlanResult}\n * @see {@link BaseTransactionPlanResultContext}\n /\nexport interface SuccessfulBaseTransactionPlanResultContext extends BaseTransactionPlanResultContext {\n signature: Signature;\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 successfulSingleTransactionPlanResultFromTransaction},\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 transaction and context.\n * ```ts\n * const result = successfulSingleTransactionPlanResultFromTransaction(\n * transactionMessage,\n * transaction\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 successfulSingleTransactionPlanResultFromTransaction}\n * @see {@link failedSingleTransactionPlanResult}\n * @see {@link canceledSingleTransactionPlanResult}\n /\nexport type SingleTransactionPlanResult<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\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 containing\n * the fields from {@link SuccessfulBaseTransactionPlanResultContext} — namely\n * a required transaction {@link Signature}, and optionally the\n * {@link TransactionMessage} and the full {@link Transaction} object.\n \n You may use the {@link successfulSingleTransactionPlanResultFromTransaction} or\n * {@link successfulSingleTransactionPlanResult} helpers 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.\n * ```ts\n * const result = successfulSingleTransactionPlanResultFromTransaction(\n * transactionMessage,\n * transaction,\n * );\n * result satisfies SuccessfulSingleTransactionPlanResult;\n * result.context.signature; // The transaction signature.\n * ```\n \n @see {@link successfulSingleTransactionPlanResultFromTransaction}\n * @see {@link successfulSingleTransactionPlanResult}\n * @see {@link isSuccessfulSingleTransactionPlanResult}\n * @see {@link assertIsSuccessfulSingleTransactionPlanResult}\n /\nexport type SuccessfulSingleTransactionPlanResult<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n> = {\n context: Readonly<SuccessfulBaseTransactionPlanResultContext & 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 containing the fields from\n * {@link BaseTransactionPlanResultContext} — namely optional\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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n> = {\n context: Readonly<BaseTransactionPlanResultContext & 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 containing the fields from\n * {@link BaseTransactionPlanResultContext} — namely optional\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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n> = {\n context: Readonly<BaseTransactionPlanResultContext & 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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 transaction.\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, the executed transaction, and an optional context object.\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 transaction - The successfully executed transaction\n * @param context - Optional context object to be included with the result\n \n @example\n * ```ts\n * const result = successfulSingleTransactionPlanResultFromTransaction(\n * transactionMessage,\n * transaction\n * );\n * result satisfies SingleTransactionPlanResult;\n * ```\n \n @see {@link SingleTransactionPlanResult}\n /\nexport function successfulSingleTransactionPlanResultFromTransaction<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n plannedMessage: TTransactionMessage,\n transaction: Transaction,\n context?: Omit<BaseTransactionPlanResultContext, 'signature' \| 'transaction'> & TContext,\n): SuccessfulSingleTransactionPlanResult<TContext, TTransactionMessage> {\n const signature = getSignatureFromTransaction(transaction);\n return Object.freeze({\n context: Object.freeze({ ...((context ?? {}) as TContext), signature, transaction }),\n kind: 'single',\n planType: 'transactionPlanResult',\n plannedMessage,\n status: 'successful',\n });\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 that must contain at least a {@link Signature}.\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 - Context object to be included with the result, must include a `signature` property\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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n plannedMessage: TTransactionMessage,\n context: SuccessfulBaseTransactionPlanResultContext & 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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n plannedMessage: TTransactionMessage,\n error: Error,\n context?: TContext,\n): FailedSingleTransactionPlanResult<TContext, TTransactionMessage> {\n return Object.freeze({\n context: Object.freeze({ ...((context ?? {}) as 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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n plannedMessage: TTransactionMessage,\n context?: TContext,\n): CanceledSingleTransactionPlanResult<TContext, TTransactionMessage> {\n return Object.freeze({\n context: Object.freeze({ ...((context ?? {}) as 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 = successfulSingleTransactionPlanResultFromTransaction(message, transaction);\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 = TransactionPlanResultContext,\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 = successfulSingleTransactionPlanResultFromTransaction(message, transaction);\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 = TransactionPlanResultContext,\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 = successfulSingleTransactionPlanResultFromTransaction(message, transaction);\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 = TransactionPlanResultContext,\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 = successfulSingleTransactionPlanResultFromTransaction(message, transaction);\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\n * successfulSingleTransactionPlanResultFromTransaction(messageB, transactionB),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\n * successfulSingleTransactionPlanResultFromTransaction(messageB, transactionB),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\n * successfulSingleTransactionPlanResultFromTransaction(messageB, transactionB),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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__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} 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 @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 /\nexport function createFailedToSendTransactionError(\n result: CanceledSingleTransactionPlanResult \| FailedSingleTransactionPlanResult,\n abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION> {\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 = getFailedIndicator(!!preflightData, result.context.signature);\n causeMessage = `${indicator}: ${(cause as Error).message}`;\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 new SolanaError(SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION, context);\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 @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 /\nexport function createFailedToSendTransactionsError(\n result: TransactionPlanResult,\n abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS> {\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 = getFailedIndicator(!!preflightData, flattenedResults[index].context.signature);\n return `\\n[Tx #${index + 1}${indicator}] ${error.message}`;\n });\n causeMessages = `.${failureLines.join('')}`;\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 new SolanaError(SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS, 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 @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 result: TransactionPlanResult,\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(result: TransactionPlanResult): 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 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 type { Signature } from '@solana/keys';\nimport { getAbortablePromise } from '@solana/promises';\nimport type { TransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\nimport { getSignatureFromTransaction, type Transaction } from '@solana/transactions';\n\nimport type {\n ParallelTransactionPlan,\n SequentialTransactionPlan,\n SingleTransactionPlan,\n TransactionPlan,\n} from './transaction-plan';\nimport { createFailedToExecuteTransactionPlanError } from './transaction-plan-errors';\nimport {\n BaseTransactionPlanResultContext,\n canceledSingleTransactionPlanResult,\n failedSingleTransactionPlanResult,\n parallelTransactionPlanResult,\n sequentialTransactionPlanResult,\n SingleTransactionPlanResult,\n successfulSingleTransactionPlanResult,\n successfulSingleTransactionPlanResultFromTransaction,\n type TransactionPlanResult,\n type TransactionPlanResultContext,\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 @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<TContext extends TransactionPlanResultContext = TransactionPlanResultContext> = (\n transactionPlan: TransactionPlan,\n config?: { abortSignal?: AbortSignal },\n) => Promise<TransactionPlanResult<TContext>>;\n\ntype ExecuteTransactionMessage<TContext extends TransactionPlanResultContext> = (\n context: BaseTransactionPlanResultContext & TContext,\n transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,\n config?: { abortSignal?: AbortSignal },\n) => Promise<Signature \| Transaction>;\n\n/\n Configuration object for creating a new transaction plan executor.\n \n @see {@link createTransactionPlanExecutor}\n /\nexport type TransactionPlanExecutorConfig<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n> = {\n /* Called whenever a transaction message must be sent to the blockchain. /\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, or any custom properties). This context is included\n * in the resulting {@link SingleTransactionPlanResult} regardless of the outcome. This\n * means that if an error is thrown at any point in the callback, any attributes already\n * saved to the context will still be available in the plan result, which can be useful\n * for debugging failures or building recovery plans. The callback must return either a\n * {@link Signature} or a full {@link Transaction} object.\n \n - If that function is successful, the executor will return a successful `TransactionPlanResult`\n * for that message. The returned signature or transaction is stored in the context automatically.\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 * await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n * return transaction;\n * }\n * });\n * ```\n \n @see {@link TransactionPlanExecutorConfig}\n /\nexport function createTransactionPlanExecutor<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\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(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\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 const context = {} as BaseTransactionPlanResultContext & TContext;\n if (traverseConfig.canceled) {\n return canceledSingleTransactionPlanResult(transactionPlan.message, context);\n }\n\n try {\n const result = await getAbortablePromise(\n traverseConfig.executeTransactionMessage(context, transactionPlan.message, {\n abortSignal: traverseConfig.abortSignal,\n }),\n traverseConfig.abortSignal,\n );\n return typeof result === 'string'\n ? successfulSingleTransactionPlanResult(transactionPlan.message, { ...context, signature: result })\n : successfulSingleTransactionPlanResultFromTransaction(transactionPlan.message, result, context);\n } catch (error) {\n traverseConfig.canceled = true;\n const contextWithSignature =\n 'transaction' in context && typeof context.transaction === 'object' && context.signature == null\n ? { ...context, signature: getSignatureFromTransaction(context.transaction) }\n : context;\n return failedSingleTransactionPlanResult(transactionPlan.message, error as Error, contextWithSignature);\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 @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 promise: Promise<SingleTransactionPlanResult>,\n): Promise<SingleTransactionPlanResult>;\nexport async function passthroughFailedTransactionPlanExecution(\n promise: Promise<TransactionPlanResult>,\n): Promise<TransactionPlanResult>;\nexport async function passthroughFailedTransactionPlanExecution(\n promise: Promise<TransactionPlanResult>,\n): Promise<TransactionPlanResult> {\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;\n }\n throw error;\n }\n}\n","import {\n isSolanaError,\n SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN,\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 SolanaError,\n} from '@solana/errors';\nimport { getAbortablePromise } from '@solana/promises';\nimport {\n appendTransactionMessageInstructions,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/transaction-messages';\nimport { getTransactionMessageSize, TRANSACTION_SIZE_LIMIT } from '@solana/transactions';\n\nimport {\n InstructionPlan,\n MessagePackerInstructionPlan,\n ParallelInstructionPlan,\n SequentialInstructionPlan,\n SingleInstructionPlan,\n} from './instruction-plan';\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 that can include an `AbortSignal` to cancel the planning process.\n \n @see {@link InstructionPlan}\n * @see {@link TransactionPlan}\n /\nexport type TransactionPlanner = (\n instructionPlan: InstructionPlan,\n config?: { abortSignal?: AbortSignal },\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 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 @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 } = {}): Promise<TransactionPlan> => {\n const plan = await traverse(instructionPlan, {\n abortSignal,\n createTransactionMessage: config.createTransactionMessage,\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 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(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\n while (!messagePacker.done()) {\n const candidate = await selectAndMutateCandidate(context, candidates, messagePacker.packMessageToCapacity);\n if (!candidate) {\n const message = await createNewMessage(context, messagePacker.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' \| '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) <= TRANSACTION_SIZE_LIMIT) {\n candidate.message = message;\n return candidate;\n }\n } catch (error) {\n if (isSolanaError(error, SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN)) {\n // Try the next candidate.\n } else {\n throw error;\n }\n }\n }\n return null;\n}\n\nasync function createNewMessage(\n context: Pick<TraverseContext, 'abortSignal' \| 'createTransactionMessage' \| 'onTransactionMessageUpdated'>,\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 > TRANSACTION_SIZE_LIMIT) {\n const newMessageSize = getTransactionMessageSize(newMessage);\n throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN, {\n numBytesRequired: updatedMessageSize - newMessageSize,\n numFreeBytes: TRANSACTION_SIZE_LIMIT - newMessageSize,\n });\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 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(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 > TRANSACTION_SIZE_LIMIT) {\n const baseMessageSize = getTransactionMessageSize(message);\n throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN, {\n numBytesRequired: newMessageSize - baseMessageSize,\n numFreeBytes: TRANSACTION_SIZE_LIMIT - baseMessageSize,\n });\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 }\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"]}
1	+ {"version":3,"sources":["../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__UNEXPECTED_INSTRUCTION_PLAN","SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE","getTransactionMessageSize","appendTransactionMessageInstruction","TRANSACTION_SIZE_LIMIT","SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN","SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND","SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN","getSignatureFromTransaction","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_SEND_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","SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND","SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED","getAbortablePromise","traverse","SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN","traverseSequential","traverseParallel","traverseSingle","candidate","message","appendTransactionMessageInstructions"],"mappings":"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","file":"index.browser.cjs","sourcesContent":["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, TRANSACTION_SIZE_LIMIT } from '@solana/transactions';\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. It returns the updated transaction message with the packed instructions\n * or throws an error if the current transaction 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 /\n packMessageToCapacity: (\n transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,\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: (message: TransactionMessage & TransactionMessageWithFeePayer) => {\n if (offset >= totalBytes) {\n throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE);\n }\n\n const messageSizeWithBaseInstruction = getTransactionMessageSize(\n appendTransactionMessageInstruction(getInstruction(offset, 0), message),\n );\n const freeSpace =\n TRANSACTION_SIZE_LIMIT -\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: TRANSACTION_SIZE_LIMIT - 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: (message: TransactionMessage & TransactionMessageWithFeePayer) => {\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\n for (let index = instructionIndex; index < instructions.length; index++) {\n message = appendTransactionMessageInstruction(instructions[index], message);\n const messageSize = getTransactionMessageSize(message);\n\n if (messageSize > TRANSACTION_SIZE_LIMIT) {\n if (index === instructionIndex) {\n throw new SolanaError(\n SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN,\n {\n numBytesRequired: messageSize - originalMessageSize,\n numFreeBytes: TRANSACTION_SIZE_LIMIT - originalMessageSize,\n },\n );\n }\n instructionIndex = index;\n return message;\n }\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 { getSignatureFromTransaction, 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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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\n * `transaction` are provided separately by {@link BaseTransactionPlanResultContext}\n * and {@link SuccessfulBaseTransactionPlanResultContext}, which are intersected\n * with this type in each {@link SingleTransactionPlanResult} variant.\n \n @see {@link SingleTransactionPlanResult}\n * @see {@link SuccessfulSingleTransactionPlanResult}\n * @see {@link FailedSingleTransactionPlanResult}\n * @see {@link CanceledSingleTransactionPlanResult}\n /\nexport type TransactionPlanResultContext = { [key: number \| string \| symbol]: unknown };\n\n/\n The base context fields that are common to all {@link SingleTransactionPlanResult} variants.\n \n This type provides optional fields for the transaction message, signature, and\n * full transaction object. These fields may or may not be populated depending on\n * how far execution progressed before the result was produced.\n \n @see {@link FailedSingleTransactionPlanResult}\n * @see {@link CanceledSingleTransactionPlanResult}\n * @see {@link SuccessfulBaseTransactionPlanResultContext}\n /\nexport interface BaseTransactionPlanResultContext {\n message?: TransactionMessage & TransactionMessageWithFeePayer;\n signature?: Signature;\n transaction?: Transaction;\n}\n\n/\n The base context fields for a {@link SuccessfulSingleTransactionPlanResult}.\n \n This extends the base context by requiring a {@link Signature}, since a\n * successful transaction always produces one. The transaction message and full\n * transaction object remain optional.\n \n @see {@link SuccessfulSingleTransactionPlanResult}\n * @see {@link BaseTransactionPlanResultContext}\n /\nexport interface SuccessfulBaseTransactionPlanResultContext extends BaseTransactionPlanResultContext {\n signature: Signature;\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 successfulSingleTransactionPlanResultFromTransaction},\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 transaction and context.\n * ```ts\n * const result = successfulSingleTransactionPlanResultFromTransaction(\n * transactionMessage,\n * transaction\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 successfulSingleTransactionPlanResultFromTransaction}\n * @see {@link failedSingleTransactionPlanResult}\n * @see {@link canceledSingleTransactionPlanResult}\n /\nexport type SingleTransactionPlanResult<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\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 containing\n * the fields from {@link SuccessfulBaseTransactionPlanResultContext} — namely\n * a required transaction {@link Signature}, and optionally the\n * {@link TransactionMessage} and the full {@link Transaction} object.\n \n You may use the {@link successfulSingleTransactionPlanResultFromTransaction} or\n * {@link successfulSingleTransactionPlanResult} helpers 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.\n * ```ts\n * const result = successfulSingleTransactionPlanResultFromTransaction(\n * transactionMessage,\n * transaction,\n * );\n * result satisfies SuccessfulSingleTransactionPlanResult;\n * result.context.signature; // The transaction signature.\n * ```\n \n @see {@link successfulSingleTransactionPlanResultFromTransaction}\n * @see {@link successfulSingleTransactionPlanResult}\n * @see {@link isSuccessfulSingleTransactionPlanResult}\n * @see {@link assertIsSuccessfulSingleTransactionPlanResult}\n /\nexport type SuccessfulSingleTransactionPlanResult<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n> = {\n context: Readonly<SuccessfulBaseTransactionPlanResultContext & 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 containing the fields from\n * {@link BaseTransactionPlanResultContext} — namely optional\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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n> = {\n context: Readonly<BaseTransactionPlanResultContext & 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 containing the fields from\n * {@link BaseTransactionPlanResultContext} — namely optional\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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n> = {\n context: Readonly<BaseTransactionPlanResultContext & 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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 transaction.\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, the executed transaction, and an optional context object.\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 transaction - The successfully executed transaction\n * @param context - Optional context object to be included with the result\n \n @example\n * ```ts\n * const result = successfulSingleTransactionPlanResultFromTransaction(\n * transactionMessage,\n * transaction\n * );\n * result satisfies SingleTransactionPlanResult;\n * ```\n \n @see {@link SingleTransactionPlanResult}\n /\nexport function successfulSingleTransactionPlanResultFromTransaction<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n plannedMessage: TTransactionMessage,\n transaction: Transaction,\n context?: Omit<BaseTransactionPlanResultContext, 'signature' \| 'transaction'> & TContext,\n): SuccessfulSingleTransactionPlanResult<TContext, TTransactionMessage> {\n const signature = getSignatureFromTransaction(transaction);\n return Object.freeze({\n context: Object.freeze({ ...((context ?? {}) as TContext), signature, transaction }),\n kind: 'single',\n planType: 'transactionPlanResult',\n plannedMessage,\n status: 'successful',\n });\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 that must contain at least a {@link Signature}.\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 - Context object to be included with the result, must include a `signature` property\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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n plannedMessage: TTransactionMessage,\n context: SuccessfulBaseTransactionPlanResultContext & 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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n plannedMessage: TTransactionMessage,\n error: Error,\n context?: TContext,\n): FailedSingleTransactionPlanResult<TContext, TTransactionMessage> {\n return Object.freeze({\n context: Object.freeze({ ...((context ?? {}) as 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 = TransactionPlanResultContext,\n TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer = TransactionMessage &\n TransactionMessageWithFeePayer,\n>(\n plannedMessage: TTransactionMessage,\n context?: TContext,\n): CanceledSingleTransactionPlanResult<TContext, TTransactionMessage> {\n return Object.freeze({\n context: Object.freeze({ ...((context ?? {}) as 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 = successfulSingleTransactionPlanResultFromTransaction(message, transaction);\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 = TransactionPlanResultContext,\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 = successfulSingleTransactionPlanResultFromTransaction(message, transaction);\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 = TransactionPlanResultContext,\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 = successfulSingleTransactionPlanResultFromTransaction(message, transaction);\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 = TransactionPlanResultContext,\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 = successfulSingleTransactionPlanResultFromTransaction(message, transaction);\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\n * successfulSingleTransactionPlanResultFromTransaction(messageB, transactionB),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\n * successfulSingleTransactionPlanResultFromTransaction(messageB, transactionB),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\n * successfulSingleTransactionPlanResultFromTransaction(messageB, transactionB),\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 = TransactionPlanResultContext,\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 * successfulSingleTransactionPlanResultFromTransaction(messageA, transactionA),\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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 = TransactionPlanResultContext,\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__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} 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 @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 /\nexport function createFailedToSendTransactionError(\n result: CanceledSingleTransactionPlanResult \| FailedSingleTransactionPlanResult,\n abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION> {\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 = getFailedIndicator(!!preflightData, result.context.signature);\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 new SolanaError(SOLANA_ERROR__FAILED_TO_SEND_TRANSACTION, context);\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 @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 /\nexport function createFailedToSendTransactionsError(\n result: TransactionPlanResult,\n abortReason?: unknown,\n): SolanaError<typeof SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS> {\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 = getFailedIndicator(!!preflightData, flattenedResults[index].context.signature);\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}`;\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 new SolanaError(SOLANA_ERROR__FAILED_TO_SEND_TRANSACTIONS, 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 @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 result: TransactionPlanResult,\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(result: TransactionPlanResult): 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}`).join('\\n')}`;\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 type { Signature } from '@solana/keys';\nimport { getAbortablePromise } from '@solana/promises';\nimport type { TransactionMessage, TransactionMessageWithFeePayer } from '@solana/transaction-messages';\nimport { getSignatureFromTransaction, type Transaction } from '@solana/transactions';\n\nimport type {\n ParallelTransactionPlan,\n SequentialTransactionPlan,\n SingleTransactionPlan,\n TransactionPlan,\n} from './transaction-plan';\nimport { createFailedToExecuteTransactionPlanError } from './transaction-plan-errors';\nimport {\n BaseTransactionPlanResultContext,\n canceledSingleTransactionPlanResult,\n failedSingleTransactionPlanResult,\n parallelTransactionPlanResult,\n sequentialTransactionPlanResult,\n SingleTransactionPlanResult,\n successfulSingleTransactionPlanResult,\n successfulSingleTransactionPlanResultFromTransaction,\n type TransactionPlanResult,\n type TransactionPlanResultContext,\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 @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<TContext extends TransactionPlanResultContext = TransactionPlanResultContext> = (\n transactionPlan: TransactionPlan,\n config?: { abortSignal?: AbortSignal },\n) => Promise<TransactionPlanResult<TContext>>;\n\ntype ExecuteTransactionMessage<TContext extends TransactionPlanResultContext> = (\n context: BaseTransactionPlanResultContext & TContext,\n transactionMessage: TransactionMessage & TransactionMessageWithFeePayer,\n config?: { abortSignal?: AbortSignal },\n) => Promise<Signature \| Transaction>;\n\n/\n Configuration object for creating a new transaction plan executor.\n \n @see {@link createTransactionPlanExecutor}\n /\nexport type TransactionPlanExecutorConfig<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\n> = {\n /* Called whenever a transaction message must be sent to the blockchain. /\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, or any custom properties). This context is included\n * in the resulting {@link SingleTransactionPlanResult} regardless of the outcome. This\n * means that if an error is thrown at any point in the callback, any attributes already\n * saved to the context will still be available in the plan result, which can be useful\n * for debugging failures or building recovery plans. The callback must return either a\n * {@link Signature} or a full {@link Transaction} object.\n \n - If that function is successful, the executor will return a successful `TransactionPlanResult`\n * for that message. The returned signature or transaction is stored in the context automatically.\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 * await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });\n * return transaction;\n * }\n * });\n * ```\n \n @see {@link TransactionPlanExecutorConfig}\n /\nexport function createTransactionPlanExecutor<\n TContext extends TransactionPlanResultContext = TransactionPlanResultContext,\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(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\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 const context = {} as BaseTransactionPlanResultContext & TContext;\n if (traverseConfig.canceled) {\n return canceledSingleTransactionPlanResult(transactionPlan.message, context);\n }\n\n try {\n const result = await getAbortablePromise(\n traverseConfig.executeTransactionMessage(context, transactionPlan.message, {\n abortSignal: traverseConfig.abortSignal,\n }),\n traverseConfig.abortSignal,\n );\n return typeof result === 'string'\n ? successfulSingleTransactionPlanResult(transactionPlan.message, { ...context, signature: result })\n : successfulSingleTransactionPlanResultFromTransaction(transactionPlan.message, result, context);\n } catch (error) {\n traverseConfig.canceled = true;\n const contextWithSignature =\n 'transaction' in context && typeof context.transaction === 'object' && context.signature == null\n ? { ...context, signature: getSignatureFromTransaction(context.transaction) }\n : context;\n return failedSingleTransactionPlanResult(transactionPlan.message, error as Error, contextWithSignature);\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 @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 promise: Promise<SingleTransactionPlanResult>,\n): Promise<SingleTransactionPlanResult>;\nexport async function passthroughFailedTransactionPlanExecution(\n promise: Promise<TransactionPlanResult>,\n): Promise<TransactionPlanResult>;\nexport async function passthroughFailedTransactionPlanExecution(\n promise: Promise<TransactionPlanResult>,\n): Promise<TransactionPlanResult> {\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;\n }\n throw error;\n }\n}\n","import {\n isSolanaError,\n SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN,\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 SolanaError,\n} from '@solana/errors';\nimport { getAbortablePromise } from '@solana/promises';\nimport {\n appendTransactionMessageInstructions,\n TransactionMessage,\n TransactionMessageWithFeePayer,\n} from '@solana/transaction-messages';\nimport { getTransactionMessageSize, TRANSACTION_SIZE_LIMIT } from '@solana/transactions';\n\nimport {\n InstructionPlan,\n MessagePackerInstructionPlan,\n ParallelInstructionPlan,\n SequentialInstructionPlan,\n SingleInstructionPlan,\n} from './instruction-plan';\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 that can include an `AbortSignal` to cancel the planning process.\n \n @see {@link InstructionPlan}\n * @see {@link TransactionPlan}\n /\nexport type TransactionPlanner = (\n instructionPlan: InstructionPlan,\n config?: { abortSignal?: AbortSignal },\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 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 @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 } = {}): Promise<TransactionPlan> => {\n const plan = await traverse(instructionPlan, {\n abortSignal,\n createTransactionMessage: config.createTransactionMessage,\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 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(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\n while (!messagePacker.done()) {\n const candidate = await selectAndMutateCandidate(context, candidates, messagePacker.packMessageToCapacity);\n if (!candidate) {\n const message = await createNewMessage(context, messagePacker.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' \| '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) <= TRANSACTION_SIZE_LIMIT) {\n candidate.message = message;\n return candidate;\n }\n } catch (error) {\n if (isSolanaError(error, SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN)) {\n // Try the next candidate.\n } else {\n throw error;\n }\n }\n }\n return null;\n}\n\nasync function createNewMessage(\n context: Pick<TraverseContext, 'abortSignal' \| 'createTransactionMessage' \| 'onTransactionMessageUpdated'>,\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 > TRANSACTION_SIZE_LIMIT) {\n const newMessageSize = getTransactionMessageSize(newMessage);\n throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN, {\n numBytesRequired: updatedMessageSize - newMessageSize,\n numFreeBytes: TRANSACTION_SIZE_LIMIT - newMessageSize,\n });\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 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(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 > TRANSACTION_SIZE_LIMIT) {\n const baseMessageSize = getTransactionMessageSize(message);\n throw new SolanaError(SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN, {\n numBytesRequired: newMessageSize - baseMessageSize,\n numFreeBytes: TRANSACTION_SIZE_LIMIT - baseMessageSize,\n });\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 }\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"]}