@usearete/sdk 0.13.0 → 0.15.0

package/dist/index.d.ts

@@ -25,6 +25,8 @@ interface TransactionSimulationResult {
     err: unknown | null;
     logs: readonly string[] | null;
     unitsConsumed?: bigint;
+    /** Loaded account data size, when the relay reports it. */
+    loadedAccountsDataSize?: bigint;
     accounts?: readonly unknown[] | null;
 }
 interface TransactionSendOptions {
@@ -116,13 +118,127 @@ interface BuiltInstruction {
  * - `finalized`: Transaction finalized (recommended for production)
  */
 type ConfirmationLevel = 'processed' | 'confirmed' | 'finalized';
+/**
+ * Transaction version requested by the caller.
+ *
+ * Numeric versions stay JSON numbers; they are versions, not u64 quantities.
+ */
+type TransactionVersion = 'legacy' | 0 | 1;
+/**
+ * u32 resource quantity: an exact integer (`number` or `bigint`) or a decimal
+ * string. Only representations that may already have lost precision are
+ * rejected, and below 2^32 a `number` cannot.
+ */
+type ResourceUnits = number | bigint | string;
+/**
+ * u64 resource quantity: a `bigint` or a decimal string.
+ *
+ * A plain `number` is rejected: every JS number is a double, so a u64 that
+ * arrived as one may already have lost precision.
+ */
+type ResourceLamports = bigint | string;
+/**
+ * Resource budget options shared by sending and unsigned inspection.
+ *
+ * The two fee fields are mutually exclusive and version-bound:
+ * `priorityFeeLamports` is V1 only, `computeUnitPriceMicroLamports` is
+ * legacy/v0 only.
+ */
+interface TransactionResourceOptions {
+    /** Compute unit ceiling (u32). */
+    computeUnitLimit?: ResourceUnits;
+    /** Loaded account data ceiling in bytes (u32). */
+    loadedAccountsDataSizeLimit?: ResourceUnits;
+    /** Heap frame bytes (u32). */
+    heapSize?: ResourceUnits;
+    /** Total priority fee in lamports (u64). Transaction V1 only. */
+    priorityFeeLamports?: ResourceLamports;
+    /** Per-compute-unit price in micro-lamports (u64). Legacy/v0 only. */
+    computeUnitPriceMicroLamports?: ResourceLamports;
+}
+/** Canonical resource option keys, in contract order. */
+declare const TRANSACTION_RESOURCE_OPTION_KEYS: readonly ["computeUnitLimit", "loadedAccountsDataSizeLimit", "heapSize", "priorityFeeLamports", "computeUnitPriceMicroLamports"];
+type TransactionResourceOptionKey = typeof TRANSACTION_RESOURCE_OPTION_KEYS[number];
+/**
+ * Version + resource options understood by version-aware adapters.
+ *
+ * The resource budget is a nested, closed object: an unrecognized key inside
+ * `resources` is rejected, which a flat shape could not enforce against the
+ * open index signature on {@link SendOptions}.
+ */
+interface TransactionBuildOptions {
+    /** Explicit transaction version. Omitted means the adapter's default (v0). */
+    transactionVersion?: TransactionVersion;
+    /** Resource budget for this transaction. */
+    resources?: TransactionResourceOptions;
+}
+/** Adapter capability declaration consulted before a build. */
+interface TransactionBuildCapability {
+    /**
+     * Versions the adapter can build. `undefined` means unknown, never empty:
+     * ordinary operations keep working, but an explicit V1 request fails.
+     */
+    readonly supportedTransactionVersions?: readonly TransactionVersion[];
+    /**
+     * Resource options the adapter honours. `undefined` means unknown and is not
+     * policed; an empty array means the adapter honours none and every supplied
+     * resource option is rejected rather than silently dropped.
+     */
+    readonly supportedResourceOptions?: readonly TransactionResourceOptionKey[];
+}
+type TransactionOptionsErrorCode = 'unsupported_transaction_version' | 'unsupported_resource_option' | 'invalid_transaction_option';
+/** Typed rejection for malformed or unsupported build options. */
+declare class TransactionOptionsError extends Error {
+    readonly code: TransactionOptionsErrorCode;
+    readonly option?: string;
+    readonly requestedVersion?: TransactionVersion;
+    readonly supportedVersions?: readonly TransactionVersion[];
+    constructor(code: TransactionOptionsErrorCode, message: string, details?: {
+        option?: string;
+        requestedVersion?: TransactionVersion;
+        supportedVersions?: readonly TransactionVersion[];
+    });
+}
+/** Resource budget after validation: every quantity normalized to a bigint. */
+interface ResolvedTransactionResourceOptions {
+    readonly computeUnitLimit?: bigint;
+    readonly loadedAccountsDataSizeLimit?: bigint;
+    readonly heapSize?: bigint;
+    readonly priorityFeeLamports?: bigint;
+    readonly computeUnitPriceMicroLamports?: bigint;
+}
+/** Build options after validation. */
+interface ResolvedTransactionBuildOptions {
+    /** Effective version: the explicit request, or the v0 default. */
+    readonly transactionVersion: TransactionVersion;
+    readonly resources: ResolvedTransactionResourceOptions;
+}
+/**
+ * Validate build options against an adapter's declared capability and
+ * normalize every quantity to a bigint.
+ *
+ * Rejections are never silent downgrades: an explicit version the adapter does
+ * not advertise fails, and a fee field used against the wrong version fails
+ * instead of being converted.
+ */
+declare function resolveTransactionBuildOptions(options?: TransactionBuildOptions, capability?: TransactionBuildCapability): ResolvedTransactionBuildOptions;
+/**
+ * Boundary form of a resolved resource budget: flat canonical camelCase keys,
+ * every present value a decimal string, absent keys omitted.
+ *
+ * Mirrors Rust `TransactionResourceOptions::to_json()` and Python `to_wire()`.
+ * Key order is not part of the contract (Rust sorts, Python uses declaration
+ * order); the keys and their decimal-string values are. bigint stays the
+ * in-process type; `JSON.stringify` cannot emit one.
+ */
+declare function toWireResourceOptions(resources: ResolvedTransactionResourceOptions): Record<string, string>;
 /**
  * Options forwarded to the wallet adapter when sending a transaction.
  *
  * The core SDK does not interpret these; it passes them straight through to
  * the adapter, which owns all RPC semantics.
  */
-interface SendOptions {
+interface SendOptions extends TransactionBuildOptions {
     /** Confirmation level the adapter should wait for */
     confirmationLevel?: ConfirmationLevel;
     /** Skip the RPC preflight simulation */
@@ -152,7 +268,7 @@ interface SendResult {
  * Inspection must not sign or submit the transaction. Concrete adapters may
  * accept additional simulation options through this passthrough object.
  */
-interface TransactionInspectionOptions {
+interface TransactionInspectionOptions extends TransactionBuildOptions {
     [key: string]: unknown;
 }
 /**
@@ -167,6 +283,8 @@ interface TransactionInspectionResult {
     computeUnitsConsumed?: number;
     /** RPC context slot for the inspection, when available. */
     contextSlot?: number;
+    /** Loaded account data size reported by simulation, when available. */
+    loadedAccountsDataSize?: number;
     /** Raw simulation failure, if the inspected transaction would fail. */
     error?: unknown;
     /** Adapter-specific inspection fields. */
@@ -187,6 +305,13 @@ interface WalletAdapter {
     publicKey: string;
     /** Signer addresses the adapter can satisfy without per-send signers. */
     readonly signerAddresses?: readonly string[];
+    /**
+     * Transaction versions this adapter can build.
+     *
+     * Omitting the field means unknown, not unsupported: existing operations keep
+     * working, but an explicit V1 request is rejected rather than downgraded.
+     */
+    readonly supportedTransactionVersions?: readonly TransactionVersion[];
     /**
      * Compile, sign, and broadcast one or more built instructions as a single
      * transaction.
@@ -2431,5 +2556,5 @@ declare const Arete: typeof Arete$1 & {
     session: typeof createSession;
 };
 
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, 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, getOperationKind, 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, withProgramRead, 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, OperationKindBrand, 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, ProgramReadOf, 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 { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TRANSACTION_RESOURCE_OPTION_KEYS, TransactionExecutionError, TransactionOptionsError, 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, getOperationKind, 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, resolveTransactionBuildOptions, safeToRawAmount, serializeInstructionData, serializeViewKey, stackQuery, stringifyBigints, toJsonValue, toRawAmount, toWireResourceOptions, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withProgramRead, 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, OperationKindBrand, 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, ProgramReadOf, ProgramReadOverride, ProgramReadOverrides, ProgramReadRequest, ProgramReadTransport, ProgramReleaseReference, ProgramRuntimeExtensionCarrier, ProgramRuntimeExtensions, ProgramSdkDefinition, ProgramsInterface, QueriesInterface, QueryLease, QuerySnapshot, RawAccountInfo, RawInstructionsInterface, RawProgramsInterface, ReadArgumentCount, ReadArgumentCounts, ReadTransportMethod, ResolvedAccount, ResolvedAccounts, ResolvedTransactionBuildOptions, ResolvedTransactionResourceOptions, ResourceLamports, ResourceUnits, 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, TransactionBuildCapability, TransactionBuildOptions, TransactionCommitment, TransactionFailureOutcome, TransactionFailurePhase, TransactionFailureStatus, TransactionFeeResult, TransactionInspectionOptions, TransactionInspectionResult, TransactionOperation, TransactionOperationNamespace, TransactionOptions, TransactionOptionsErrorCode, TransactionOutcome, TransactionRequestContext, TransactionResourceOptionKey, TransactionResourceOptions, TransactionSendOptions, TransactionSendResult, TransactionSignatureStatus, TransactionSimulationOptions, TransactionSimulationResult, TransactionTransport, TransactionTransportErrorBody, TransactionVersion, 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

@@ -3121,6 +3121,195 @@ function createTypedViews(stack, storage, subscriptionRegistry) {
     return views;
 }
 
+/**
+ * Wallet adapter boundary for the Arete SDK.
+ *
+ * The core SDK is intentionally RPC-free: it only constructs `BuiltInstruction`
+ * objects. Everything network-related (recent blockhash, message compilation,
+ * signing, sending, and confirmation) lives behind the `WalletAdapter`
+ * boundary, implemented by adapters that wrap the Solana library of your choice
+ * (@solana/web3.js, @solana/kit, a raw Keypair signer for scripts, etc.).
+ */
+/** Canonical resource option keys, in contract order. */
+const TRANSACTION_RESOURCE_OPTION_KEYS = [
+    'computeUnitLimit',
+    'loadedAccountsDataSizeLimit',
+    'heapSize',
+    'priorityFeeLamports',
+    'computeUnitPriceMicroLamports',
+];
+/** Typed rejection for malformed or unsupported build options. */
+class TransactionOptionsError extends Error {
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'TransactionOptionsError';
+        this.code = code;
+        this.option = details.option;
+        this.requestedVersion = details.requestedVersion;
+        this.supportedVersions = details.supportedVersions;
+    }
+}
+const U32_MAX = 0xffffffffn;
+const U64_MAX = (1n << 64n) - 1n;
+const DECIMAL = /^\d+$/;
+function inRange(value, max, option) {
+    if (value > max) {
+        throw new TransactionOptionsError('invalid_transaction_option', `Transaction option '${option}' exceeds its maximum of ${max}`, { option });
+    }
+    return value;
+}
+function parseUnits(value, option) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'bigint') {
+        if (value < 0n) {
+            throw new TransactionOptionsError('invalid_transaction_option', `Transaction option '${option}' must not be negative`, { option });
+        }
+        return inRange(value, U32_MAX, option);
+    }
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new TransactionOptionsError('invalid_transaction_option', `Transaction option '${option}' must be a non-negative integer or decimal string, `
+                + `received ${value}`, { option });
+        }
+        return inRange(BigInt(value), U32_MAX, option);
+    }
+    if (typeof value === 'string' && DECIMAL.test(value)) {
+        return inRange(BigInt(value), U32_MAX, option);
+    }
+    throw new TransactionOptionsError('invalid_transaction_option', `Transaction option '${option}' must be a non-negative integer or decimal string`, { option });
+}
+function parseLamports(value, option) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'number') {
+        throw new TransactionOptionsError('invalid_transaction_option', `Transaction option '${option}' must be a bigint or decimal string, never a number: `
+            + 'every JavaScript number is a double, so a u64 passed as one may already have lost '
+            + `precision before it reached the SDK (received ${value})`, { option });
+    }
+    if (typeof value === 'bigint') {
+        if (value < 0n) {
+            throw new TransactionOptionsError('invalid_transaction_option', `Transaction option '${option}' must not be negative`, { option });
+        }
+        return inRange(value, U64_MAX, option);
+    }
+    if (typeof value === 'string' && DECIMAL.test(value)) {
+        return inRange(BigInt(value), U64_MAX, option);
+    }
+    throw new TransactionOptionsError('invalid_transaction_option', `Transaction option '${option}' must be a bigint or decimal string`, { option });
+}
+/**
+ * Merge execution defaults with per-call send options.
+ *
+ * `resources` merges key by key, so a per-call fee does not discard a
+ * configured compute budget — except for the two fee fields, which are one
+ * slot: setting either clears the other, or the merged budget would hold both
+ * and be refused as mutually exclusive. Shared by every entry point that has
+ * defaults to merge; duplicating this logic is how `session` came to disagree
+ * with `Arete.execute`.
+ */
+function mergeSendOptions(defaults, override) {
+    if (!defaults)
+        return override;
+    if (!override)
+        return defaults;
+    const inherited = { ...defaults.resources };
+    if (override.resources?.priorityFeeLamports !== undefined ||
+        override.resources?.computeUnitPriceMicroLamports !== undefined) {
+        delete inherited.priorityFeeLamports;
+        delete inherited.computeUnitPriceMicroLamports;
+    }
+    const resources = defaults.resources || override.resources
+        ? { ...inherited, ...override.resources }
+        : undefined;
+    return { ...defaults, ...override, ...(resources ? { resources } : {}) };
+}
+/**
+ * Validate build options against an adapter's declared capability and
+ * normalize every quantity to a bigint.
+ *
+ * Rejections are never silent downgrades: an explicit version the adapter does
+ * not advertise fails, and a fee field used against the wrong version fails
+ * instead of being converted.
+ */
+function resolveTransactionBuildOptions(options, capability) {
+    const requested = options?.transactionVersion;
+    if (requested !== undefined && requested !== 'legacy' && requested !== 0 && requested !== 1) {
+        throw new TransactionOptionsError('invalid_transaction_option', `Unknown transactionVersion ${JSON.stringify(requested)}: expected 'legacy', 0, or 1`, { option: 'transactionVersion' });
+    }
+    const supported = capability?.supportedTransactionVersions;
+    if (requested !== undefined) {
+        // Undeclared capability means unknown, not unsupported: old versions keep
+        // working, and only an explicit V1 request needs proof of support.
+        const unsupported = supported ? !supported.includes(requested) : requested === 1;
+        if (unsupported) {
+            throw new TransactionOptionsError('unsupported_transaction_version', `Wallet adapter does not support transaction version ${JSON.stringify(requested)}`
+                + (supported
+                    ? ` (supported: ${supported.map((version) => JSON.stringify(version)).join(', ')})`
+                    : ' (adapter declares no supported versions)'), { option: 'transactionVersion', requestedVersion: requested, supportedVersions: supported });
+        }
+    }
+    const resources = options?.resources;
+    if (resources !== undefined) {
+        if (typeof resources !== 'object' || resources === null || Array.isArray(resources)) {
+            throw new TransactionOptionsError('invalid_transaction_option', 'Transaction option \'resources\' must be an object of canonical resource options', { option: 'resources' });
+        }
+        // Closed key set: an unrecognized budget key is a rejection, never a
+        // silently ignored passthrough.
+        const unknownKey = Object.keys(resources).find((key) => !TRANSACTION_RESOURCE_OPTION_KEYS.includes(key));
+        if (unknownKey) {
+            throw new TransactionOptionsError('unsupported_resource_option', `Unknown resource option '${unknownKey}': expected one of `
+                + TRANSACTION_RESOURCE_OPTION_KEYS.join(', '), { option: unknownKey });
+        }
+    }
+    const honoured = capability?.supportedResourceOptions;
+    if (honoured) {
+        const rejected = TRANSACTION_RESOURCE_OPTION_KEYS.find((key) => resources?.[key] !== undefined && !honoured.includes(key));
+        if (rejected) {
+            throw new TransactionOptionsError('unsupported_resource_option', `Wallet adapter does not apply the '${rejected}' resource option`, { option: rejected });
+        }
+    }
+    const version = requested ?? 0;
+    if (resources?.priorityFeeLamports !== undefined
+        && resources?.computeUnitPriceMicroLamports !== undefined) {
+        throw new TransactionOptionsError('invalid_transaction_option', 'priorityFeeLamports and computeUnitPriceMicroLamports are mutually exclusive', { option: 'priorityFeeLamports', requestedVersion: version });
+    }
+    if (resources?.priorityFeeLamports !== undefined && version !== 1) {
+        throw new TransactionOptionsError('unsupported_resource_option', `priorityFeeLamports requires transaction version 1, not ${JSON.stringify(version)}`, { option: 'priorityFeeLamports', requestedVersion: version });
+    }
+    if (resources?.computeUnitPriceMicroLamports !== undefined && version === 1) {
+        throw new TransactionOptionsError('unsupported_resource_option', 'computeUnitPriceMicroLamports applies to legacy/v0 only; version 1 uses priorityFeeLamports', { option: 'computeUnitPriceMicroLamports', requestedVersion: version });
+    }
+    return {
+        transactionVersion: version,
+        resources: {
+            computeUnitLimit: parseUnits(resources?.computeUnitLimit, 'computeUnitLimit'),
+            loadedAccountsDataSizeLimit: parseUnits(resources?.loadedAccountsDataSizeLimit, 'loadedAccountsDataSizeLimit'),
+            heapSize: parseUnits(resources?.heapSize, 'heapSize'),
+            priorityFeeLamports: parseLamports(resources?.priorityFeeLamports, 'priorityFeeLamports'),
+            computeUnitPriceMicroLamports: parseLamports(resources?.computeUnitPriceMicroLamports, 'computeUnitPriceMicroLamports'),
+        },
+    };
+}
+/**
+ * Boundary form of a resolved resource budget: flat canonical camelCase keys,
+ * every present value a decimal string, absent keys omitted.
+ *
+ * Mirrors Rust `TransactionResourceOptions::to_json()` and Python `to_wire()`.
+ * Key order is not part of the contract (Rust sorts, Python uses declaration
+ * order); the keys and their decimal-string values are. bigint stays the
+ * in-process type; `JSON.stringify` cannot emit one.
+ */
+function toWireResourceOptions(resources) {
+    const wire = {};
+    for (const key of TRANSACTION_RESOURCE_OPTION_KEYS) {
+        const value = resources[key];
+        if (value !== undefined)
+            wire[key] = value.toString(10);
+    }
+    return wire;
+}
+
 /**
  * Non-enumerable brand attached by the operation and read factories so
  * tooling (e.g. the knowledge-layer extractor's runtime walk) can classify
@@ -3471,6 +3660,7 @@ function createTransactionTransport(baseUrl, authenticatedFetch) {
                 err: value.err ?? null,
                 logs: value.logs ?? null,
                 unitsConsumed: optionalBigint(value.unitsConsumed, 'unitsConsumed'),
+                loadedAccountsDataSize: optionalBigint(value.loadedAccountsDataSize, 'loadedAccountsDataSize'),
                 accounts: value.accounts,
             };
         },
@@ -6247,6 +6437,7 @@ async function inspectPreparedOperation(wallet, operation, options, context) {
     if (!wallet?.inspectTransaction) {
         throw new Error('Wallet adapter does not support unsigned transaction inspection');
     }
+    resolveTransactionBuildOptions(options, wallet);
     const transaction = operation.plan.transactions[0];
     const description = describePreparedOperation(operation);
     const inspection = context
@@ -6941,13 +7132,17 @@ let Arete$1 = class Arete {
                 cause,
             });
         }
+        const sendOptions = {
+            ...(options?.send ?? {}),
+        };
+        if (options?.signers !== undefined) {
+            sendOptions.signers = options.signers;
+        }
+        // Version/resource options are validated before anything reaches the
+        // adapter, so an unsupported request throws the typed options error rather
+        // than a wrapped execution failure.
+        resolveTransactionBuildOptions(sendOptions, wallet);
         try {
-            const sendOptions = {
-                ...(options?.send ?? {}),
-            };
-            if (options?.signers !== undefined) {
-                sendOptions.signers = options.signers;
-            }
             const result = await wallet.signAndSend(instructions, sendOptions, {
                 transactionTransport: options?.transactionTransport ?? this._transactions,
             });
@@ -6961,9 +7156,7 @@ let Arete$1 = class Arete {
         const defaults = this.executionDefaults;
         return executePreparedOperation(this, prepared, {
             wallet: options?.wallet ?? defaults?.wallet,
-            send: defaults?.send || options?.send
-                ? { ...(defaults?.send ?? {}), ...(options?.send ?? {}) }
-                : undefined,
+            send: mergeSendOptions(defaults?.send, options?.send),
             signers: options?.signers ?? defaults?.signers,
             transactionTransport: options?.transactionTransport ?? defaults?.transactionTransport,
             signerRegistry: options?.signerRegistry ?? defaults?.signerRegistry,
@@ -7277,9 +7470,7 @@ async function createSession(definition, ...args) {
             return executionHost.transaction(instructions, {
                 wallet: transactionOptions?.wallet ?? defaults?.wallet,
                 transactionTransport: transactionOptions?.transactionTransport ?? transactions,
-                send: defaults?.send || transactionOptions?.send
-                    ? { ...(defaults?.send ?? {}), ...(transactionOptions?.send ?? {}) }
-                    : undefined,
+                send: mergeSendOptions(defaults?.send, transactionOptions?.send),
                 errors: transactionOptions?.errors,
                 signers: signers.length > 0 ? signers : undefined,
             });
@@ -7290,9 +7481,7 @@ async function createSession(definition, ...args) {
             return executionHost.execute(prepared, {
                 wallet: executionOptions?.wallet ?? defaults?.wallet,
                 transactionTransport: executionOptions?.transactionTransport ?? defaults?.transactionTransport ?? transactions,
-                send: defaults?.send || executionOptions?.send
-                    ? { ...(defaults?.send ?? {}), ...(executionOptions?.send ?? {}) }
-                    : undefined,
+                send: mergeSendOptions(defaults?.send, executionOptions?.send),
                 signers: configuredSigners,
                 signerRegistry,
                 availableSignerAddresses: executionOptions?.availableSignerAddresses ?? defaults?.availableSignerAddresses,
@@ -7494,5 +7683,5 @@ function stringifyBigints(value) {
 
 const Arete = Object.assign(Arete$1, { session: createSession });
 
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, 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, getOperationKind, 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, withProgramRead, withPrograms };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TRANSACTION_RESOURCE_OPTION_KEYS, TransactionExecutionError, TransactionOptionsError, 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, getOperationKind, 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, resolveTransactionBuildOptions, safeToRawAmount, serializeInstructionData, serializeViewKey, stackQuery, stringifyBigints, toJsonValue, toRawAmount, toWireResourceOptions, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withProgramRead, withPrograms };
 //# sourceMappingURL=index.esm.js.map