{"version":3,"sources":["../src/request-transformer-bigint-downcast-internal.ts","../src/tree-traversal.ts","../src/request-transformer-bigint-downcast.ts","../src/request-transformer-default-commitment-internal.ts","../src/request-transformer-default-commitment.ts","../src/request-transformer-integer-overflow-internal.ts","../src/request-transformer-integer-overflow.ts","../src/request-transformer-options-object-position-config.ts","../src/request-transformer.ts","../src/response-transformer-bigint-upcast-internal.ts","../src/response-transformer-bigint-upcast.ts","../src/response-transformer-result.ts","../src/response-transformer-allowed-numeric-values.ts","../src/response-transformer-throw-solana-error.ts","../src/response-transformer.ts"],"names":["pipe","getSolanaErrorFromJsonRpcError"],"mappings":"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","file":"index.browser.cjs","sourcesContent":["export function downcastNodeToNumberIfBigint(value: bigint): number;\nexport function downcastNodeToNumberIfBigint(value: T): T;\nexport function downcastNodeToNumberIfBigint(value: unknown): unknown {\n return typeof value === 'bigint'\n ? // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana\n // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely\n // downcasting `bigints` to `numbers`.\n Number(value)\n : value;\n}\n","import { RpcRequest, RpcRequestTransformer, RpcResponseTransformer } from '@solana/rpc-spec-types';\n\nexport type KeyPathWildcard = { readonly ['__keyPathWildcard:@solana/kit']: unique symbol };\nexport type KeyPath = ReadonlyArray;\n\nexport const KEYPATH_WILDCARD = {} as KeyPathWildcard;\n\ntype NodeVisitor = (value: unknown, state: TState) => unknown;\nexport type TraversalState = Readonly<{\n keyPath: KeyPath;\n}>;\n\nfunction getTreeWalker(visitors: NodeVisitor[]) {\n return function traverse(node: unknown, state: TState): unknown {\n if (Array.isArray(node)) {\n return node.map((element, ii) => {\n const nextState = {\n ...state,\n keyPath: [...state.keyPath, ii],\n };\n return traverse(element, nextState);\n });\n } else if (typeof node === 'object' && node !== null) {\n const out: Record = {};\n for (const propName in node) {\n if (!Object.prototype.hasOwnProperty.call(node, propName)) {\n continue;\n }\n const nextState = {\n ...state,\n keyPath: [...state.keyPath, propName],\n };\n out[propName] = traverse(node[propName as keyof typeof node], nextState);\n }\n return out;\n } else {\n return visitors.reduce((acc, visitNode) => visitNode(acc, state), node);\n }\n };\n}\n\n/**\n * Creates a transformer that traverses the request parameters and executes the provided visitors at\n * each node. A custom initial state can be provided but must at least provide `{ keyPath: [] }`.\n *\n * @example\n * ```ts\n * import { getTreeWalkerRequestTransformer } from '@solana/rpc-transformers';\n *\n * const requestTransformer = getTreeWalkerRequestTransformer(\n * [\n * // Replaces foo.bar with \"baz\".\n * (node, state) => (state.keyPath === ['foo', 'bar'] ? 'baz' : node),\n * // Increments all numbers by 1.\n * node => (typeof node === number ? node + 1 : node),\n * ],\n * { keyPath: [] },\n * );\n * ```\n */\nexport function getTreeWalkerRequestTransformer(\n visitors: NodeVisitor[],\n initialState: TState,\n): RpcRequestTransformer {\n return (request: RpcRequest): RpcRequest => {\n const traverse = getTreeWalker(visitors);\n return Object.freeze({\n ...request,\n params: traverse(request.params, initialState),\n });\n };\n}\n\nexport function getTreeWalkerResponseTransformer(\n visitors: NodeVisitor[],\n initialState: TState,\n): RpcResponseTransformer {\n return json => getTreeWalker(visitors)(json, initialState);\n}\n","import { downcastNodeToNumberIfBigint } from './request-transformer-bigint-downcast-internal';\nimport { getTreeWalkerRequestTransformer } from './tree-traversal';\n\n/**\n * Creates a transformer that downcasts all `BigInt` values to `Number`.\n *\n * @example\n * ```ts\n * import { getBigIntDowncastRequestTransformer } from '@solana/rpc-transformers';\n *\n * const requestTransformer = getBigIntDowncastRequestTransformer();\n * ```\n *\n */\nexport function getBigIntDowncastRequestTransformer() {\n return getTreeWalkerRequestTransformer([downcastNodeToNumberIfBigint], { keyPath: [] });\n}\n","import { Commitment } from '@solana/rpc-types';\n\nexport function applyDefaultCommitment({\n commitmentPropertyName,\n params,\n optionsObjectPositionInParams,\n overrideCommitment,\n}: Readonly<{\n commitmentPropertyName: string;\n optionsObjectPositionInParams: number;\n overrideCommitment?: Commitment;\n params: unknown[];\n}>) {\n const paramInTargetPosition = params[optionsObjectPositionInParams];\n if (\n // There's no config.\n paramInTargetPosition === undefined ||\n // There is a config object.\n (paramInTargetPosition && typeof paramInTargetPosition === 'object' && !Array.isArray(paramInTargetPosition))\n ) {\n if (\n // The config object already has a commitment set.\n paramInTargetPosition &&\n commitmentPropertyName in paramInTargetPosition\n ) {\n if (\n !paramInTargetPosition[commitmentPropertyName as keyof typeof paramInTargetPosition] ||\n paramInTargetPosition[commitmentPropertyName as keyof typeof paramInTargetPosition] === 'finalized'\n ) {\n // Delete the commitment property; `finalized` is already the server default.\n const nextParams = [...params];\n const {\n [commitmentPropertyName as keyof typeof paramInTargetPosition]: _, // eslint-disable-line @typescript-eslint/no-unused-vars\n ...rest\n } = paramInTargetPosition;\n if (Object.keys(rest).length > 0) {\n nextParams[optionsObjectPositionInParams] = rest;\n } else {\n if (optionsObjectPositionInParams === nextParams.length - 1) {\n nextParams.length--;\n } else {\n nextParams[optionsObjectPositionInParams] = undefined;\n }\n }\n return nextParams;\n }\n } else if (overrideCommitment !== 'finalized') {\n // Apply the default commitment.\n const nextParams = [...params];\n nextParams[optionsObjectPositionInParams] = {\n ...paramInTargetPosition,\n [commitmentPropertyName]: overrideCommitment,\n };\n return nextParams;\n }\n }\n return params;\n}\n","import type { RpcRequest, RpcRequestTransformer } from '@solana/rpc-spec-types';\nimport type { Commitment } from '@solana/rpc-types';\n\nimport { applyDefaultCommitment } from './request-transformer-default-commitment-internal';\n\n/**\n * Creates a transformer that adds the provided default commitment to the configuration object of the request when applicable.\n *\n * @param config\n *\n * @example\n * ```ts\n * import { getDefaultCommitmentRequestTransformer, OPTIONS_OBJECT_POSITION_BY_METHOD } from '@solana/rpc-transformers';\n *\n * const requestTransformer = getDefaultCommitmentRequestTransformer({\n * defaultCommitment: 'confirmed',\n * optionsObjectPositionByMethod: OPTIONS_OBJECT_POSITION_BY_METHOD,\n * });\n */\nexport function getDefaultCommitmentRequestTransformer({\n defaultCommitment,\n optionsObjectPositionByMethod,\n}: Readonly<{\n defaultCommitment?: Commitment;\n optionsObjectPositionByMethod: Record;\n}>): RpcRequestTransformer {\n return (request: RpcRequest): RpcRequest => {\n const { params, methodName } = request;\n\n // We only apply default commitment to array parameters.\n if (!Array.isArray(params)) {\n return request;\n }\n\n // Find the position of the options object in the parameters and abort if not found.\n const optionsObjectPositionInParams = optionsObjectPositionByMethod[methodName];\n if (optionsObjectPositionInParams == null) {\n return request;\n }\n\n return Object.freeze({\n methodName,\n params: applyDefaultCommitment({\n commitmentPropertyName: methodName === 'sendTransaction' ? 'preflightCommitment' : 'commitment',\n optionsObjectPositionInParams,\n overrideCommitment: defaultCommitment,\n params,\n }),\n });\n };\n}\n","import { KeyPath, TraversalState } from './tree-traversal';\n\nexport function getIntegerOverflowNodeVisitor(onIntegerOverflow: (keyPath: KeyPath, value: bigint) => void) {\n return (value: T, { keyPath }: TraversalState): T => {\n if (typeof value === 'bigint') {\n if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {\n onIntegerOverflow(keyPath as (number | string)[], value);\n }\n }\n return value;\n };\n}\n","import { RpcRequest } from '@solana/rpc-spec-types';\n\nimport { getIntegerOverflowNodeVisitor } from './request-transformer-integer-overflow-internal';\nimport { getTreeWalkerRequestTransformer, KeyPath } from './tree-traversal';\n\nexport type IntegerOverflowHandler = (request: RpcRequest, keyPath: KeyPath, value: bigint) => void;\n\n/**\n * Creates a transformer that traverses the request parameters and executes the provided handler\n * when an integer overflow is detected.\n *\n * @example\n * ```ts\n * import { getIntegerOverflowRequestTransformer } from '@solana/rpc-transformers';\n *\n * const requestTransformer = getIntegerOverflowRequestTransformer((request, keyPath, value) => {\n * throw new Error(`Integer overflow at ${keyPath.join('.')}: ${value}`);\n * });\n * ```\n */\nexport function getIntegerOverflowRequestTransformer(onIntegerOverflow: IntegerOverflowHandler) {\n return (request: RpcRequest): RpcRequest => {\n const transformer = getTreeWalkerRequestTransformer(\n [getIntegerOverflowNodeVisitor((...args) => onIntegerOverflow(request, ...args))],\n { keyPath: [] },\n );\n return transformer(request);\n };\n}\n","export const OPTIONS_OBJECT_POSITION_BY_METHOD: Record = {\n accountNotifications: 1,\n blockNotifications: 1,\n getAccountInfo: 1,\n getBalance: 1,\n getBlock: 1,\n getBlockHeight: 0,\n getBlockProduction: 0,\n getBlocks: 2,\n getBlocksWithLimit: 2,\n getEpochInfo: 0,\n getFeeForMessage: 1,\n getInflationGovernor: 0,\n getInflationReward: 1,\n getLargestAccounts: 0,\n getLatestBlockhash: 0,\n getLeaderSchedule: 1,\n getMinimumBalanceForRentExemption: 1,\n getMultipleAccounts: 1,\n getProgramAccounts: 1,\n getSignaturesForAddress: 1,\n getSlot: 0,\n getSlotLeader: 0,\n getStakeMinimumDelegation: 0,\n getSupply: 0,\n getTokenAccountBalance: 1,\n getTokenAccountsByDelegate: 2,\n getTokenAccountsByOwner: 2,\n getTokenLargestAccounts: 1,\n getTokenSupply: 1,\n getTransaction: 1,\n getTransactionCount: 0,\n getVoteAccounts: 0,\n isBlockhashValid: 1,\n logsNotifications: 1,\n programNotifications: 1,\n requestAirdrop: 2,\n sendTransaction: 1,\n signatureNotifications: 1,\n simulateTransaction: 1,\n};\n","import { pipe } from '@solana/functional';\nimport { RpcRequest, RpcRequestTransformer } from '@solana/rpc-spec-types';\nimport { Commitment } from '@solana/rpc-types';\n\nimport { getBigIntDowncastRequestTransformer } from './request-transformer-bigint-downcast';\nimport { getDefaultCommitmentRequestTransformer } from './request-transformer-default-commitment';\nimport { getIntegerOverflowRequestTransformer, IntegerOverflowHandler } from './request-transformer-integer-overflow';\nimport { OPTIONS_OBJECT_POSITION_BY_METHOD } from './request-transformer-options-object-position-config';\n\nexport type RequestTransformerConfig = Readonly<{\n /**\n * An optional {@link Commitment} value to use as the default when none is supplied by the\n * caller.\n */\n defaultCommitment?: Commitment;\n /**\n * An optional function that will be called whenever a `bigint` input exceeds that which can be\n * expressed using JavaScript numbers.\n *\n * This is used in the default {@link SolanaRpcSubscriptionsApi} to throw an exception rather\n * than to allow truncated values to propagate through a program.\n */\n onIntegerOverflow?: IntegerOverflowHandler;\n}>;\n\n/**\n * Returns the default request transformer for the Solana RPC API.\n *\n * Under the hood, this function composes multiple\n * {@link RpcRequestTransformer | RpcRequestTransformers} together such as the\n * {@link getDefaultCommitmentTransformer}, the {@link getIntegerOverflowRequestTransformer} and the\n * {@link getBigIntDowncastRequestTransformer}.\n *\n * @example\n * ```ts\n * import { getDefaultRequestTransformerForSolanaRpc } from '@solana/rpc-transformers';\n *\n * const requestTransformer = getDefaultRequestTransformerForSolanaRpc({\n * defaultCommitment: 'confirmed',\n * onIntegerOverflow: (request, keyPath, value) => {\n * throw new Error(`Integer overflow at ${keyPath.join('.')}: ${value}`);\n * },\n * });\n * ```\n */\nexport function getDefaultRequestTransformerForSolanaRpc(config?: RequestTransformerConfig): RpcRequestTransformer {\n const handleIntegerOverflow = config?.onIntegerOverflow;\n return (request: RpcRequest): RpcRequest => {\n return pipe(\n request,\n handleIntegerOverflow ? getIntegerOverflowRequestTransformer(handleIntegerOverflow) : r => r,\n getBigIntDowncastRequestTransformer(),\n getDefaultCommitmentRequestTransformer({\n defaultCommitment: config?.defaultCommitment,\n optionsObjectPositionByMethod: OPTIONS_OBJECT_POSITION_BY_METHOD,\n }),\n );\n };\n}\n","import { KeyPath, KEYPATH_WILDCARD, TraversalState } from './tree-traversal';\n\nexport function getBigIntUpcastVisitor(allowedNumericKeyPaths: readonly KeyPath[]) {\n return function upcastNodeToBigIntIfNumber(value: unknown, { keyPath }: TraversalState) {\n const isInteger = (typeof value === 'number' && Number.isInteger(value)) || typeof value === 'bigint';\n if (!isInteger) return value;\n if (keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths)) {\n return Number(value);\n } else {\n return BigInt(value);\n }\n };\n}\n\nfunction keyPathIsAllowedToBeNumeric(keyPath: KeyPath, allowedNumericKeyPaths: readonly KeyPath[]) {\n return allowedNumericKeyPaths.some(prohibitedKeyPath => {\n if (prohibitedKeyPath.length !== keyPath.length) {\n return false;\n }\n for (let ii = keyPath.length - 1; ii >= 0; ii--) {\n const keyPathPart = keyPath[ii];\n const prohibitedKeyPathPart = prohibitedKeyPath[ii];\n if (\n prohibitedKeyPathPart !== keyPathPart &&\n (prohibitedKeyPathPart !== KEYPATH_WILDCARD || typeof keyPathPart !== 'number')\n ) {\n return false;\n }\n }\n return true;\n });\n}\n","import { getBigIntUpcastVisitor } from './response-transformer-bigint-upcast-internal';\nimport { getTreeWalkerResponseTransformer, KeyPath } from './tree-traversal';\n\n/**\n * Returns a transformer that upcasts all `Number` values to `BigInts` unless they match within the\n * provided {@link KeyPath | KeyPaths}. In other words, the provided {@link KeyPath | KeyPaths} will\n * remain as `Number` values, any other numeric value will be upcasted to a `BigInt`.\n *\n * Note that you can use {@link KEYPATH_WILDCARD} to match any key within a {@link KeyPath}.\n *\n * @example\n * ```ts\n * import { getBigIntUpcastResponseTransformer } from '@solana/rpc-transformers';\n *\n * const responseTransformer = getBigIntUpcastResponseTransformer([\n * ['index'],\n * ['instructions', KEYPATH_WILDCARD, 'accounts', KEYPATH_WILDCARD],\n * ['instructions', KEYPATH_WILDCARD, 'programIdIndex'],\n * ['instructions', KEYPATH_WILDCARD, 'stackHeight'],\n * ]);\n * ```\n */\nexport function getBigIntUpcastResponseTransformer(allowedNumericKeyPaths: readonly KeyPath[]) {\n return getTreeWalkerResponseTransformer([getBigIntUpcastVisitor(allowedNumericKeyPaths)], { keyPath: [] });\n}\n","import { RpcResponseTransformer } from '@solana/rpc-spec-types';\n\ntype JsonRpcResponse = { result: unknown };\n\n/**\n * Returns a transformer that extracts the `result` field from the body of the RPC response.\n *\n * For instance, we go from `{ jsonrpc: '2.0', result: 'foo', id: 1 }` to `'foo'`.\n *\n * @example\n * ```ts\n * import { getResultResponseTransformer } from '@solana/rpc-transformers';\n *\n * const responseTransformer = getResultResponseTransformer();\n * ```\n */\nexport function getResultResponseTransformer(): RpcResponseTransformer {\n return json => (json as JsonRpcResponse).result;\n}\n","import { KeyPath, KEYPATH_WILDCARD } from './tree-traversal';\n\nexport type AllowedNumericKeypaths = Partial>;\n\n// Numeric values nested in `jsonParsed` accounts\nexport const jsonParsedTokenAccountsConfigs = [\n // parsed Token/Token22 token account\n ['data', 'parsed', 'info', 'tokenAmount', 'decimals'],\n ['data', 'parsed', 'info', 'tokenAmount', 'uiAmount'],\n ['data', 'parsed', 'info', 'rentExemptReserve', 'decimals'],\n ['data', 'parsed', 'info', 'rentExemptReserve', 'uiAmount'],\n ['data', 'parsed', 'info', 'delegatedAmount', 'decimals'],\n ['data', 'parsed', 'info', 'delegatedAmount', 'uiAmount'],\n ['data', 'parsed', 'info', 'extensions', KEYPATH_WILDCARD, 'state', 'olderTransferFee', 'transferFeeBasisPoints'],\n ['data', 'parsed', 'info', 'extensions', KEYPATH_WILDCARD, 'state', 'newerTransferFee', 'transferFeeBasisPoints'],\n ['data', 'parsed', 'info', 'extensions', KEYPATH_WILDCARD, 'state', 'preUpdateAverageRate'],\n ['data', 'parsed', 'info', 'extensions', KEYPATH_WILDCARD, 'state', 'currentRate'],\n];\nexport const jsonParsedAccountsConfigs = [\n ...jsonParsedTokenAccountsConfigs,\n // parsed AddressTableLookup account\n ['data', 'parsed', 'info', 'lastExtendedSlotStartIndex'],\n // parsed Config account\n ['data', 'parsed', 'info', 'slashPenalty'],\n ['data', 'parsed', 'info', 'warmupCooldownRate'],\n // parsed Token/Token22 mint account\n ['data', 'parsed', 'info', 'decimals'],\n // parsed Token/Token22 multisig account\n ['data', 'parsed', 'info', 'numRequiredSigners'],\n ['data', 'parsed', 'info', 'numValidSigners'],\n // parsed Stake account\n ['data', 'parsed', 'info', 'stake', 'delegation', 'warmupCooldownRate'],\n // parsed Sysvar rent account\n ['data', 'parsed', 'info', 'exemptionThreshold'],\n ['data', 'parsed', 'info', 'burnPercent'],\n // parsed Vote account\n ['data', 'parsed', 'info', 'commission'],\n ['data', 'parsed', 'info', 'votes', KEYPATH_WILDCARD, 'confirmationCount'],\n];\nexport const innerInstructionsConfigs = [\n ['index'],\n ['instructions', KEYPATH_WILDCARD, 'accounts', KEYPATH_WILDCARD],\n ['instructions', KEYPATH_WILDCARD, 'programIdIndex'],\n ['instructions', KEYPATH_WILDCARD, 'stackHeight'],\n];\nexport const messageConfig = [\n ['addressTableLookups', KEYPATH_WILDCARD, 'writableIndexes', KEYPATH_WILDCARD],\n ['addressTableLookups', KEYPATH_WILDCARD, 'readonlyIndexes', KEYPATH_WILDCARD],\n ['header', 'numReadonlySignedAccounts'],\n ['header', 'numReadonlyUnsignedAccounts'],\n ['header', 'numRequiredSignatures'],\n ['instructions', KEYPATH_WILDCARD, 'accounts', KEYPATH_WILDCARD],\n ['instructions', KEYPATH_WILDCARD, 'programIdIndex'],\n ['instructions', KEYPATH_WILDCARD, 'stackHeight'],\n] as const;\n","import { getSolanaErrorFromJsonRpcError } from '@solana/errors';\nimport { RpcResponseTransformer } from '@solana/rpc-spec-types';\n\nimport { innerInstructionsConfigs, jsonParsedAccountsConfigs } from './response-transformer-allowed-numeric-values';\nimport { getBigIntUpcastVisitor } from './response-transformer-bigint-upcast-internal';\nimport { getTreeWalkerResponseTransformer, KeyPath, KEYPATH_WILDCARD } from './tree-traversal';\n\ntype JsonRpcResponse = { error: Parameters[0] } | { result: unknown };\n\n// Keypaths for simulateTransaction result that should remain as Number (not BigInt)\n// Note: These are relative to the error.data root, not result.value like in success responses\nfunction getSimulateTransactionAllowedNumericKeypaths(): readonly KeyPath[] {\n return [\n ['loadedAccountsDataSize'],\n ...jsonParsedAccountsConfigs.map(c => ['accounts', KEYPATH_WILDCARD, ...c]),\n ...innerInstructionsConfigs.map(c => ['innerInstructions', KEYPATH_WILDCARD, ...c]),\n ];\n}\n\n/**\n * Returns a transformer that throws a {@link SolanaError} with the appropriate RPC error code if\n * the body of the RPC response contains an error.\n *\n * @example\n * ```ts\n * import { getThrowSolanaErrorResponseTransformer } from '@solana/rpc-transformers';\n *\n * const responseTransformer = getThrowSolanaErrorResponseTransformer();\n * ```\n */\nexport function getThrowSolanaErrorResponseTransformer(): RpcResponseTransformer {\n return (json, request) => {\n const jsonRpcResponse = json as JsonRpcResponse;\n if ('error' in jsonRpcResponse) {\n const { error } = jsonRpcResponse;\n\n // Check if this is a sendTransaction preflight failure (error code -32002)\n // These errors contain RpcSimulateTransactionResult in error.data which needs\n // BigInt values downcast to Number for fields that should be numbers\n const isSendTransactionPreflightFailure =\n error &&\n typeof error === 'object' &&\n 'code' in error &&\n (error.code === -32002 || error.code === -32002n);\n\n if (isSendTransactionPreflightFailure && 'data' in error && error.data) {\n // Apply BigInt downcast transformation to error.data\n const treeWalker = getTreeWalkerResponseTransformer(\n [getBigIntUpcastVisitor(getSimulateTransactionAllowedNumericKeypaths())],\n { keyPath: [] },\n );\n const transformedData = treeWalker(error.data, request);\n\n // Reconstruct error with transformed data\n const transformedError = { ...error, data: transformedData };\n throw getSolanaErrorFromJsonRpcError(transformedError);\n }\n\n throw getSolanaErrorFromJsonRpcError(jsonRpcResponse.error);\n }\n return jsonRpcResponse;\n };\n}\n","import { pipe } from '@solana/functional';\nimport { RpcRequest, RpcResponse, RpcResponseTransformer } from '@solana/rpc-spec-types';\n\nimport { AllowedNumericKeypaths } from './response-transformer-allowed-numeric-values';\nimport { getBigIntUpcastResponseTransformer } from './response-transformer-bigint-upcast';\nimport { getResultResponseTransformer } from './response-transformer-result';\nimport { getThrowSolanaErrorResponseTransformer } from './response-transformer-throw-solana-error';\n\nexport type ResponseTransformerConfig = Readonly<{\n /**\n * An optional map from the name of an API method to an array of {@link KeyPath | KeyPaths}\n * pointing to values in the response that should materialize in the application as `Number`\n * instead of `BigInt`.\n */\n allowedNumericKeyPaths?: AllowedNumericKeypaths;\n}>;\n\n/**\n * Returns the default response transformer for the Solana RPC API.\n *\n * Under the hood, this function composes multiple\n * {@link RpcResponseTransformer | RpcResponseTransformers} together such as the\n * {@link getThrowSolanaErrorResponseTransformer}, the {@link getResultResponseTransformer} and the\n * {@link getBigIntUpcastResponseTransformer}.\n *\n * @example\n * ```ts\n * import { getDefaultResponseTransformerForSolanaRpc } from '@solana/rpc-transformers';\n *\n * const responseTransformer = getDefaultResponseTransformerForSolanaRpc({\n * allowedNumericKeyPaths: getAllowedNumericKeypaths(),\n * });\n * ```\n */\nexport function getDefaultResponseTransformerForSolanaRpc(\n config?: ResponseTransformerConfig,\n): RpcResponseTransformer {\n return (response: RpcResponse, request: RpcRequest): RpcResponse => {\n const methodName = request.methodName as keyof TApi;\n const keyPaths =\n config?.allowedNumericKeyPaths && methodName ? config.allowedNumericKeyPaths[methodName] : undefined;\n return pipe(\n response,\n r => getThrowSolanaErrorResponseTransformer()(r, request),\n r => getResultResponseTransformer()(r, request),\n r => getBigIntUpcastResponseTransformer(keyPaths ?? [])(r, request),\n );\n };\n}\n\n/**\n * Returns the default response transformer for the Solana RPC Subscriptions API.\n *\n * Under the hood, this function composes the {@link getBigIntUpcastResponseTransformer}.\n *\n * @example\n * ```ts\n * import { getDefaultResponseTransformerForSolanaRpcSubscriptions } from '@solana/rpc-transformers';\n *\n * const responseTransformer = getDefaultResponseTransformerForSolanaRpcSubscriptions({\n * allowedNumericKeyPaths: getAllowedNumericKeypaths(),\n * });\n * ```\n */\nexport function getDefaultResponseTransformerForSolanaRpcSubscriptions(\n config?: ResponseTransformerConfig,\n): RpcResponseTransformer {\n return (response: RpcResponse, request: RpcRequest): RpcResponse => {\n const methodName = request.methodName as keyof TApi;\n const keyPaths =\n config?.allowedNumericKeyPaths && methodName ? config.allowedNumericKeyPaths[methodName] : undefined;\n return pipe(response, r => getBigIntUpcastResponseTransformer(keyPaths ?? [])(r, request));\n };\n}\n"]}