@usearete/sdk 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -241,6 +241,8 @@ interface AccountMeta {
     isWritable: boolean;
     /** Category of this account */
     category: AccountCategory;
+    /** How a signer account is satisfied. Unspecified signers are caller-provided. */
+    signerKind?: 'wallet' | 'provided' | 'generated';
     /** Fixed address for "known" accounts (e.g., "11111111111111111111111111111111") */
     knownAddress?: string;
     /** PDA configuration for "pda" accounts */
@@ -254,9 +256,18 @@ interface AccountMeta {
 interface PdaConfig {
     /** Program ID that owns this PDA (defaults to instruction's programId) */
     programId?: string;
+    /** Dynamic program selector for cross-program PDA derivation. */
+    program?: PdaProgram;
     /** Seed definitions for PDA derivation */
     seeds: PdaSeed[];
 }
+type PdaProgram = {
+    type: 'accountRef';
+    accountName: string;
+} | {
+    type: 'argRef';
+    argName: string;
+};
 /**
  * Single seed in a PDA derivation.
  */
@@ -304,7 +315,7 @@ interface AccountResolutionOptions {
     accounts?: Record<string, string>;
     /** Helper-only PDA seed inputs */
     resolve?: Record<string, unknown>;
-    /** Wallet adapter for signer accounts */
+    /** Wallet adapter for accounts explicitly marked with signerKind: 'wallet' */
     wallet?: WalletAdapter;
     /** Program ID for PDA derivation (required if any PDAs exist) */
     programId?: string;
@@ -610,7 +621,7 @@ declare function createInstructionHandler<TParams = Record<string, unknown>, TEr
  * Options for building an instruction (no network access).
  */
 interface BuildOptions {
-    /** Wallet, used only for `publicKey` to resolve signer accounts. */
+    /** Wallet, used only for accounts explicitly marked with signerKind: 'wallet'. */
     wallet?: WalletAdapter;
     /** Explicit account-address overrides, including signer slots when needed. */
     accounts?: Record<string, string>;
@@ -685,9 +696,17 @@ interface PdaDeriveContext {
     resolve?: Record<string, unknown>;
     programId?: string;
 }
+type PdaProgramSelector = string | {
+    type: 'accountRef';
+    accountName: string;
+} | {
+    type: 'argRef';
+    argName: string;
+};
 interface PdaFactory {
     readonly seeds: readonly SeedDef[];
-    readonly programId: string;
+    readonly programId?: string;
+    readonly programSelector: PdaProgramSelector;
     program(programId: string): PdaFactory;
     derive(context: PdaDeriveContext): Promise<string>;
     deriveSync(context: PdaDeriveContext): string;
@@ -696,7 +715,7 @@ declare function literal(value: string): SeedDef;
 declare function account(name: string): SeedDef;
 declare function arg(name: string, type?: string): SeedDef;
 declare function bytes(value: Uint8Array): SeedDef;
-declare function pda(programId: string, ...seeds: SeedDef[]): PdaFactory;
+declare function pda(programSelector: PdaProgramSelector, ...seeds: SeedDef[]): PdaFactory;
 type ProgramPdas<T extends Record<string, PdaFactory>> = T;
 declare function createProgramPdas<T extends Record<string, PdaFactory>>(pdas: T): ProgramPdas<T>;
 
@@ -1563,6 +1582,8 @@ interface PreparedTransactionBody {
     readonly name: string;
     readonly instructions: NonEmptyReadonlyArray<BuiltInstruction>;
     readonly requiredSignerAddresses: readonly string[];
+    /** Signer material created while preparing this transaction. */
+    readonly signers?: readonly unknown[];
     readonly errors: readonly ErrorMetadata[];
 }
 interface OperationPlan<TArtifacts = void> {
@@ -1591,6 +1612,7 @@ interface CreatePreparedInstructionInput<TArtifacts> {
     instruction: BuiltInstruction;
     artifacts: TArtifacts;
     requiredSignerAddresses?: readonly string[];
+    signers?: readonly unknown[];
     errors?: readonly ErrorMetadata[];
 }
 type PreparedTransactionInstruction = BuiltInstruction | PreparedInstruction<unknown>;
@@ -1599,6 +1621,7 @@ interface CreatePreparedTransactionBaseInput<TArtifacts> {
     name: string;
     artifacts: TArtifacts;
     requiredSignerAddresses?: readonly string[];
+    signers?: readonly unknown[];
     errors?: readonly ErrorMetadata[];
 }
 type CreatePreparedTransactionInput<TArtifacts> = CreatePreparedTransactionBaseInput<TArtifacts> & ({
@@ -1617,6 +1640,7 @@ declare function createPreparedTransactionBody(input: {
     name: string;
     instructions: readonly BuiltInstruction[];
     requiredSignerAddresses?: readonly string[];
+    signers?: readonly unknown[];
     errors?: readonly ErrorMetadata[];
 }): PreparedTransactionBody;
 declare function createPreparedInstruction<TArtifacts>(input: CreatePreparedInstructionInput<TArtifacts>): PreparedInstruction<TArtifacts>;
@@ -2365,4 +2389,4 @@ declare const Arete: typeof Arete$1 & {
 };
 
 export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TransactionExecutionError, TransactionTransportError, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, canonicalQueryKey, chainAccountLoader, createChainClient, createEntityStream, createHostedSolanaGatewayTransports, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, createSubscriptionId, createTransactionTransport, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, defineProgramExtensions, defineStackExtensions, deriveAssociatedTokenAccount, deriveHttpEndpoint, findProgramAddress as derivePda, describePreparedOperation, encodeBase58, executeInstruction, executePreparedOperation, extendProgram, extendPrograms, extendStack, findProgramAddress, findProgramAddressSync, flowOperation, formatPreparedOperation, formatProgramError, formatRawToUi, getMintDecimals, getProgramRuntimeExtensions, getStackRuntimeExtensions, getTransactionFailureOutcome, inspectPreparedOperation, instructionOperation, isEntityFrame, isErrorFrame, isHostedAreteEndpoint, isSnapshotFrame, isSubscribedFrame, isUnsubscribedFrame, isValidFrame, literal, normalizeSubscription, normalizeSubscriptionQuery, normalizeSubscriptionRequest, normalizeTransactionError, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, safeToRawAmount, serializeInstructionData, serializeViewKey, stackQuery, stringifyBigints, toJsonValue, toRawAmount, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withPrograms };
-export type { AccountCategory, AccountLoader, AccountMeta, AccountResolutionOptions, AccountResolutionResult, AmountInput, AnyOperation, AreteConfig, AreteOptions, AreteOptionsWithStorage, ArgSchema, ArgType, AuthConfig, AuthTokenRequest, AuthTokenResult, AuthTokenTarget, BuildOptions, BuiltAccountMeta, BuiltInstruction, ChainClient, ChainClock, ChainFailedTransactionOutcome, CompositionSessionOptions, ConfirmationLevel, ConfirmedTransactionOutcome, ConnectOptions, ConnectedArete, ConnectedStackClient, ConnectionState, ConnectionStateCallback, ContextSlotOptions, CreatePreparedFlowInput, CreatePreparedInstructionInput, CreatePreparedTransactionInput, DefaultViewKey, EntityFrame, ErrorFrame, ErrorMetadata, ExecuteOptions, ExecutionResult, ExtendedProgramDefinition, ExtendedStackDefinition, FlowOperation, FlowOperationNamespace, FlowOperationReceipt, Frame, FrameMode, FrameOp, FrameProcessorConfig, FrameValidationDiagnostic, HostedSolanaGatewayBindings, HostedSolanaGatewayCapabilityBinding, HostedSolanaGatewayTransportOptions, HostedSolanaGatewayTransports, HttpAuthMetadata, InstructionExecutor, InstructionHandler, InstructionHandlerConfig, InstructionOperation, InstructionOperationNamespace, JsonObject, JsonPrimitive, JsonValue, LatestBlockhashResult, MergeProgramMaps, MintAccountInfo, NativeBalanceInfo, NonEmptyReadonlyArray, NotSubmittedTransactionOutcome, OperationCallbackPhase, OperationExecutionEvent, OperationExecutionHost, OperationExecutionOptions, OperationExecutionSuccessEvent, OperationInspection, OperationInspectionOptions, OperationKind, OperationNamespace, OperationPlan, OperationReceiptFor, OperationTransactionReceipt, PdaConfig, PdaDeriveContext, PdaFactory, PdaSeed, PreparedFlow, PreparedInstruction, PreparedOperation, PreparedOperationDescription, PreparedTransaction, PreparedTransactionBody, PreparedTransactionInstruction, PreparedTransactionOperation, ProgramAccountBatchItem, ProgramAccountBatchResult, ProgramAccountReadDefinition, ProgramError, ProgramExtensionInput, ProgramInterface, ProgramOperationContext, ProgramOperations, ProgramOperationsOf, ProgramPdas, ProgramQueryDefinition, ProgramReadBinding, ProgramReadBindingAuthTarget, ProgramReadDescriptor, ProgramReadDescriptors, ProgramReadOverride, ProgramReadOverrides, ProgramReadRequest, ProgramReadTransport, ProgramReleaseReference, ProgramRuntimeExtensionCarrier, ProgramRuntimeExtensions, ProgramSdkDefinition, ProgramsInterface, QueriesInterface, QueryLease, QuerySnapshot, RawAccountInfo, RawInstructionsInterface, RawProgramsInterface, ReadArgumentCount, ReadArgumentCounts, ReadTransportMethod, ResolvedAccount, ResolvedAccounts, RichUpdate, RichUpdateCallback, Schema, SchemaResult, SeedDef, SendOptions, SendResult, Session, SessionDefinition, SessionMemberOptions, SessionOptions, SignerRegistry, SingleTransactionOperationReceipt, SnapshotEntity, SnapshotFrame, SocketIssue, SocketIssueCallback, SolanaGatewayAuthMetadata, SolanaGatewayAuthScope, SolanaGatewayBindingAuthTarget, SortConfig, SortOrder, StackConnectedExtensions, StackDefinition, StackEndpoints, StackExtensionClient, StackExtensionInput, StackQueryDefinition, StackRuntimeExtensionCarrier, StackRuntimeExtensions, StackWithAttachedPrograms, StorageAdapter, StorageAdapterConfig, StringifiedBigints, SubmittedUnknownTransactionOutcome, SubscribeCallback, SubscribedFrame, Subscription, SubscriptionIdentity, SubscriptionOptions, SubscriptionQuery, SubscriptionRequest, SubscriptionSnapshotOptions, TokenAccountInfo, TokenBalanceInfo, TokenBalanceInput, TransactionCommitment, TransactionFailureOutcome, TransactionFailurePhase, TransactionFailureStatus, TransactionFeeResult, TransactionInspectionOptions, TransactionInspectionResult, TransactionOperation, TransactionOperationNamespace, TransactionOptions, TransactionOutcome, TransactionRequestContext, TransactionSendOptions, TransactionSendResult, TransactionSignatureStatus, TransactionSimulationOptions, TransactionSimulationResult, TransactionTransport, TransactionTransportErrorBody, TypedAccountReader, TypedInstruction, TypedListView, TypedQueryExecutor, TypedStateView, TypedViewGroup, TypedViews, UnsubscribeFn, UnsubscribedFrame, Update, UpdateCallback, ViewDef, ViewGroup, ViewKeyFields, ViewKeyValue, ViewSortConfig, WaitForProcessedSlotOptions, WalletAdapter, WalletConnectOptions, WalletExecutionContext, WalletState, WatchOptions, WebSocketFactoryInit };
+export type { AccountCategory, AccountLoader, AccountMeta, AccountResolutionOptions, AccountResolutionResult, AmountInput, AnyOperation, AreteConfig, AreteOptions, AreteOptionsWithStorage, ArgSchema, ArgType, AuthConfig, AuthTokenRequest, AuthTokenResult, AuthTokenTarget, BuildOptions, BuiltAccountMeta, BuiltInstruction, ChainClient, ChainClock, ChainFailedTransactionOutcome, CompositionSessionOptions, ConfirmationLevel, ConfirmedTransactionOutcome, ConnectOptions, ConnectedArete, ConnectedStackClient, ConnectionState, ConnectionStateCallback, ContextSlotOptions, CreatePreparedFlowInput, CreatePreparedInstructionInput, CreatePreparedTransactionInput, DefaultViewKey, EntityFrame, ErrorFrame, ErrorMetadata, ExecuteOptions, ExecutionResult, ExtendedProgramDefinition, ExtendedStackDefinition, FlowOperation, FlowOperationNamespace, FlowOperationReceipt, Frame, FrameMode, FrameOp, FrameProcessorConfig, FrameValidationDiagnostic, HostedSolanaGatewayBindings, HostedSolanaGatewayCapabilityBinding, HostedSolanaGatewayTransportOptions, HostedSolanaGatewayTransports, HttpAuthMetadata, InstructionExecutor, InstructionHandler, InstructionHandlerConfig, InstructionOperation, InstructionOperationNamespace, JsonObject, JsonPrimitive, JsonValue, LatestBlockhashResult, MergeProgramMaps, MintAccountInfo, NativeBalanceInfo, NonEmptyReadonlyArray, NotSubmittedTransactionOutcome, OperationCallbackPhase, OperationExecutionEvent, OperationExecutionHost, OperationExecutionOptions, OperationExecutionSuccessEvent, OperationInspection, OperationInspectionOptions, OperationKind, OperationNamespace, OperationPlan, OperationReceiptFor, OperationTransactionReceipt, PdaConfig, PdaDeriveContext, PdaFactory, PdaProgram, PdaProgramSelector, PdaSeed, PreparedFlow, PreparedInstruction, PreparedOperation, PreparedOperationDescription, PreparedTransaction, PreparedTransactionBody, PreparedTransactionInstruction, PreparedTransactionOperation, ProgramAccountBatchItem, ProgramAccountBatchResult, ProgramAccountReadDefinition, ProgramError, ProgramExtensionInput, ProgramInterface, ProgramOperationContext, ProgramOperations, ProgramOperationsOf, ProgramPdas, ProgramQueryDefinition, ProgramReadBinding, ProgramReadBindingAuthTarget, ProgramReadDescriptor, ProgramReadDescriptors, ProgramReadOverride, ProgramReadOverrides, ProgramReadRequest, ProgramReadTransport, ProgramReleaseReference, ProgramRuntimeExtensionCarrier, ProgramRuntimeExtensions, ProgramSdkDefinition, ProgramsInterface, QueriesInterface, QueryLease, QuerySnapshot, RawAccountInfo, RawInstructionsInterface, RawProgramsInterface, ReadArgumentCount, ReadArgumentCounts, ReadTransportMethod, ResolvedAccount, ResolvedAccounts, RichUpdate, RichUpdateCallback, Schema, SchemaResult, SeedDef, SendOptions, SendResult, Session, SessionDefinition, SessionMemberOptions, SessionOptions, SignerRegistry, SingleTransactionOperationReceipt, SnapshotEntity, SnapshotFrame, SocketIssue, SocketIssueCallback, SolanaGatewayAuthMetadata, SolanaGatewayAuthScope, SolanaGatewayBindingAuthTarget, SortConfig, SortOrder, StackConnectedExtensions, StackDefinition, StackEndpoints, StackExtensionClient, StackExtensionInput, StackQueryDefinition, StackRuntimeExtensionCarrier, StackRuntimeExtensions, StackWithAttachedPrograms, StorageAdapter, StorageAdapterConfig, StringifiedBigints, SubmittedUnknownTransactionOutcome, SubscribeCallback, SubscribedFrame, Subscription, SubscriptionIdentity, SubscriptionOptions, SubscriptionQuery, SubscriptionRequest, SubscriptionSnapshotOptions, TokenAccountInfo, TokenBalanceInfo, TokenBalanceInput, TransactionCommitment, TransactionFailureOutcome, TransactionFailurePhase, TransactionFailureStatus, TransactionFeeResult, TransactionInspectionOptions, TransactionInspectionResult, TransactionOperation, TransactionOperationNamespace, TransactionOptions, TransactionOutcome, TransactionRequestContext, TransactionSendOptions, TransactionSendResult, TransactionSignatureStatus, TransactionSimulationOptions, TransactionSimulationResult, TransactionTransport, TransactionTransportErrorBody, TypedAccountReader, TypedInstruction, TypedListView, TypedQueryExecutor, TypedStateView, TypedViewGroup, TypedViews, UnsubscribeFn, UnsubscribedFrame, Update, UpdateCallback, ViewDef, ViewGroup, ViewKeyFields, ViewKeyValue, ViewSortConfig, WaitForProcessedSlotOptions, WalletAdapter, WalletConnectOptions, WalletExecutionContext, WalletState, WatchOptions, WebSocketFactoryInit };

package/dist/index.esm.js

@@ -4250,6 +4250,9 @@ function sortAccountsByDependency(accountMetas) {
                     deps.add(seed.accountName);
                 }
             }
+            if (meta.pdaConfig.program?.type === 'accountRef') {
+                deps.add(meta.pdaConfig.program.accountName);
+            }
         }
         pdaDeps.set(meta.name, deps);
     }
@@ -4343,9 +4346,19 @@ function resolveAccounts(accountMetas, args, options) {
     };
 }
 function resolveSingleAccount(meta, args, options, resolvedMap) {
+    const explicit = options.accounts?.[meta.name];
+    if (explicit !== undefined) {
+        validateAccountAddress(meta.name, explicit);
+        return {
+            name: meta.name,
+            address: explicit,
+            isSigner: meta.isSigner,
+            isWritable: meta.isWritable,
+        };
+    }
     switch (meta.category) {
         case 'signer':
-            return resolveSignerAccount(meta, options.accounts, options.wallet);
+            return resolveSignerAccount(meta, options.wallet);
         case 'known':
             return resolveKnownAccount(meta);
         case 'pda':
@@ -4356,8 +4369,22 @@ function resolveSingleAccount(meta, args, options, resolvedMap) {
             return null;
     }
 }
-function resolveSignerAccount(meta, accounts, wallet) {
-    const address = accounts?.[meta.name] ?? wallet?.publicKey;
+function validateAccountAddress(name, address) {
+    let decoded;
+    try {
+        decoded = decodeBase58(address);
+    }
+    catch {
+        throw new Error(`Invalid account override for "${name}": expected a base58 public key`);
+    }
+    if (decoded.length !== 32) {
+        throw new Error(`Invalid account override for "${name}": expected a 32-byte public key, got ${decoded.length} bytes`);
+    }
+}
+function resolveSignerAccount(meta, wallet) {
+    // An IDL only tells us that an account signs; it cannot prove that the
+    // account is the connected wallet. Wallet fallback is therefore opt-in.
+    const address = meta.signerKind === 'wallet' ? wallet?.publicKey : undefined;
     if (!address) {
         return null;
     }
@@ -4384,7 +4411,7 @@ function resolvePdaAccount(meta, args, resolvedMap, programId, resolve) {
         return null;
     }
     // Determine which program to derive against
-    const pdaProgramId = meta.pdaConfig.programId || programId;
+    const pdaProgramId = resolvePdaProgram(meta.pdaConfig, args, resolvedMap, programId, resolve);
     if (!pdaProgramId) {
         throw new Error('Cannot derive PDA for "' + meta.name + '": no programId specified. ' +
             'Either set pdaConfig.programId or pass programId in options.');
@@ -4431,6 +4458,24 @@ function resolvePdaAccount(meta, args, resolvedMap, programId, resolve) {
         isWritable: meta.isWritable,
     };
 }
+function resolvePdaProgram(config, args, resolvedMap, defaultProgramId, resolve) {
+    if (config.program?.type === 'accountRef') {
+        const account = resolvedMap[config.program.accountName];
+        if (!account) {
+            throw new Error('PDA program references unresolved account: ' + config.program.accountName);
+        }
+        return account.address;
+    }
+    if (config.program?.type === 'argRef') {
+        const value = getValueByPath(args, config.program.argName)
+            ?? getValueByPath(resolve, config.program.argName);
+        if (typeof value !== 'string' || value.length === 0) {
+            throw new Error('PDA program references missing or non-address argument: ' + config.program.argName);
+        }
+        return value;
+    }
+    return config.programId || defaultProgramId;
+}
 function resolveUserProvidedAccount(meta, accounts) {
     const address = accounts?.[meta.name];
     if (!address) {
@@ -5054,10 +5099,10 @@ function createInstructionHandler(config) {
  *
  * Keys matching a declared argument name are args; keys matching a declared
  * account name (with a string value) are account address overrides. This
- * applies to signer slots too, allowing explicit signer addresses to override
- * the wallet fallback. Anything else throws — a typo'd key silently dropped
+ * applies to signer slots too, allowing explicit signer addresses to fill or
+ * override those slots. Anything else throws — a typo'd key silently dropped
  * here would otherwise change the built instruction. `options.accounts` on
- * {@link BuildOptions} remains an unvalidated escape hatch for advanced callers.
+ * {@link BuildOptions} is the explicit override map and wins over merged params.
  */
 function splitParams(handler, params) {
     const argNameSet = new Set(handler.argNames);
@@ -5206,22 +5251,39 @@ function resolveSeeds(seeds, context) {
         }
     });
 }
-function pda(programId, ...seeds) {
+function resolveProgram(selector, context) {
+    if (typeof selector === 'string')
+        return context.programId ?? selector;
+    if (selector.type === 'accountRef') {
+        const address = context.accounts?.[selector.accountName];
+        if (!address)
+            throw new Error(`Missing account for PDA program: ${selector.accountName}`);
+        return address;
+    }
+    const value = getValueByPath(context.args, selector.argName)
+        ?? getValueByPath(context.resolve, selector.argName);
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`Missing argument for PDA program: ${selector.argName}`);
+    }
+    return value;
+}
+function pda(programSelector, ...seeds) {
     return {
         seeds,
-        programId,
+        programId: typeof programSelector === 'string' ? programSelector : undefined,
+        programSelector,
         program(newProgramId) {
             return pda(newProgramId, ...seeds);
         },
         async derive(context) {
             const resolvedSeeds = resolveSeeds(this.seeds, context);
-            const pid = context.programId ?? this.programId;
+            const pid = resolveProgram(this.programSelector, context);
             const [address] = await findProgramAddress(resolvedSeeds, pid);
             return address;
         },
         deriveSync(context) {
             const resolvedSeeds = resolveSeeds(this.seeds, context);
-            const pid = context.programId ?? this.programId;
+            const pid = resolveProgram(this.programSelector, context);
             const [address] = findProgramAddressSync(resolvedSeeds, pid);
             return address;
         },
@@ -5384,6 +5446,7 @@ function createPreparedTransactionBody(input) {
         name: input.name,
         instructions,
         requiredSignerAddresses: dedupe(input.requiredSignerAddresses ?? inferSignerAddresses(instructions)),
+        signers: [...new Set(input.signers ?? [])],
         errors: [...(input.errors ?? [])],
     };
 }
@@ -5399,6 +5462,7 @@ function createPreparedInstruction(input) {
         name: input.name,
         instructions: [input.instruction],
         requiredSignerAddresses: input.requiredSignerAddresses,
+        signers: input.signers,
         errors: input.errors,
     });
     return {
@@ -5429,6 +5493,10 @@ function createPreparedTransaction(input) {
         instructions: transactionParts.flatMap((part) => part.instructions),
         requiredSignerAddresses: input.requiredSignerAddresses
             ?? transactionParts.flatMap((part) => part.requiredSignerAddresses),
+        signers: [
+            ...transactionParts.flatMap((part) => part.signers),
+            ...(input.signers ?? []),
+        ],
         errors: input.errors ?? transactionParts.flatMap((part) => part.errors),
     });
     return {
@@ -5505,8 +5573,8 @@ function inferSignerAddress(value) {
     const publicKey = candidate.publicKey;
     return typeof publicKey?.toBase58 === 'function' ? publicKey.toBase58() : null;
 }
-function validateTransactionSigners(transaction, host, options) {
-    const signerAddresses = (options.signers ?? []).map(inferSignerAddress);
+function validateTransactionSigners(transaction, host, options, signers) {
+    const signerAddresses = signers.map(inferSignerAddress);
     const available = new Set(options.availableSignerAddresses ?? []);
     for (const address of options.signerRegistry?.addresses() ?? []) {
         available.add(address);
@@ -5592,15 +5660,16 @@ async function runOperationCallback(input, callbackErrors, onCallbackError) {
 async function executePreparedOperation(host, operation, options = {}) {
     const receipts = [];
     const callbackErrors = [];
-    const signers = [
-        ...new Set([
-            ...(options.signerRegistry?.values() ?? []),
-            ...(options.signers ?? []),
-        ]),
-    ];
     for (const [transactionIndex, transaction] of operation.plan.transactions.entries()) {
+        const signers = [
+            ...new Set([
+                ...(transaction.signers ?? []),
+                ...(options.signerRegistry?.values() ?? []),
+                ...(options.signers ?? []),
+            ]),
+        ];
         try {
-            validateTransactionSigners(transaction, host, options);
+            validateTransactionSigners(transaction, host, options, signers);
         }
         catch (cause) {
             throw new OperationExecutionError({