@solana/rpc-core - npm Package Compare versions

Comparing version 2.0.0-experimental.a7f0f86 to 2.0.0-experimental.a81a78e

dist/index.browser.js

@@ -1,169 +0,3 @@
-import { base58 } from '@metaplex-foundation/umi-serializers-encodings';
-
-// src/blockhash.ts
-function assertIsBlockhash(putativeBlockhash) {
-  try {
-    if (
-      // Lowest value (32 bytes of zeroes)
-      putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
-      putativeBlockhash.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = base58.serialize(putativeBlockhash);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-      cause: e
-    });
-  }
-}
-
-// src/params-patcher.ts
-function visitNode(value, keyPath, onIntegerOverflow) {
-  if (Array.isArray(value)) {
-    return value.map(
-      (element, ii) => visitNode(element, [...keyPath, ii], onIntegerOverflow)
-    );
-  } else if (typeof value === "object" && value !== null) {
-    const out = {};
-    for (const propName in value) {
-      if (Object.prototype.hasOwnProperty.call(value, propName)) {
-        out[propName] = visitNode(value[propName], [...keyPath, propName], onIntegerOverflow);
-      }
-    }
-    return out;
-  } else if (typeof value === "bigint") {
-    if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {
-      onIntegerOverflow(keyPath, value);
-    }
-    return Number(value);
-  } else {
-    return value;
-  }
-}
-function patchParamsForSolanaLabsRpc(params, onIntegerOverflow) {
-  return visitNode(params, [], onIntegerOverflow);
-}
-
-// src/response-patcher-types.ts
-var KEYPATH_WILDCARD = {};
-
-// src/response-patcher-allowed-numeric-values.ts
-var ALLOWED_NUMERIC_KEYPATHS = {
-  getAccountInfo: [
-    // parsed AddressTableLookup account
-    ["value", "data", "parsed", "info", "lastExtendedSlotStartIndex"],
-    // parsed Config account
-    ["value", "data", "parsed", "info", "slashPenalty"],
-    ["value", "data", "parsed", "info", "warmupCooldownRate"],
-    // parsed Token/Token22 token account
-    ["value", "data", "parsed", "info", "tokenAmount", "decimals"],
-    ["value", "data", "parsed", "info", "tokenAmount", "uiAmount"],
-    ["value", "data", "parsed", "info", "rentExemptReserve", "decimals"],
-    ["value", "data", "parsed", "info", "delegatedAmount", "decimals"],
-    [
-      "value",
-      "data",
-      "parsed",
-      "info",
-      "extensions",
-      KEYPATH_WILDCARD,
-      "state",
-      "olderTransferFee",
-      "transferFeeBasisPoints"
-    ],
-    [
-      "value",
-      "data",
-      "parsed",
-      "info",
-      "extensions",
-      KEYPATH_WILDCARD,
-      "state",
-      "newerTransferFee",
-      "transferFeeBasisPoints"
-    ],
-    ["value", "data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "preUpdateAverageRate"],
-    ["value", "data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "currentRate"],
-    // parsed Token/Token22 mint account
-    ["value", "data", "parsed", "info", "decimals"],
-    // parsed Token/Token22 multisig account
-    ["value", "data", "parsed", "info", "numRequiredSigners"],
-    ["value", "data", "parsed", "info", "numValidSigners"],
-    // parsed Stake account
-    ["value", "data", "parsed", "info", "stake", "delegation", "warmupCooldownRate"],
-    // parsed Sysvar rent account
-    ["value", "data", "parsed", "info", "exemptionThreshold"],
-    ["value", "data", "parsed", "info", "burnPercent"],
-    // parsed Vote account
-    ["value", "data", "parsed", "info", "commission"],
-    ["value", "data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
-  ],
-  getBlockTime: [[]],
-  getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
-  getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
-  getTokenLargestAccounts: [
-    ["value", KEYPATH_WILDCARD, "decimals"],
-    ["value", KEYPATH_WILDCARD, "uiAmount"]
-  ],
-  getTransaction: [
-    ["meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
-    ["meta", "preTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
-    ["meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
-    ["meta", "postTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
-    ["meta", "rewards", KEYPATH_WILDCARD, "commission"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "programIdIndex"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
-    ["transaction", "message", "addressTableLookups", KEYPATH_WILDCARD, "writableIndexes", KEYPATH_WILDCARD],
-    ["transaction", "message", "addressTableLookups", KEYPATH_WILDCARD, "readonlyIndexes", KEYPATH_WILDCARD],
-    ["transaction", "message", "instructions", KEYPATH_WILDCARD, "programIdIndex"],
-    ["transaction", "message", "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
-    ["transaction", "message", "header", "numReadonlySignedAccounts"],
-    ["transaction", "message", "header", "numReadonlyUnsignedAccounts"],
-    ["transaction", "message", "header", "numRequiredSignatures"]
-  ],
-  getVoteAccounts: [
-    ["current", KEYPATH_WILDCARD, "commission"],
-    ["delinquent", KEYPATH_WILDCARD, "commission"]
-  ]
-};
-
-// src/response-patcher.ts
-function getNextAllowedKeypaths(keyPaths, property) {
-  return keyPaths.filter((keyPath) => keyPath[0] === KEYPATH_WILDCARD && typeof property === "number" || keyPath[0] === property).map((keyPath) => keyPath.slice(1));
-}
-function visitNode2(value, allowedKeypaths) {
-  if (Array.isArray(value)) {
-    return value.map((element, ii) => {
-      const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, ii);
-      return visitNode2(element, nextAllowedKeypaths);
-    });
-  } else if (typeof value === "object" && value !== null) {
-    const out = {};
-    for (const [propName, innerValue] of Object.entries(value)) {
-      const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, propName);
-      out[propName] = visitNode2(innerValue, nextAllowedKeypaths);
-    }
-    return out;
-  } else if (typeof value === "number" && // The presence of an allowed keypath on the route to this value implies it's allowlisted;
-  // Upcast the value to `bigint` unless an allowed keypath is present.
-  allowedKeypaths.length === 0 && // Only try to upcast an Integer to `bigint`
-  Number.isInteger(value)) {
-    return BigInt(value);
-  } else {
-    return value;
-  }
-}
-function patchResponseForSolanaLabsRpc(rawResponse, methodName) {
-  const allowedKeypaths = methodName ? ALLOWED_NUMERIC_KEYPATHS[methodName] : void 0;
-  return visitNode2(rawResponse, allowedKeypaths ?? []);
-}
-
-// src/rpc-methods/index.ts
-function createSolanaRpcApi(config) {
+// ../rpc-transport/dist/index.browser.js
+function createJsonRpcApi(config) {
   return new Proxy({}, {
@@ -180,11 +14,8 @@ defineProperty() {
       return function(...rawParams) {
-        const handleIntegerOverflow = config?.onIntegerOverflow;
-        const params = patchParamsForSolanaLabsRpc(
-          rawParams,
-          handleIntegerOverflow ? (keyPath, value) => handleIntegerOverflow(methodName, keyPath, value) : void 0
-        );
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, methodName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
         return {
           methodName,
           params,
-          responseProcessor: (rawResponse) => patchResponseForSolanaLabsRpc(rawResponse, methodName)
+          responseTransformer
         };
@@ -195,49 +26,669 @@ };
 }
+function createJsonRpcSubscriptionsApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const notificationName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, notificationName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        const subscribeMethodName = config?.subscribeNotificationNameTransformer ? config?.subscribeNotificationNameTransformer(notificationName) : notificationName;
+        const unsubscribeMethodName = config?.unsubscribeNotificationNameTransformer ? config?.unsubscribeNotificationNameTransformer(notificationName) : notificationName;
+        return {
+          params,
+          responseTransformer,
+          subscribeMethodName,
+          unsubscribeMethodName
+        };
+      };
+    }
+  });
+}
 
-// src/stringified-bigint.ts
-function assertIsStringifiedBigInt(putativeBigInt) {
-  try {
-    BigInt(putativeBigInt);
-  } catch (e) {
-    throw new Error(`\`${putativeBigInt}\` cannot be parsed as a BigInt`, {
-      cause: e
-    });
-  }
-}
-function assertIsTransactionSignature(putativeTransactionSignature) {
-  try {
+// src/default-commitment.ts
+function applyDefaultCommitment({
+  commitmentPropertyName,
+  params,
+  optionsObjectPositionInParams,
+  overrideCommitment
+}) {
+  const paramInTargetPosition = params[optionsObjectPositionInParams];
+  if (
+    // There's no config.
+    paramInTargetPosition === void 0 || // There is a config object.
+    paramInTargetPosition && typeof paramInTargetPosition === "object" && !Array.isArray(paramInTargetPosition)
+  ) {
     if (
-      // Lowest value (64 bytes of zeroes)
-      putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-      putativeTransactionSignature.length > 88
+      // The config object already has a commitment set.
+      paramInTargetPosition && commitmentPropertyName in paramInTargetPosition
     ) {
-      throw new Error("Expected input string to decode to a byte array of length 64.");
+      if (!paramInTargetPosition[commitmentPropertyName] || paramInTargetPosition[commitmentPropertyName] === "finalized") {
+        const nextParams = [...params];
+        const {
+          [commitmentPropertyName]: _,
+          // eslint-disable-line @typescript-eslint/no-unused-vars
+          ...rest
+        } = paramInTargetPosition;
+        if (Object.keys(rest).length > 0) {
+          nextParams[optionsObjectPositionInParams] = rest;
+        } else {
+          if (optionsObjectPositionInParams === nextParams.length - 1) {
+            nextParams.length--;
+          } else {
+            nextParams[optionsObjectPositionInParams] = void 0;
+          }
+        }
+        return nextParams;
+      }
+    } else if (overrideCommitment !== "finalized") {
+      const nextParams = [...params];
+      nextParams[optionsObjectPositionInParams] = {
+        ...paramInTargetPosition,
+        [commitmentPropertyName]: overrideCommitment
+      };
+      return nextParams;
     }
-    const bytes = base58.serialize(putativeTransactionSignature);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 64) {
-      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeTransactionSignature}\` is not a transaction signature`, {
-      cause: e
-    });
   }
+  return params;
 }
 
-// src/unix-timestamp.ts
-function assertIsUnixTimestamp(putativeTimestamp) {
-  try {
-    if (putativeTimestamp > 864e13 || putativeTimestamp < -864e13) {
-      throw new Error("Expected input number to be in the range [-8.64e15, 8.64e15]");
+// src/params-patcher-bigint-downcast.ts
+function downcastNodeToNumberIfBigint(value) {
+  return typeof value === "bigint" ? (
+    // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana
+    // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely
+    // downcasting `bigints` to `numbers`.
+    Number(value)
+  ) : value;
+}
+
+// src/params-patcher-integer-overflow.ts
+function getIntegerOverflowNodeVisitor(onIntegerOverflow) {
+  return (value, { keyPath }) => {
+    if (typeof value === "bigint") {
+      if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {
+        onIntegerOverflow(keyPath, value);
+      }
     }
-  } catch (e) {
-    throw new Error(`\`${putativeTimestamp}\` is not a timestamp`, {
-      cause: e
+    return value;
+  };
+}
+
+// src/params-patcher-options-object-position-config.ts
+var OPTIONS_OBJECT_POSITION_BY_METHOD = {
+  accountNotifications: 1,
+  blockNotifications: 1,
+  getAccountInfo: 1,
+  getBalance: 1,
+  getBlock: 1,
+  getBlockHeight: 0,
+  getBlockProduction: 0,
+  getBlocks: 2,
+  getBlocksWithLimit: 2,
+  getConfirmedBlock: 1,
+  getConfirmedBlocks: 1,
+  getConfirmedBlocksWithLimit: 2,
+  getConfirmedSignaturesForAddress2: 1,
+  getConfirmedTransaction: 1,
+  getEpochInfo: 0,
+  getFeeCalculatorForBlockhash: 1,
+  getFeeForMessage: 1,
+  getFees: 1,
+  getInflationGovernor: 0,
+  getInflationReward: 1,
+  getLargestAccounts: 0,
+  getLatestBlockhash: 0,
+  getLeaderSchedule: 1,
+  getMinimumBalanceForRentExemption: 1,
+  getMultipleAccounts: 1,
+  getProgramAccounts: 1,
+  getRecentBlockhash: 1,
+  getSignaturesForAddress: 1,
+  getSlot: 0,
+  getSlotLeader: 0,
+  getStakeActivation: 1,
+  getStakeMinimumDelegation: 0,
+  getSupply: 0,
+  getTokenAccountBalance: 1,
+  getTokenAccountsByDelegate: 2,
+  getTokenAccountsByOwner: 2,
+  getTokenLargestAccounts: 1,
+  getTokenSupply: 1,
+  getTransaction: 1,
+  getTransactionCount: 0,
+  getVoteAccounts: 0,
+  isBlockhashValid: 1,
+  logsNotifications: 1,
+  programNotifications: 1,
+  requestAirdrop: 2,
+  sendTransaction: 1,
+  signatureNotifications: 1,
+  simulateTransaction: 1
+};
+
+// src/tree-traversal.ts
+var KEYPATH_WILDCARD = {};
+function getTreeWalker(visitors) {
+  return function traverse(node, state) {
+    if (Array.isArray(node)) {
+      return node.map((element, ii) => {
+        const nextState = {
+          ...state,
+          keyPath: [...state.keyPath, ii]
+        };
+        return traverse(element, nextState);
+      });
+    } else if (typeof node === "object" && node !== null) {
+      const out = {};
+      for (const propName in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, propName)) {
+          continue;
+        }
+        const nextState = {
+          ...state,
+          keyPath: [...state.keyPath, propName]
+        };
+        out[propName] = traverse(node[propName], nextState);
+      }
+      return out;
+    } else {
+      return visitors.reduce((acc, visitNode) => visitNode(acc, state), node);
+    }
+  };
+}
+
+// src/params-patcher.ts
+function getParamsPatcherForSolanaLabsRpc(config) {
+  const defaultCommitment = config?.defaultCommitment;
+  const handleIntegerOverflow = config?.onIntegerOverflow;
+  return (rawParams, methodName) => {
+    const traverse = getTreeWalker([
+      ...handleIntegerOverflow ? [getIntegerOverflowNodeVisitor((...args) => handleIntegerOverflow(methodName, ...args))] : [],
+      downcastNodeToNumberIfBigint
+    ]);
+    const initialState = {
+      keyPath: []
+    };
+    const patchedParams = traverse(rawParams, initialState);
+    if (!Array.isArray(patchedParams)) {
+      return patchedParams;
+    }
+    const optionsObjectPositionInParams = OPTIONS_OBJECT_POSITION_BY_METHOD[methodName];
+    if (optionsObjectPositionInParams == null) {
+      return patchedParams;
+    }
+    return applyDefaultCommitment({
+      commitmentPropertyName: methodName === "sendTransaction" ? "preflightCommitment" : "commitment",
+      optionsObjectPositionInParams,
+      overrideCommitment: defaultCommitment,
+      params: patchedParams
     });
+  };
+}
+
+// src/response-patcher-allowed-numeric-values.ts
+var jsonParsedTokenAccountsConfigs = [
+  // parsed Token/Token22 token account
+  ["data", "parsed", "info", "tokenAmount", "decimals"],
+  ["data", "parsed", "info", "tokenAmount", "uiAmount"],
+  ["data", "parsed", "info", "rentExemptReserve", "decimals"],
+  ["data", "parsed", "info", "rentExemptReserve", "uiAmount"],
+  ["data", "parsed", "info", "delegatedAmount", "decimals"],
+  ["data", "parsed", "info", "delegatedAmount", "uiAmount"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "olderTransferFee", "transferFeeBasisPoints"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "newerTransferFee", "transferFeeBasisPoints"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "preUpdateAverageRate"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "currentRate"]
+];
+var jsonParsedAccountsConfigs = [
+  ...jsonParsedTokenAccountsConfigs,
+  // parsed AddressTableLookup account
+  ["data", "parsed", "info", "lastExtendedSlotStartIndex"],
+  // parsed Config account
+  ["data", "parsed", "info", "slashPenalty"],
+  ["data", "parsed", "info", "warmupCooldownRate"],
+  // parsed Token/Token22 mint account
+  ["data", "parsed", "info", "decimals"],
+  // parsed Token/Token22 multisig account
+  ["data", "parsed", "info", "numRequiredSigners"],
+  ["data", "parsed", "info", "numValidSigners"],
+  // parsed Stake account
+  ["data", "parsed", "info", "stake", "delegation", "warmupCooldownRate"],
+  // parsed Sysvar rent account
+  ["data", "parsed", "info", "exemptionThreshold"],
+  ["data", "parsed", "info", "burnPercent"],
+  // parsed Vote account
+  ["data", "parsed", "info", "commission"],
+  ["data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
+];
+var memoizedNotificationKeypaths;
+var memoizedResponseKeypaths;
+function getAllowedNumericKeypathsForNotification() {
+  if (!memoizedNotificationKeypaths) {
+    memoizedNotificationKeypaths = {
+      accountNotifications: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+      blockNotifications: [
+        ["value", "block", "blockTime"],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "accountIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "accountIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["value", "block", "transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "index"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numReadonlySignedAccounts"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numReadonlyUnsignedAccounts"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numRequiredSignatures"
+        ],
+        ["value", "block", "rewards", KEYPATH_WILDCARD, "commission"]
+      ],
+      programNotifications: jsonParsedAccountsConfigs.flatMap((c) => [
+        ["value", KEYPATH_WILDCARD, "account", ...c],
+        [KEYPATH_WILDCARD, "account", ...c]
+      ])
+    };
   }
+  return memoizedNotificationKeypaths;
 }
+function getAllowedNumericKeypathsForResponse() {
+  if (!memoizedResponseKeypaths) {
+    memoizedResponseKeypaths = {
+      getAccountInfo: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+      getBlock: [
+        ["blockTime"],
+        ["transactions", KEYPATH_WILDCARD, "meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["transactions", KEYPATH_WILDCARD, "meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        ["transactions", KEYPATH_WILDCARD, "meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numReadonlySignedAccounts"],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numReadonlyUnsignedAccounts"],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numRequiredSignatures"],
+        ["rewards", KEYPATH_WILDCARD, "commission"]
+      ],
+      getBlockTime: [[]],
+      getClusterNodes: [
+        [KEYPATH_WILDCARD, "featureSet"],
+        [KEYPATH_WILDCARD, "shredVersion"]
+      ],
+      getInflationGovernor: [["initial"], ["foundation"], ["foundationTerm"], ["taper"], ["terminal"]],
+      getInflationRate: [["foundation"], ["total"], ["validator"]],
+      getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
+      getMultipleAccounts: jsonParsedAccountsConfigs.map((c) => ["value", KEYPATH_WILDCARD, ...c]),
+      getProgramAccounts: jsonParsedAccountsConfigs.flatMap((c) => [
+        ["value", KEYPATH_WILDCARD, "account", ...c],
+        [KEYPATH_WILDCARD, "account", ...c]
+      ]),
+      getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
+      getTokenAccountBalance: [
+        ["value", "decimals"],
+        ["value", "uiAmount"]
+      ],
+      getTokenAccountsByDelegate: jsonParsedTokenAccountsConfigs.map((c) => [
+        "value",
+        KEYPATH_WILDCARD,
+        "account",
+        ...c
+      ]),
+      getTokenAccountsByOwner: jsonParsedTokenAccountsConfigs.map((c) => [
+        "value",
+        KEYPATH_WILDCARD,
+        "account",
+        ...c
+      ]),
+      getTokenLargestAccounts: [
+        ["value", KEYPATH_WILDCARD, "decimals"],
+        ["value", KEYPATH_WILDCARD, "uiAmount"]
+      ],
+      getTokenSupply: [
+        ["value", "decimals"],
+        ["value", "uiAmount"]
+      ],
+      getTransaction: [
+        ["meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        ["meta", "preTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+        ["meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        ["meta", "postTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+        ["meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        ["meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
+        ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "programIdIndex"],
+        [
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        ["transaction", "message", "instructions", KEYPATH_WILDCARD, "programIdIndex"],
+        ["transaction", "message", "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
+        ["transaction", "message", "header", "numReadonlySignedAccounts"],
+        ["transaction", "message", "header", "numReadonlyUnsignedAccounts"],
+        ["transaction", "message", "header", "numRequiredSignatures"]
+      ],
+      getVersion: [["feature-set"]],
+      getVoteAccounts: [
+        ["current", KEYPATH_WILDCARD, "commission"],
+        ["delinquent", KEYPATH_WILDCARD, "commission"]
+      ],
+      simulateTransaction: jsonParsedAccountsConfigs.map((c) => ["value", "accounts", KEYPATH_WILDCARD, ...c])
+    };
+  }
+  return memoizedResponseKeypaths;
+}
 
-export { assertIsBlockhash, assertIsStringifiedBigInt, assertIsTransactionSignature, assertIsUnixTimestamp, createSolanaRpcApi };
+// src/response-patcher-bigint-upcast.ts
+function keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths) {
+  return allowedNumericKeyPaths.some((prohibitedKeyPath) => {
+    if (prohibitedKeyPath.length !== keyPath.length) {
+      return false;
+    }
+    for (let ii = keyPath.length - 1; ii >= 0; ii--) {
+      const keyPathPart = keyPath[ii];
+      const prohibitedKeyPathPart = prohibitedKeyPath[ii];
+      if (prohibitedKeyPathPart !== keyPathPart && (prohibitedKeyPathPart !== KEYPATH_WILDCARD || typeof keyPathPart !== "number")) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function getBigIntUpcastVisitor(allowedNumericKeyPaths) {
+  return function upcastNodeToBigIntIfNumber(value, { keyPath }) {
+    if (typeof value === "number" && Number.isInteger(value) && !keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths)) {
+      return BigInt(value);
+    } else {
+      return value;
+    }
+  };
+}
+
+// src/response-patcher.ts
+function patchResponseForSolanaLabsRpc(rawResponse, methodName) {
+  const allowedNumericKeyPaths = methodName ? getAllowedNumericKeypathsForResponse()[methodName] : void 0;
+  const traverse = getTreeWalker([getBigIntUpcastVisitor(allowedNumericKeyPaths ?? [])]);
+  const initialState = {
+    keyPath: []
+  };
+  return traverse(rawResponse, initialState);
+}
+function patchResponseForSolanaLabsRpcSubscriptions(rawResponse, notificationName) {
+  const allowedNumericKeyPaths = notificationName ? getAllowedNumericKeypathsForNotification()[notificationName] : void 0;
+  const traverse = getTreeWalker([getBigIntUpcastVisitor(allowedNumericKeyPaths ?? [])]);
+  const initialState = {
+    keyPath: []
+  };
+  return traverse(rawResponse, initialState);
+}
+
+// src/rpc-methods/index.ts
+function createSolanaRpcApi(config) {
+  return createJsonRpcApi({
+    parametersTransformer: getParamsPatcherForSolanaLabsRpc(config),
+    responseTransformer: patchResponseForSolanaLabsRpc
+  });
+}
+
+// src/rpc-subscriptions/index.ts
+function createSolanaRpcSubscriptionsApi_INTERNAL(config) {
+  return createJsonRpcSubscriptionsApi({
+    parametersTransformer: getParamsPatcherForSolanaLabsRpc(config),
+    responseTransformer: patchResponseForSolanaLabsRpcSubscriptions,
+    subscribeNotificationNameTransformer: (notificationName) => notificationName.replace(/Notifications$/, "Subscribe"),
+    unsubscribeNotificationNameTransformer: (notificationName) => notificationName.replace(/Notifications$/, "Unsubscribe")
+  });
+}
+function createSolanaRpcSubscriptionsApi(config) {
+  return createSolanaRpcSubscriptionsApi_INTERNAL(config);
+}
+function createSolanaRpcSubscriptionsApi_UNSTABLE(config) {
+  return createSolanaRpcSubscriptionsApi_INTERNAL(config);
+}
+
+export { createSolanaRpcApi, createSolanaRpcSubscriptionsApi, createSolanaRpcSubscriptionsApi_INTERNAL, createSolanaRpcSubscriptionsApi_UNSTABLE };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.js.map

dist/index.native.js

@@ -1,169 +0,3 @@
-import { base58 } from '@metaplex-foundation/umi-serializers-encodings';
-
-// src/blockhash.ts
-function assertIsBlockhash(putativeBlockhash) {
-  try {
-    if (
-      // Lowest value (32 bytes of zeroes)
-      putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
-      putativeBlockhash.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = base58.serialize(putativeBlockhash);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-      cause: e
-    });
-  }
-}
-
-// src/params-patcher.ts
-function visitNode(value, keyPath, onIntegerOverflow) {
-  if (Array.isArray(value)) {
-    return value.map(
-      (element, ii) => visitNode(element, [...keyPath, ii], onIntegerOverflow)
-    );
-  } else if (typeof value === "object" && value !== null) {
-    const out = {};
-    for (const propName in value) {
-      if (Object.prototype.hasOwnProperty.call(value, propName)) {
-        out[propName] = visitNode(value[propName], [...keyPath, propName], onIntegerOverflow);
-      }
-    }
-    return out;
-  } else if (typeof value === "bigint") {
-    if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {
-      onIntegerOverflow(keyPath, value);
-    }
-    return Number(value);
-  } else {
-    return value;
-  }
-}
-function patchParamsForSolanaLabsRpc(params, onIntegerOverflow) {
-  return visitNode(params, [], onIntegerOverflow);
-}
-
-// src/response-patcher-types.ts
-var KEYPATH_WILDCARD = {};
-
-// src/response-patcher-allowed-numeric-values.ts
-var ALLOWED_NUMERIC_KEYPATHS = {
-  getAccountInfo: [
-    // parsed AddressTableLookup account
-    ["value", "data", "parsed", "info", "lastExtendedSlotStartIndex"],
-    // parsed Config account
-    ["value", "data", "parsed", "info", "slashPenalty"],
-    ["value", "data", "parsed", "info", "warmupCooldownRate"],
-    // parsed Token/Token22 token account
-    ["value", "data", "parsed", "info", "tokenAmount", "decimals"],
-    ["value", "data", "parsed", "info", "tokenAmount", "uiAmount"],
-    ["value", "data", "parsed", "info", "rentExemptReserve", "decimals"],
-    ["value", "data", "parsed", "info", "delegatedAmount", "decimals"],
-    [
-      "value",
-      "data",
-      "parsed",
-      "info",
-      "extensions",
-      KEYPATH_WILDCARD,
-      "state",
-      "olderTransferFee",
-      "transferFeeBasisPoints"
-    ],
-    [
-      "value",
-      "data",
-      "parsed",
-      "info",
-      "extensions",
-      KEYPATH_WILDCARD,
-      "state",
-      "newerTransferFee",
-      "transferFeeBasisPoints"
-    ],
-    ["value", "data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "preUpdateAverageRate"],
-    ["value", "data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "currentRate"],
-    // parsed Token/Token22 mint account
-    ["value", "data", "parsed", "info", "decimals"],
-    // parsed Token/Token22 multisig account
-    ["value", "data", "parsed", "info", "numRequiredSigners"],
-    ["value", "data", "parsed", "info", "numValidSigners"],
-    // parsed Stake account
-    ["value", "data", "parsed", "info", "stake", "delegation", "warmupCooldownRate"],
-    // parsed Sysvar rent account
-    ["value", "data", "parsed", "info", "exemptionThreshold"],
-    ["value", "data", "parsed", "info", "burnPercent"],
-    // parsed Vote account
-    ["value", "data", "parsed", "info", "commission"],
-    ["value", "data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
-  ],
-  getBlockTime: [[]],
-  getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
-  getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
-  getTokenLargestAccounts: [
-    ["value", KEYPATH_WILDCARD, "decimals"],
-    ["value", KEYPATH_WILDCARD, "uiAmount"]
-  ],
-  getTransaction: [
-    ["meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
-    ["meta", "preTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
-    ["meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
-    ["meta", "postTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
-    ["meta", "rewards", KEYPATH_WILDCARD, "commission"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "programIdIndex"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
-    ["transaction", "message", "addressTableLookups", KEYPATH_WILDCARD, "writableIndexes", KEYPATH_WILDCARD],
-    ["transaction", "message", "addressTableLookups", KEYPATH_WILDCARD, "readonlyIndexes", KEYPATH_WILDCARD],
-    ["transaction", "message", "instructions", KEYPATH_WILDCARD, "programIdIndex"],
-    ["transaction", "message", "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
-    ["transaction", "message", "header", "numReadonlySignedAccounts"],
-    ["transaction", "message", "header", "numReadonlyUnsignedAccounts"],
-    ["transaction", "message", "header", "numRequiredSignatures"]
-  ],
-  getVoteAccounts: [
-    ["current", KEYPATH_WILDCARD, "commission"],
-    ["delinquent", KEYPATH_WILDCARD, "commission"]
-  ]
-};
-
-// src/response-patcher.ts
-function getNextAllowedKeypaths(keyPaths, property) {
-  return keyPaths.filter((keyPath) => keyPath[0] === KEYPATH_WILDCARD && typeof property === "number" || keyPath[0] === property).map((keyPath) => keyPath.slice(1));
-}
-function visitNode2(value, allowedKeypaths) {
-  if (Array.isArray(value)) {
-    return value.map((element, ii) => {
-      const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, ii);
-      return visitNode2(element, nextAllowedKeypaths);
-    });
-  } else if (typeof value === "object" && value !== null) {
-    const out = {};
-    for (const [propName, innerValue] of Object.entries(value)) {
-      const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, propName);
-      out[propName] = visitNode2(innerValue, nextAllowedKeypaths);
-    }
-    return out;
-  } else if (typeof value === "number" && // The presence of an allowed keypath on the route to this value implies it's allowlisted;
-  // Upcast the value to `bigint` unless an allowed keypath is present.
-  allowedKeypaths.length === 0 && // Only try to upcast an Integer to `bigint`
-  Number.isInteger(value)) {
-    return BigInt(value);
-  } else {
-    return value;
-  }
-}
-function patchResponseForSolanaLabsRpc(rawResponse, methodName) {
-  const allowedKeypaths = methodName ? ALLOWED_NUMERIC_KEYPATHS[methodName] : void 0;
-  return visitNode2(rawResponse, allowedKeypaths ?? []);
-}
-
-// src/rpc-methods/index.ts
-function createSolanaRpcApi(config) {
+// ../rpc-transport/dist/index.browser.js
+function createJsonRpcApi(config) {
   return new Proxy({}, {
@@ -180,11 +14,8 @@ defineProperty() {
       return function(...rawParams) {
-        const handleIntegerOverflow = config?.onIntegerOverflow;
-        const params = patchParamsForSolanaLabsRpc(
-          rawParams,
-          handleIntegerOverflow ? (keyPath, value) => handleIntegerOverflow(methodName, keyPath, value) : void 0
-        );
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, methodName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
         return {
           methodName,
           params,
-          responseProcessor: (rawResponse) => patchResponseForSolanaLabsRpc(rawResponse, methodName)
+          responseTransformer
         };
@@ -195,49 +26,669 @@ };
 }
+function createJsonRpcSubscriptionsApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const notificationName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, notificationName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        const subscribeMethodName = config?.subscribeNotificationNameTransformer ? config?.subscribeNotificationNameTransformer(notificationName) : notificationName;
+        const unsubscribeMethodName = config?.unsubscribeNotificationNameTransformer ? config?.unsubscribeNotificationNameTransformer(notificationName) : notificationName;
+        return {
+          params,
+          responseTransformer,
+          subscribeMethodName,
+          unsubscribeMethodName
+        };
+      };
+    }
+  });
+}
 
-// src/stringified-bigint.ts
-function assertIsStringifiedBigInt(putativeBigInt) {
-  try {
-    BigInt(putativeBigInt);
-  } catch (e) {
-    throw new Error(`\`${putativeBigInt}\` cannot be parsed as a BigInt`, {
-      cause: e
-    });
-  }
-}
-function assertIsTransactionSignature(putativeTransactionSignature) {
-  try {
+// src/default-commitment.ts
+function applyDefaultCommitment({
+  commitmentPropertyName,
+  params,
+  optionsObjectPositionInParams,
+  overrideCommitment
+}) {
+  const paramInTargetPosition = params[optionsObjectPositionInParams];
+  if (
+    // There's no config.
+    paramInTargetPosition === void 0 || // There is a config object.
+    paramInTargetPosition && typeof paramInTargetPosition === "object" && !Array.isArray(paramInTargetPosition)
+  ) {
     if (
-      // Lowest value (64 bytes of zeroes)
-      putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-      putativeTransactionSignature.length > 88
+      // The config object already has a commitment set.
+      paramInTargetPosition && commitmentPropertyName in paramInTargetPosition
     ) {
-      throw new Error("Expected input string to decode to a byte array of length 64.");
+      if (!paramInTargetPosition[commitmentPropertyName] || paramInTargetPosition[commitmentPropertyName] === "finalized") {
+        const nextParams = [...params];
+        const {
+          [commitmentPropertyName]: _,
+          // eslint-disable-line @typescript-eslint/no-unused-vars
+          ...rest
+        } = paramInTargetPosition;
+        if (Object.keys(rest).length > 0) {
+          nextParams[optionsObjectPositionInParams] = rest;
+        } else {
+          if (optionsObjectPositionInParams === nextParams.length - 1) {
+            nextParams.length--;
+          } else {
+            nextParams[optionsObjectPositionInParams] = void 0;
+          }
+        }
+        return nextParams;
+      }
+    } else if (overrideCommitment !== "finalized") {
+      const nextParams = [...params];
+      nextParams[optionsObjectPositionInParams] = {
+        ...paramInTargetPosition,
+        [commitmentPropertyName]: overrideCommitment
+      };
+      return nextParams;
     }
-    const bytes = base58.serialize(putativeTransactionSignature);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 64) {
-      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeTransactionSignature}\` is not a transaction signature`, {
-      cause: e
-    });
   }
+  return params;
 }
 
-// src/unix-timestamp.ts
-function assertIsUnixTimestamp(putativeTimestamp) {
-  try {
-    if (putativeTimestamp > 864e13 || putativeTimestamp < -864e13) {
-      throw new Error("Expected input number to be in the range [-8.64e15, 8.64e15]");
+// src/params-patcher-bigint-downcast.ts
+function downcastNodeToNumberIfBigint(value) {
+  return typeof value === "bigint" ? (
+    // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana
+    // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely
+    // downcasting `bigints` to `numbers`.
+    Number(value)
+  ) : value;
+}
+
+// src/params-patcher-integer-overflow.ts
+function getIntegerOverflowNodeVisitor(onIntegerOverflow) {
+  return (value, { keyPath }) => {
+    if (typeof value === "bigint") {
+      if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {
+        onIntegerOverflow(keyPath, value);
+      }
     }
-  } catch (e) {
-    throw new Error(`\`${putativeTimestamp}\` is not a timestamp`, {
-      cause: e
+    return value;
+  };
+}
+
+// src/params-patcher-options-object-position-config.ts
+var OPTIONS_OBJECT_POSITION_BY_METHOD = {
+  accountNotifications: 1,
+  blockNotifications: 1,
+  getAccountInfo: 1,
+  getBalance: 1,
+  getBlock: 1,
+  getBlockHeight: 0,
+  getBlockProduction: 0,
+  getBlocks: 2,
+  getBlocksWithLimit: 2,
+  getConfirmedBlock: 1,
+  getConfirmedBlocks: 1,
+  getConfirmedBlocksWithLimit: 2,
+  getConfirmedSignaturesForAddress2: 1,
+  getConfirmedTransaction: 1,
+  getEpochInfo: 0,
+  getFeeCalculatorForBlockhash: 1,
+  getFeeForMessage: 1,
+  getFees: 1,
+  getInflationGovernor: 0,
+  getInflationReward: 1,
+  getLargestAccounts: 0,
+  getLatestBlockhash: 0,
+  getLeaderSchedule: 1,
+  getMinimumBalanceForRentExemption: 1,
+  getMultipleAccounts: 1,
+  getProgramAccounts: 1,
+  getRecentBlockhash: 1,
+  getSignaturesForAddress: 1,
+  getSlot: 0,
+  getSlotLeader: 0,
+  getStakeActivation: 1,
+  getStakeMinimumDelegation: 0,
+  getSupply: 0,
+  getTokenAccountBalance: 1,
+  getTokenAccountsByDelegate: 2,
+  getTokenAccountsByOwner: 2,
+  getTokenLargestAccounts: 1,
+  getTokenSupply: 1,
+  getTransaction: 1,
+  getTransactionCount: 0,
+  getVoteAccounts: 0,
+  isBlockhashValid: 1,
+  logsNotifications: 1,
+  programNotifications: 1,
+  requestAirdrop: 2,
+  sendTransaction: 1,
+  signatureNotifications: 1,
+  simulateTransaction: 1
+};
+
+// src/tree-traversal.ts
+var KEYPATH_WILDCARD = {};
+function getTreeWalker(visitors) {
+  return function traverse(node, state) {
+    if (Array.isArray(node)) {
+      return node.map((element, ii) => {
+        const nextState = {
+          ...state,
+          keyPath: [...state.keyPath, ii]
+        };
+        return traverse(element, nextState);
+      });
+    } else if (typeof node === "object" && node !== null) {
+      const out = {};
+      for (const propName in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, propName)) {
+          continue;
+        }
+        const nextState = {
+          ...state,
+          keyPath: [...state.keyPath, propName]
+        };
+        out[propName] = traverse(node[propName], nextState);
+      }
+      return out;
+    } else {
+      return visitors.reduce((acc, visitNode) => visitNode(acc, state), node);
+    }
+  };
+}
+
+// src/params-patcher.ts
+function getParamsPatcherForSolanaLabsRpc(config) {
+  const defaultCommitment = config?.defaultCommitment;
+  const handleIntegerOverflow = config?.onIntegerOverflow;
+  return (rawParams, methodName) => {
+    const traverse = getTreeWalker([
+      ...handleIntegerOverflow ? [getIntegerOverflowNodeVisitor((...args) => handleIntegerOverflow(methodName, ...args))] : [],
+      downcastNodeToNumberIfBigint
+    ]);
+    const initialState = {
+      keyPath: []
+    };
+    const patchedParams = traverse(rawParams, initialState);
+    if (!Array.isArray(patchedParams)) {
+      return patchedParams;
+    }
+    const optionsObjectPositionInParams = OPTIONS_OBJECT_POSITION_BY_METHOD[methodName];
+    if (optionsObjectPositionInParams == null) {
+      return patchedParams;
+    }
+    return applyDefaultCommitment({
+      commitmentPropertyName: methodName === "sendTransaction" ? "preflightCommitment" : "commitment",
+      optionsObjectPositionInParams,
+      overrideCommitment: defaultCommitment,
+      params: patchedParams
     });
+  };
+}
+
+// src/response-patcher-allowed-numeric-values.ts
+var jsonParsedTokenAccountsConfigs = [
+  // parsed Token/Token22 token account
+  ["data", "parsed", "info", "tokenAmount", "decimals"],
+  ["data", "parsed", "info", "tokenAmount", "uiAmount"],
+  ["data", "parsed", "info", "rentExemptReserve", "decimals"],
+  ["data", "parsed", "info", "rentExemptReserve", "uiAmount"],
+  ["data", "parsed", "info", "delegatedAmount", "decimals"],
+  ["data", "parsed", "info", "delegatedAmount", "uiAmount"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "olderTransferFee", "transferFeeBasisPoints"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "newerTransferFee", "transferFeeBasisPoints"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "preUpdateAverageRate"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "currentRate"]
+];
+var jsonParsedAccountsConfigs = [
+  ...jsonParsedTokenAccountsConfigs,
+  // parsed AddressTableLookup account
+  ["data", "parsed", "info", "lastExtendedSlotStartIndex"],
+  // parsed Config account
+  ["data", "parsed", "info", "slashPenalty"],
+  ["data", "parsed", "info", "warmupCooldownRate"],
+  // parsed Token/Token22 mint account
+  ["data", "parsed", "info", "decimals"],
+  // parsed Token/Token22 multisig account
+  ["data", "parsed", "info", "numRequiredSigners"],
+  ["data", "parsed", "info", "numValidSigners"],
+  // parsed Stake account
+  ["data", "parsed", "info", "stake", "delegation", "warmupCooldownRate"],
+  // parsed Sysvar rent account
+  ["data", "parsed", "info", "exemptionThreshold"],
+  ["data", "parsed", "info", "burnPercent"],
+  // parsed Vote account
+  ["data", "parsed", "info", "commission"],
+  ["data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
+];
+var memoizedNotificationKeypaths;
+var memoizedResponseKeypaths;
+function getAllowedNumericKeypathsForNotification() {
+  if (!memoizedNotificationKeypaths) {
+    memoizedNotificationKeypaths = {
+      accountNotifications: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+      blockNotifications: [
+        ["value", "block", "blockTime"],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "accountIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "accountIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["value", "block", "transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "index"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numReadonlySignedAccounts"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numReadonlyUnsignedAccounts"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numRequiredSignatures"
+        ],
+        ["value", "block", "rewards", KEYPATH_WILDCARD, "commission"]
+      ],
+      programNotifications: jsonParsedAccountsConfigs.flatMap((c) => [
+        ["value", KEYPATH_WILDCARD, "account", ...c],
+        [KEYPATH_WILDCARD, "account", ...c]
+      ])
+    };
   }
+  return memoizedNotificationKeypaths;
 }
+function getAllowedNumericKeypathsForResponse() {
+  if (!memoizedResponseKeypaths) {
+    memoizedResponseKeypaths = {
+      getAccountInfo: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+      getBlock: [
+        ["blockTime"],
+        ["transactions", KEYPATH_WILDCARD, "meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["transactions", KEYPATH_WILDCARD, "meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        ["transactions", KEYPATH_WILDCARD, "meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numReadonlySignedAccounts"],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numReadonlyUnsignedAccounts"],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numRequiredSignatures"],
+        ["rewards", KEYPATH_WILDCARD, "commission"]
+      ],
+      getBlockTime: [[]],
+      getClusterNodes: [
+        [KEYPATH_WILDCARD, "featureSet"],
+        [KEYPATH_WILDCARD, "shredVersion"]
+      ],
+      getInflationGovernor: [["initial"], ["foundation"], ["foundationTerm"], ["taper"], ["terminal"]],
+      getInflationRate: [["foundation"], ["total"], ["validator"]],
+      getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
+      getMultipleAccounts: jsonParsedAccountsConfigs.map((c) => ["value", KEYPATH_WILDCARD, ...c]),
+      getProgramAccounts: jsonParsedAccountsConfigs.flatMap((c) => [
+        ["value", KEYPATH_WILDCARD, "account", ...c],
+        [KEYPATH_WILDCARD, "account", ...c]
+      ]),
+      getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
+      getTokenAccountBalance: [
+        ["value", "decimals"],
+        ["value", "uiAmount"]
+      ],
+      getTokenAccountsByDelegate: jsonParsedTokenAccountsConfigs.map((c) => [
+        "value",
+        KEYPATH_WILDCARD,
+        "account",
+        ...c
+      ]),
+      getTokenAccountsByOwner: jsonParsedTokenAccountsConfigs.map((c) => [
+        "value",
+        KEYPATH_WILDCARD,
+        "account",
+        ...c
+      ]),
+      getTokenLargestAccounts: [
+        ["value", KEYPATH_WILDCARD, "decimals"],
+        ["value", KEYPATH_WILDCARD, "uiAmount"]
+      ],
+      getTokenSupply: [
+        ["value", "decimals"],
+        ["value", "uiAmount"]
+      ],
+      getTransaction: [
+        ["meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        ["meta", "preTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+        ["meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        ["meta", "postTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+        ["meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        ["meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
+        ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "programIdIndex"],
+        [
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        ["transaction", "message", "instructions", KEYPATH_WILDCARD, "programIdIndex"],
+        ["transaction", "message", "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
+        ["transaction", "message", "header", "numReadonlySignedAccounts"],
+        ["transaction", "message", "header", "numReadonlyUnsignedAccounts"],
+        ["transaction", "message", "header", "numRequiredSignatures"]
+      ],
+      getVersion: [["feature-set"]],
+      getVoteAccounts: [
+        ["current", KEYPATH_WILDCARD, "commission"],
+        ["delinquent", KEYPATH_WILDCARD, "commission"]
+      ],
+      simulateTransaction: jsonParsedAccountsConfigs.map((c) => ["value", "accounts", KEYPATH_WILDCARD, ...c])
+    };
+  }
+  return memoizedResponseKeypaths;
+}
 
-export { assertIsBlockhash, assertIsStringifiedBigInt, assertIsTransactionSignature, assertIsUnixTimestamp, createSolanaRpcApi };
+// src/response-patcher-bigint-upcast.ts
+function keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths) {
+  return allowedNumericKeyPaths.some((prohibitedKeyPath) => {
+    if (prohibitedKeyPath.length !== keyPath.length) {
+      return false;
+    }
+    for (let ii = keyPath.length - 1; ii >= 0; ii--) {
+      const keyPathPart = keyPath[ii];
+      const prohibitedKeyPathPart = prohibitedKeyPath[ii];
+      if (prohibitedKeyPathPart !== keyPathPart && (prohibitedKeyPathPart !== KEYPATH_WILDCARD || typeof keyPathPart !== "number")) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function getBigIntUpcastVisitor(allowedNumericKeyPaths) {
+  return function upcastNodeToBigIntIfNumber(value, { keyPath }) {
+    if (typeof value === "number" && Number.isInteger(value) && !keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths)) {
+      return BigInt(value);
+    } else {
+      return value;
+    }
+  };
+}
+
+// src/response-patcher.ts
+function patchResponseForSolanaLabsRpc(rawResponse, methodName) {
+  const allowedNumericKeyPaths = methodName ? getAllowedNumericKeypathsForResponse()[methodName] : void 0;
+  const traverse = getTreeWalker([getBigIntUpcastVisitor(allowedNumericKeyPaths ?? [])]);
+  const initialState = {
+    keyPath: []
+  };
+  return traverse(rawResponse, initialState);
+}
+function patchResponseForSolanaLabsRpcSubscriptions(rawResponse, notificationName) {
+  const allowedNumericKeyPaths = notificationName ? getAllowedNumericKeypathsForNotification()[notificationName] : void 0;
+  const traverse = getTreeWalker([getBigIntUpcastVisitor(allowedNumericKeyPaths ?? [])]);
+  const initialState = {
+    keyPath: []
+  };
+  return traverse(rawResponse, initialState);
+}
+
+// src/rpc-methods/index.ts
+function createSolanaRpcApi(config) {
+  return createJsonRpcApi({
+    parametersTransformer: getParamsPatcherForSolanaLabsRpc(config),
+    responseTransformer: patchResponseForSolanaLabsRpc
+  });
+}
+
+// src/rpc-subscriptions/index.ts
+function createSolanaRpcSubscriptionsApi_INTERNAL(config) {
+  return createJsonRpcSubscriptionsApi({
+    parametersTransformer: getParamsPatcherForSolanaLabsRpc(config),
+    responseTransformer: patchResponseForSolanaLabsRpcSubscriptions,
+    subscribeNotificationNameTransformer: (notificationName) => notificationName.replace(/Notifications$/, "Subscribe"),
+    unsubscribeNotificationNameTransformer: (notificationName) => notificationName.replace(/Notifications$/, "Unsubscribe")
+  });
+}
+function createSolanaRpcSubscriptionsApi(config) {
+  return createSolanaRpcSubscriptionsApi_INTERNAL(config);
+}
+function createSolanaRpcSubscriptionsApi_UNSTABLE(config) {
+  return createSolanaRpcSubscriptionsApi_INTERNAL(config);
+}
+
+export { createSolanaRpcApi, createSolanaRpcSubscriptionsApi, createSolanaRpcSubscriptionsApi_INTERNAL, createSolanaRpcSubscriptionsApi_UNSTABLE };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map

dist/index.node.js

@@ -1,169 +0,5 @@
-import { base58 } from '@metaplex-foundation/umi-serializers-encodings';
+import 'ws';
 
-// src/blockhash.ts
-function assertIsBlockhash(putativeBlockhash) {
-  try {
-    if (
-      // Lowest value (32 bytes of zeroes)
-      putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
-      putativeBlockhash.length > 44
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 32.");
-    }
-    const bytes = base58.serialize(putativeBlockhash);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-      cause: e
-    });
-  }
-}
-
-// src/params-patcher.ts
-function visitNode(value, keyPath, onIntegerOverflow) {
-  if (Array.isArray(value)) {
-    return value.map(
-      (element, ii) => visitNode(element, [...keyPath, ii], onIntegerOverflow)
-    );
-  } else if (typeof value === "object" && value !== null) {
-    const out = {};
-    for (const propName in value) {
-      if (Object.prototype.hasOwnProperty.call(value, propName)) {
-        out[propName] = visitNode(value[propName], [...keyPath, propName], onIntegerOverflow);
-      }
-    }
-    return out;
-  } else if (typeof value === "bigint") {
-    if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {
-      onIntegerOverflow(keyPath, value);
-    }
-    return Number(value);
-  } else {
-    return value;
-  }
-}
-function patchParamsForSolanaLabsRpc(params, onIntegerOverflow) {
-  return visitNode(params, [], onIntegerOverflow);
-}
-
-// src/response-patcher-types.ts
-var KEYPATH_WILDCARD = {};
-
-// src/response-patcher-allowed-numeric-values.ts
-var ALLOWED_NUMERIC_KEYPATHS = {
-  getAccountInfo: [
-    // parsed AddressTableLookup account
-    ["value", "data", "parsed", "info", "lastExtendedSlotStartIndex"],
-    // parsed Config account
-    ["value", "data", "parsed", "info", "slashPenalty"],
-    ["value", "data", "parsed", "info", "warmupCooldownRate"],
-    // parsed Token/Token22 token account
-    ["value", "data", "parsed", "info", "tokenAmount", "decimals"],
-    ["value", "data", "parsed", "info", "tokenAmount", "uiAmount"],
-    ["value", "data", "parsed", "info", "rentExemptReserve", "decimals"],
-    ["value", "data", "parsed", "info", "delegatedAmount", "decimals"],
-    [
-      "value",
-      "data",
-      "parsed",
-      "info",
-      "extensions",
-      KEYPATH_WILDCARD,
-      "state",
-      "olderTransferFee",
-      "transferFeeBasisPoints"
-    ],
-    [
-      "value",
-      "data",
-      "parsed",
-      "info",
-      "extensions",
-      KEYPATH_WILDCARD,
-      "state",
-      "newerTransferFee",
-      "transferFeeBasisPoints"
-    ],
-    ["value", "data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "preUpdateAverageRate"],
-    ["value", "data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "currentRate"],
-    // parsed Token/Token22 mint account
-    ["value", "data", "parsed", "info", "decimals"],
-    // parsed Token/Token22 multisig account
-    ["value", "data", "parsed", "info", "numRequiredSigners"],
-    ["value", "data", "parsed", "info", "numValidSigners"],
-    // parsed Stake account
-    ["value", "data", "parsed", "info", "stake", "delegation", "warmupCooldownRate"],
-    // parsed Sysvar rent account
-    ["value", "data", "parsed", "info", "exemptionThreshold"],
-    ["value", "data", "parsed", "info", "burnPercent"],
-    // parsed Vote account
-    ["value", "data", "parsed", "info", "commission"],
-    ["value", "data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
-  ],
-  getBlockTime: [[]],
-  getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
-  getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
-  getTokenLargestAccounts: [
-    ["value", KEYPATH_WILDCARD, "decimals"],
-    ["value", KEYPATH_WILDCARD, "uiAmount"]
-  ],
-  getTransaction: [
-    ["meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
-    ["meta", "preTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
-    ["meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
-    ["meta", "postTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
-    ["meta", "rewards", KEYPATH_WILDCARD, "commission"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "programIdIndex"],
-    ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
-    ["transaction", "message", "addressTableLookups", KEYPATH_WILDCARD, "writableIndexes", KEYPATH_WILDCARD],
-    ["transaction", "message", "addressTableLookups", KEYPATH_WILDCARD, "readonlyIndexes", KEYPATH_WILDCARD],
-    ["transaction", "message", "instructions", KEYPATH_WILDCARD, "programIdIndex"],
-    ["transaction", "message", "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
-    ["transaction", "message", "header", "numReadonlySignedAccounts"],
-    ["transaction", "message", "header", "numReadonlyUnsignedAccounts"],
-    ["transaction", "message", "header", "numRequiredSignatures"]
-  ],
-  getVoteAccounts: [
-    ["current", KEYPATH_WILDCARD, "commission"],
-    ["delinquent", KEYPATH_WILDCARD, "commission"]
-  ]
-};
-
-// src/response-patcher.ts
-function getNextAllowedKeypaths(keyPaths, property) {
-  return keyPaths.filter((keyPath) => keyPath[0] === KEYPATH_WILDCARD && typeof property === "number" || keyPath[0] === property).map((keyPath) => keyPath.slice(1));
-}
-function visitNode2(value, allowedKeypaths) {
-  if (Array.isArray(value)) {
-    return value.map((element, ii) => {
-      const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, ii);
-      return visitNode2(element, nextAllowedKeypaths);
-    });
-  } else if (typeof value === "object" && value !== null) {
-    const out = {};
-    for (const [propName, innerValue] of Object.entries(value)) {
-      const nextAllowedKeypaths = getNextAllowedKeypaths(allowedKeypaths, propName);
-      out[propName] = visitNode2(innerValue, nextAllowedKeypaths);
-    }
-    return out;
-  } else if (typeof value === "number" && // The presence of an allowed keypath on the route to this value implies it's allowlisted;
-  // Upcast the value to `bigint` unless an allowed keypath is present.
-  allowedKeypaths.length === 0 && // Only try to upcast an Integer to `bigint`
-  Number.isInteger(value)) {
-    return BigInt(value);
-  } else {
-    return value;
-  }
-}
-function patchResponseForSolanaLabsRpc(rawResponse, methodName) {
-  const allowedKeypaths = methodName ? ALLOWED_NUMERIC_KEYPATHS[methodName] : void 0;
-  return visitNode2(rawResponse, allowedKeypaths ?? []);
-}
-
-// src/rpc-methods/index.ts
-function createSolanaRpcApi(config) {
+// ../rpc-transport/dist/index.node.js
+function createJsonRpcApi(config) {
   return new Proxy({}, {
@@ -180,11 +16,8 @@ defineProperty() {
       return function(...rawParams) {
-        const handleIntegerOverflow = config?.onIntegerOverflow;
-        const params = patchParamsForSolanaLabsRpc(
-          rawParams,
-          handleIntegerOverflow ? (keyPath, value) => handleIntegerOverflow(methodName, keyPath, value) : void 0
-        );
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, methodName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
         return {
           methodName,
           params,
-          responseProcessor: (rawResponse) => patchResponseForSolanaLabsRpc(rawResponse, methodName)
+          responseTransformer
         };
@@ -195,49 +28,669 @@ };
 }
+function createJsonRpcSubscriptionsApi(config) {
+  return new Proxy({}, {
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    get(...args) {
+      const [_, p] = args;
+      const notificationName = p.toString();
+      return function(...rawParams) {
+        const params = config?.parametersTransformer ? config?.parametersTransformer(rawParams, notificationName) : rawParams;
+        const responseTransformer = config?.responseTransformer ? config?.responseTransformer : (rawResponse) => rawResponse;
+        const subscribeMethodName = config?.subscribeNotificationNameTransformer ? config?.subscribeNotificationNameTransformer(notificationName) : notificationName;
+        const unsubscribeMethodName = config?.unsubscribeNotificationNameTransformer ? config?.unsubscribeNotificationNameTransformer(notificationName) : notificationName;
+        return {
+          params,
+          responseTransformer,
+          subscribeMethodName,
+          unsubscribeMethodName
+        };
+      };
+    }
+  });
+}
 
-// src/stringified-bigint.ts
-function assertIsStringifiedBigInt(putativeBigInt) {
-  try {
-    BigInt(putativeBigInt);
-  } catch (e) {
-    throw new Error(`\`${putativeBigInt}\` cannot be parsed as a BigInt`, {
-      cause: e
-    });
-  }
-}
-function assertIsTransactionSignature(putativeTransactionSignature) {
-  try {
+// src/default-commitment.ts
+function applyDefaultCommitment({
+  commitmentPropertyName,
+  params,
+  optionsObjectPositionInParams,
+  overrideCommitment
+}) {
+  const paramInTargetPosition = params[optionsObjectPositionInParams];
+  if (
+    // There's no config.
+    paramInTargetPosition === void 0 || // There is a config object.
+    paramInTargetPosition && typeof paramInTargetPosition === "object" && !Array.isArray(paramInTargetPosition)
+  ) {
     if (
-      // Lowest value (64 bytes of zeroes)
-      putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-      putativeTransactionSignature.length > 88
+      // The config object already has a commitment set.
+      paramInTargetPosition && commitmentPropertyName in paramInTargetPosition
     ) {
-      throw new Error("Expected input string to decode to a byte array of length 64.");
+      if (!paramInTargetPosition[commitmentPropertyName] || paramInTargetPosition[commitmentPropertyName] === "finalized") {
+        const nextParams = [...params];
+        const {
+          [commitmentPropertyName]: _,
+          // eslint-disable-line @typescript-eslint/no-unused-vars
+          ...rest
+        } = paramInTargetPosition;
+        if (Object.keys(rest).length > 0) {
+          nextParams[optionsObjectPositionInParams] = rest;
+        } else {
+          if (optionsObjectPositionInParams === nextParams.length - 1) {
+            nextParams.length--;
+          } else {
+            nextParams[optionsObjectPositionInParams] = void 0;
+          }
+        }
+        return nextParams;
+      }
+    } else if (overrideCommitment !== "finalized") {
+      const nextParams = [...params];
+      nextParams[optionsObjectPositionInParams] = {
+        ...paramInTargetPosition,
+        [commitmentPropertyName]: overrideCommitment
+      };
+      return nextParams;
     }
-    const bytes = base58.serialize(putativeTransactionSignature);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 64) {
-      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeTransactionSignature}\` is not a transaction signature`, {
-      cause: e
-    });
   }
+  return params;
 }
 
-// src/unix-timestamp.ts
-function assertIsUnixTimestamp(putativeTimestamp) {
-  try {
-    if (putativeTimestamp > 864e13 || putativeTimestamp < -864e13) {
-      throw new Error("Expected input number to be in the range [-8.64e15, 8.64e15]");
+// src/params-patcher-bigint-downcast.ts
+function downcastNodeToNumberIfBigint(value) {
+  return typeof value === "bigint" ? (
+    // FIXME(solana-labs/solana/issues/30341) Create a data type to represent u64 in the Solana
+    // JSON RPC implementation so that we can throw away this entire patcher instead of unsafely
+    // downcasting `bigints` to `numbers`.
+    Number(value)
+  ) : value;
+}
+
+// src/params-patcher-integer-overflow.ts
+function getIntegerOverflowNodeVisitor(onIntegerOverflow) {
+  return (value, { keyPath }) => {
+    if (typeof value === "bigint") {
+      if (onIntegerOverflow && (value > Number.MAX_SAFE_INTEGER || value < -Number.MAX_SAFE_INTEGER)) {
+        onIntegerOverflow(keyPath, value);
+      }
     }
-  } catch (e) {
-    throw new Error(`\`${putativeTimestamp}\` is not a timestamp`, {
-      cause: e
+    return value;
+  };
+}
+
+// src/params-patcher-options-object-position-config.ts
+var OPTIONS_OBJECT_POSITION_BY_METHOD = {
+  accountNotifications: 1,
+  blockNotifications: 1,
+  getAccountInfo: 1,
+  getBalance: 1,
+  getBlock: 1,
+  getBlockHeight: 0,
+  getBlockProduction: 0,
+  getBlocks: 2,
+  getBlocksWithLimit: 2,
+  getConfirmedBlock: 1,
+  getConfirmedBlocks: 1,
+  getConfirmedBlocksWithLimit: 2,
+  getConfirmedSignaturesForAddress2: 1,
+  getConfirmedTransaction: 1,
+  getEpochInfo: 0,
+  getFeeCalculatorForBlockhash: 1,
+  getFeeForMessage: 1,
+  getFees: 1,
+  getInflationGovernor: 0,
+  getInflationReward: 1,
+  getLargestAccounts: 0,
+  getLatestBlockhash: 0,
+  getLeaderSchedule: 1,
+  getMinimumBalanceForRentExemption: 1,
+  getMultipleAccounts: 1,
+  getProgramAccounts: 1,
+  getRecentBlockhash: 1,
+  getSignaturesForAddress: 1,
+  getSlot: 0,
+  getSlotLeader: 0,
+  getStakeActivation: 1,
+  getStakeMinimumDelegation: 0,
+  getSupply: 0,
+  getTokenAccountBalance: 1,
+  getTokenAccountsByDelegate: 2,
+  getTokenAccountsByOwner: 2,
+  getTokenLargestAccounts: 1,
+  getTokenSupply: 1,
+  getTransaction: 1,
+  getTransactionCount: 0,
+  getVoteAccounts: 0,
+  isBlockhashValid: 1,
+  logsNotifications: 1,
+  programNotifications: 1,
+  requestAirdrop: 2,
+  sendTransaction: 1,
+  signatureNotifications: 1,
+  simulateTransaction: 1
+};
+
+// src/tree-traversal.ts
+var KEYPATH_WILDCARD = {};
+function getTreeWalker(visitors) {
+  return function traverse(node, state) {
+    if (Array.isArray(node)) {
+      return node.map((element, ii) => {
+        const nextState = {
+          ...state,
+          keyPath: [...state.keyPath, ii]
+        };
+        return traverse(element, nextState);
+      });
+    } else if (typeof node === "object" && node !== null) {
+      const out = {};
+      for (const propName in node) {
+        if (!Object.prototype.hasOwnProperty.call(node, propName)) {
+          continue;
+        }
+        const nextState = {
+          ...state,
+          keyPath: [...state.keyPath, propName]
+        };
+        out[propName] = traverse(node[propName], nextState);
+      }
+      return out;
+    } else {
+      return visitors.reduce((acc, visitNode) => visitNode(acc, state), node);
+    }
+  };
+}
+
+// src/params-patcher.ts
+function getParamsPatcherForSolanaLabsRpc(config) {
+  const defaultCommitment = config?.defaultCommitment;
+  const handleIntegerOverflow = config?.onIntegerOverflow;
+  return (rawParams, methodName) => {
+    const traverse = getTreeWalker([
+      ...handleIntegerOverflow ? [getIntegerOverflowNodeVisitor((...args) => handleIntegerOverflow(methodName, ...args))] : [],
+      downcastNodeToNumberIfBigint
+    ]);
+    const initialState = {
+      keyPath: []
+    };
+    const patchedParams = traverse(rawParams, initialState);
+    if (!Array.isArray(patchedParams)) {
+      return patchedParams;
+    }
+    const optionsObjectPositionInParams = OPTIONS_OBJECT_POSITION_BY_METHOD[methodName];
+    if (optionsObjectPositionInParams == null) {
+      return patchedParams;
+    }
+    return applyDefaultCommitment({
+      commitmentPropertyName: methodName === "sendTransaction" ? "preflightCommitment" : "commitment",
+      optionsObjectPositionInParams,
+      overrideCommitment: defaultCommitment,
+      params: patchedParams
     });
+  };
+}
+
+// src/response-patcher-allowed-numeric-values.ts
+var jsonParsedTokenAccountsConfigs = [
+  // parsed Token/Token22 token account
+  ["data", "parsed", "info", "tokenAmount", "decimals"],
+  ["data", "parsed", "info", "tokenAmount", "uiAmount"],
+  ["data", "parsed", "info", "rentExemptReserve", "decimals"],
+  ["data", "parsed", "info", "rentExemptReserve", "uiAmount"],
+  ["data", "parsed", "info", "delegatedAmount", "decimals"],
+  ["data", "parsed", "info", "delegatedAmount", "uiAmount"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "olderTransferFee", "transferFeeBasisPoints"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "newerTransferFee", "transferFeeBasisPoints"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "preUpdateAverageRate"],
+  ["data", "parsed", "info", "extensions", KEYPATH_WILDCARD, "state", "currentRate"]
+];
+var jsonParsedAccountsConfigs = [
+  ...jsonParsedTokenAccountsConfigs,
+  // parsed AddressTableLookup account
+  ["data", "parsed", "info", "lastExtendedSlotStartIndex"],
+  // parsed Config account
+  ["data", "parsed", "info", "slashPenalty"],
+  ["data", "parsed", "info", "warmupCooldownRate"],
+  // parsed Token/Token22 mint account
+  ["data", "parsed", "info", "decimals"],
+  // parsed Token/Token22 multisig account
+  ["data", "parsed", "info", "numRequiredSigners"],
+  ["data", "parsed", "info", "numValidSigners"],
+  // parsed Stake account
+  ["data", "parsed", "info", "stake", "delegation", "warmupCooldownRate"],
+  // parsed Sysvar rent account
+  ["data", "parsed", "info", "exemptionThreshold"],
+  ["data", "parsed", "info", "burnPercent"],
+  // parsed Vote account
+  ["data", "parsed", "info", "commission"],
+  ["data", "parsed", "info", "votes", KEYPATH_WILDCARD, "confirmationCount"]
+];
+var memoizedNotificationKeypaths;
+var memoizedResponseKeypaths;
+function getAllowedNumericKeypathsForNotification() {
+  if (!memoizedNotificationKeypaths) {
+    memoizedNotificationKeypaths = {
+      accountNotifications: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+      blockNotifications: [
+        ["value", "block", "blockTime"],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "accountIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "accountIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["value", "block", "transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "index"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numReadonlySignedAccounts"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numReadonlyUnsignedAccounts"
+        ],
+        [
+          "value",
+          "block",
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "header",
+          "numRequiredSignatures"
+        ],
+        ["value", "block", "rewards", KEYPATH_WILDCARD, "commission"]
+      ],
+      programNotifications: jsonParsedAccountsConfigs.flatMap((c) => [
+        ["value", KEYPATH_WILDCARD, "account", ...c],
+        [KEYPATH_WILDCARD, "account", ...c]
+      ])
+    };
   }
+  return memoizedNotificationKeypaths;
 }
+function getAllowedNumericKeypathsForResponse() {
+  if (!memoizedResponseKeypaths) {
+    memoizedResponseKeypaths = {
+      getAccountInfo: jsonParsedAccountsConfigs.map((c) => ["value", ...c]),
+      getBlock: [
+        ["blockTime"],
+        ["transactions", KEYPATH_WILDCARD, "meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "preTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["transactions", KEYPATH_WILDCARD, "meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "postTokenBalances",
+          KEYPATH_WILDCARD,
+          "uiTokenAmount",
+          "decimals"
+        ],
+        ["transactions", KEYPATH_WILDCARD, "meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        ["transactions", KEYPATH_WILDCARD, "meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "programIdIndex"
+        ],
+        [
+          "transactions",
+          KEYPATH_WILDCARD,
+          "transaction",
+          "message",
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numReadonlySignedAccounts"],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numReadonlyUnsignedAccounts"],
+        ["transactions", KEYPATH_WILDCARD, "transaction", "message", "header", "numRequiredSignatures"],
+        ["rewards", KEYPATH_WILDCARD, "commission"]
+      ],
+      getBlockTime: [[]],
+      getClusterNodes: [
+        [KEYPATH_WILDCARD, "featureSet"],
+        [KEYPATH_WILDCARD, "shredVersion"]
+      ],
+      getInflationGovernor: [["initial"], ["foundation"], ["foundationTerm"], ["taper"], ["terminal"]],
+      getInflationRate: [["foundation"], ["total"], ["validator"]],
+      getInflationReward: [[KEYPATH_WILDCARD, "commission"]],
+      getMultipleAccounts: jsonParsedAccountsConfigs.map((c) => ["value", KEYPATH_WILDCARD, ...c]),
+      getProgramAccounts: jsonParsedAccountsConfigs.flatMap((c) => [
+        ["value", KEYPATH_WILDCARD, "account", ...c],
+        [KEYPATH_WILDCARD, "account", ...c]
+      ]),
+      getRecentPerformanceSamples: [[KEYPATH_WILDCARD, "samplePeriodSecs"]],
+      getTokenAccountBalance: [
+        ["value", "decimals"],
+        ["value", "uiAmount"]
+      ],
+      getTokenAccountsByDelegate: jsonParsedTokenAccountsConfigs.map((c) => [
+        "value",
+        KEYPATH_WILDCARD,
+        "account",
+        ...c
+      ]),
+      getTokenAccountsByOwner: jsonParsedTokenAccountsConfigs.map((c) => [
+        "value",
+        KEYPATH_WILDCARD,
+        "account",
+        ...c
+      ]),
+      getTokenLargestAccounts: [
+        ["value", KEYPATH_WILDCARD, "decimals"],
+        ["value", KEYPATH_WILDCARD, "uiAmount"]
+      ],
+      getTokenSupply: [
+        ["value", "decimals"],
+        ["value", "uiAmount"]
+      ],
+      getTransaction: [
+        ["meta", "preTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        ["meta", "preTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+        ["meta", "postTokenBalances", KEYPATH_WILDCARD, "accountIndex"],
+        ["meta", "postTokenBalances", KEYPATH_WILDCARD, "uiTokenAmount", "decimals"],
+        ["meta", "rewards", KEYPATH_WILDCARD, "commission"],
+        ["meta", "innerInstructions", KEYPATH_WILDCARD, "index"],
+        ["meta", "innerInstructions", KEYPATH_WILDCARD, "instructions", KEYPATH_WILDCARD, "programIdIndex"],
+        [
+          "meta",
+          "innerInstructions",
+          KEYPATH_WILDCARD,
+          "instructions",
+          KEYPATH_WILDCARD,
+          "accounts",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "writableIndexes",
+          KEYPATH_WILDCARD
+        ],
+        [
+          "transaction",
+          "message",
+          "addressTableLookups",
+          KEYPATH_WILDCARD,
+          "readonlyIndexes",
+          KEYPATH_WILDCARD
+        ],
+        ["transaction", "message", "instructions", KEYPATH_WILDCARD, "programIdIndex"],
+        ["transaction", "message", "instructions", KEYPATH_WILDCARD, "accounts", KEYPATH_WILDCARD],
+        ["transaction", "message", "header", "numReadonlySignedAccounts"],
+        ["transaction", "message", "header", "numReadonlyUnsignedAccounts"],
+        ["transaction", "message", "header", "numRequiredSignatures"]
+      ],
+      getVersion: [["feature-set"]],
+      getVoteAccounts: [
+        ["current", KEYPATH_WILDCARD, "commission"],
+        ["delinquent", KEYPATH_WILDCARD, "commission"]
+      ],
+      simulateTransaction: jsonParsedAccountsConfigs.map((c) => ["value", "accounts", KEYPATH_WILDCARD, ...c])
+    };
+  }
+  return memoizedResponseKeypaths;
+}
 
-export { assertIsBlockhash, assertIsStringifiedBigInt, assertIsTransactionSignature, assertIsUnixTimestamp, createSolanaRpcApi };
+// src/response-patcher-bigint-upcast.ts
+function keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths) {
+  return allowedNumericKeyPaths.some((prohibitedKeyPath) => {
+    if (prohibitedKeyPath.length !== keyPath.length) {
+      return false;
+    }
+    for (let ii = keyPath.length - 1; ii >= 0; ii--) {
+      const keyPathPart = keyPath[ii];
+      const prohibitedKeyPathPart = prohibitedKeyPath[ii];
+      if (prohibitedKeyPathPart !== keyPathPart && (prohibitedKeyPathPart !== KEYPATH_WILDCARD || typeof keyPathPart !== "number")) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function getBigIntUpcastVisitor(allowedNumericKeyPaths) {
+  return function upcastNodeToBigIntIfNumber(value, { keyPath }) {
+    if (typeof value === "number" && Number.isInteger(value) && !keyPathIsAllowedToBeNumeric(keyPath, allowedNumericKeyPaths)) {
+      return BigInt(value);
+    } else {
+      return value;
+    }
+  };
+}
+
+// src/response-patcher.ts
+function patchResponseForSolanaLabsRpc(rawResponse, methodName) {
+  const allowedNumericKeyPaths = methodName ? getAllowedNumericKeypathsForResponse()[methodName] : void 0;
+  const traverse = getTreeWalker([getBigIntUpcastVisitor(allowedNumericKeyPaths ?? [])]);
+  const initialState = {
+    keyPath: []
+  };
+  return traverse(rawResponse, initialState);
+}
+function patchResponseForSolanaLabsRpcSubscriptions(rawResponse, notificationName) {
+  const allowedNumericKeyPaths = notificationName ? getAllowedNumericKeypathsForNotification()[notificationName] : void 0;
+  const traverse = getTreeWalker([getBigIntUpcastVisitor(allowedNumericKeyPaths ?? [])]);
+  const initialState = {
+    keyPath: []
+  };
+  return traverse(rawResponse, initialState);
+}
+
+// src/rpc-methods/index.ts
+function createSolanaRpcApi(config) {
+  return createJsonRpcApi({
+    parametersTransformer: getParamsPatcherForSolanaLabsRpc(config),
+    responseTransformer: patchResponseForSolanaLabsRpc
+  });
+}
+
+// src/rpc-subscriptions/index.ts
+function createSolanaRpcSubscriptionsApi_INTERNAL(config) {
+  return createJsonRpcSubscriptionsApi({
+    parametersTransformer: getParamsPatcherForSolanaLabsRpc(config),
+    responseTransformer: patchResponseForSolanaLabsRpcSubscriptions,
+    subscribeNotificationNameTransformer: (notificationName) => notificationName.replace(/Notifications$/, "Subscribe"),
+    unsubscribeNotificationNameTransformer: (notificationName) => notificationName.replace(/Notifications$/, "Unsubscribe")
+  });
+}
+function createSolanaRpcSubscriptionsApi(config) {
+  return createSolanaRpcSubscriptionsApi_INTERNAL(config);
+}
+function createSolanaRpcSubscriptionsApi_UNSTABLE(config) {
+  return createSolanaRpcSubscriptionsApi_INTERNAL(config);
+}
+
+export { createSolanaRpcApi, createSolanaRpcSubscriptionsApi, createSolanaRpcSubscriptionsApi_INTERNAL, createSolanaRpcSubscriptionsApi_UNSTABLE };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.node.js.map

dist/types/index.d.ts

@@ -1,6 +0,4 @@
-export * from './blockhash';
-export * from './rpc-methods';
-export * from './stringified-bigint';
-export * from './transaction-signature';
-export * from './unix-timestamp';
+export * from './rpc-methods/index.js';
+export * from './rpc-subscriptions/index.js';
+export * from './transaction-error.js';
 //# sourceMappingURL=index.d.ts.map

dist/types/params-patcher.d.ts

@@ -1,7 +0,8 @@
-type IntegerOverflowHandler = (keyPath: (number | string)[], value: bigint) => void;
-type Patched<T> = T extends object ? {
-    [Property in keyof T]: Patched<T[Property]>;
-} : T extends bigint ? number : T;
-export declare function patchParamsForSolanaLabsRpc<T>(params: T, onIntegerOverflow?: IntegerOverflowHandler): Patched<T>;
-export {};
+import { Commitment } from '@solana/rpc-types';
+import { KeyPath } from './tree-traversal.js';
+export type ParamsPatcherConfig = Readonly<{
+    defaultCommitment?: Commitment;
+    onIntegerOverflow?: (methodName: string, keyPath: KeyPath, value: bigint) => void;
+}>;
+export declare function getParamsPatcherForSolanaLabsRpc(config?: ParamsPatcherConfig): <T>(rawParams: T, methodName: string) => unknown;
 //# sourceMappingURL=params-patcher.d.ts.map

dist/types/response-patcher-allowed-numeric-values.d.ts

@@ -1,3 +0,6 @@
-import { KeyPath } from './response-patcher';
-import { createSolanaRpcApi } from './rpc-methods';
+import type { IRpcSubscriptionsApi } from '@solana/rpc-transport';
+import { createSolanaRpcApi } from './rpc-methods/index.js';
+import { SolanaRpcSubscriptions, SolanaRpcSubscriptionsUnstable } from './rpc-subscriptions/index.js';
+import { KeyPath } from './tree-traversal.js';
+type AllowedNumericKeypaths<TApi> = Partial<Record<keyof TApi, readonly KeyPath[]>>;
 /**
@@ -7,3 +10,9 @@ * These are keypaths at the end of which you will find a numeric value that should *not* be upcast
  */
-export declare const ALLOWED_NUMERIC_KEYPATHS: Partial<Record<keyof ReturnType<typeof createSolanaRpcApi>, readonly KeyPath[]>>;
+export declare function getAllowedNumericKeypathsForNotification(): AllowedNumericKeypaths<IRpcSubscriptionsApi<SolanaRpcSubscriptions & SolanaRpcSubscriptionsUnstable>>;
+/**
+ * These are keypaths at the end of which you will find a numeric value that should *not* be upcast
+ * to a `bigint`. These are values that are legitimately defined as `u8` or `usize` on the backend.
+ */
+export declare function getAllowedNumericKeypathsForResponse(): AllowedNumericKeypaths<ReturnType<typeof createSolanaRpcApi>>;
+export {};
 //# sourceMappingURL=response-patcher-allowed-numeric-values.d.ts.map

dist/types/response-patcher.d.ts

@@ -1,5 +0,5 @@
-import { KeyPathWildcard } from './response-patcher-types';
-import { createSolanaRpcApi } from './rpc-methods';
-export type KeyPath = ReadonlyArray<KeyPathWildcard | number | string | KeyPath>;
+import { createSolanaRpcApi } from './rpc-methods/index.js';
+import { createSolanaRpcSubscriptionsApi } from './rpc-subscriptions/index.js';
 export declare function patchResponseForSolanaLabsRpc<T>(rawResponse: unknown, methodName?: keyof ReturnType<typeof createSolanaRpcApi>): T;
+export declare function patchResponseForSolanaLabsRpcSubscriptions<T>(rawResponse: unknown, notificationName?: keyof ReturnType<typeof createSolanaRpcSubscriptionsApi>): T;
 //# sourceMappingURL=response-patcher.d.ts.map

dist/types/rpc-methods/common.d.ts

@@ -1,2 +0,4 @@
-export type Commitment = 'confirmed' | 'finalized' | 'processed';
+import { Address } from '@solana/addresses';
+import type { Base58EncodedBytes, Base58EncodedDataResponse, Base64EncodedDataResponse, Base64EncodedZStdCompressedDataResponse } from '@solana/rpc-types';
+import { LamportsUnsafeBeyond2Pow53Minus1, TokenAmount } from '@solana/rpc-types';
 export type DataSlice = Readonly<{
@@ -6,7 +8,9 @@ offset: number;
 }>;
-export type LamportsUnsafeBeyond2Pow53Minus1 = bigint & {
-    readonly __lamports: unique symbol;
+export type MicroLamportsUnsafeBeyond2Pow53Minus1 = bigint & {
+    readonly __brand: unique symbol;
 };
 export type Slot = U64UnsafeBeyond2Pow53Minus1;
 export type U64UnsafeBeyond2Pow53Minus1 = bigint;
+export type SignedLamportsAsI64Unsafe = bigint;
+export type F64UnsafeSeeDocumentation = number;
 export type RpcResponse<TValue> = Readonly<{
@@ -18,15 +22,59 @@ context: Readonly<{
 }>;
-export type TransactionVersion = 'legacy' | 0;
-export type Base58EncodedBytes = string & {
-    readonly __base58EncodedBytes: unique symbol;
-};
-export type Base64EncodedBytes = string & {
-    readonly __base64EncodedBytes: unique symbol;
-};
-export type Base64EncodedZStdCompressedBytes = string & {
-    readonly __base64EncodedZStdCompressedBytes: unique symbol;
-};
-export type Base58EncodedDataResponse = [Base58EncodedBytes, 'base58'];
-export type Base64EncodedDataResponse = [Base64EncodedBytes, 'base64'];
-export type Base64EncodedZStdCompressedDataResponse = [Base64EncodedZStdCompressedBytes, 'base64+zstd'];
+export type AccountInfoBase = Readonly<{
+    /** indicates if the account contains a program (and is strictly read-only) */
+    executable: boolean;
+    /** number of lamports assigned to this account */
+    lamports: LamportsUnsafeBeyond2Pow53Minus1;
+    /** pubkey of the program this account has been assigned to */
+    owner: Address;
+    /** the epoch at which this account will next owe rent */
+    rentEpoch: U64UnsafeBeyond2Pow53Minus1;
+}>;
+/** @deprecated */
+export type AccountInfoWithBase58Bytes = Readonly<{
+    data: Base58EncodedBytes;
+}>;
+/** @deprecated */
+export type AccountInfoWithBase58EncodedData = Readonly<{
+    data: Base58EncodedDataResponse;
+}>;
+export type AccountInfoWithBase64EncodedData = Readonly<{
+    data: Base64EncodedDataResponse;
+}>;
+export type AccountInfoWithBase64EncodedZStdCompressedData = Readonly<{
+    data: Base64EncodedZStdCompressedDataResponse;
+}>;
+export type AccountInfoWithJsonData = Readonly<{
+    data: Readonly<{
+        program: string;
+        parsed: {
+            info?: object;
+            type: string;
+        };
+        space: U64UnsafeBeyond2Pow53Minus1;
+    }> | Base64EncodedDataResponse;
+}>;
+export type AccountInfoWithPubkey<TAccount extends AccountInfoBase> = Readonly<{
+    account: TAccount;
+    pubkey: Address;
+}>;
+export type TokenBalance = Readonly<{
+    /** Index of the account in which the token balance is provided for. */
+    accountIndex: number;
+    /** Pubkey of the token's mint. */
+    mint: Address;
+    /** Pubkey of token balance's owner. */
+    owner?: Address;
+    /** Pubkey of the Token program that owns the account. */
+    programId?: Address;
+    uiTokenAmount: TokenAmount;
+}>;
+export type GetProgramAccountsMemcmpFilter = Readonly<{
+    offset: U64UnsafeBeyond2Pow53Minus1;
+    bytes: string;
+    encoding: 'base58' | 'base64';
+}>;
+export type GetProgramAccountsDatasizeFilter = Readonly<{
+    dataSize: U64UnsafeBeyond2Pow53Minus1;
+}>;
 //# sourceMappingURL=common.d.ts.map

dist/types/rpc-methods/getAccountInfo.d.ts

@@ -1,44 +0,9 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { Base58EncodedBytes, Base58EncodedDataResponse, Base64EncodedDataResponse, Base64EncodedZStdCompressedDataResponse, Commitment, DataSlice, LamportsUnsafeBeyond2Pow53Minus1, Slot, U64UnsafeBeyond2Pow53Minus1 } from './common';
-type GetAccountInfoApiResponseBase = Readonly<{
-    context: Readonly<{
-        slot: Slot;
-    }>;
-    value: Readonly<{
-        executable: boolean;
-        lamports: LamportsUnsafeBeyond2Pow53Minus1;
-        owner: Base58EncodedAddress;
-        rentEpoch: U64UnsafeBeyond2Pow53Minus1;
-        space: U64UnsafeBeyond2Pow53Minus1;
-    }> | null;
+import { Address } from '@solana/addresses';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment } from '@solana/rpc-types';
+import { AccountInfoBase, AccountInfoWithBase58Bytes, AccountInfoWithBase58EncodedData, AccountInfoWithBase64EncodedData, AccountInfoWithBase64EncodedZStdCompressedData, AccountInfoWithJsonData, DataSlice, RpcResponse, Slot } from './common.js';
+type GetAccountInfoApiResponseBase = RpcResponse<AccountInfoBase | null>;
+type NestInRpcResponseOrNull<T> = Readonly<{
+    value: T | null;
 }>;
-type GetAccountInfoApiResponseWithDefaultData = Readonly<{
-    value: Readonly<{
-        data: Base58EncodedBytes;
-    }> | null;
-}>;
-type GetAccountInfoApiResponseWithBase58EncodedData_DEPRECATED = Readonly<{
-    value: Readonly<{
-        data: Base58EncodedDataResponse;
-    }> | null;
-}>;
-type GetAccountInfoApiResponseWithBase64EncodedData = Readonly<{
-    value: Readonly<{
-        data: Base64EncodedDataResponse;
-    }> | null;
-}>;
-type GetAccountInfoApiResponseWithBase64EncodedZStdCompressedData = Readonly<{
-    value: Readonly<{
-        data: Base64EncodedZStdCompressedDataResponse;
-    }> | null;
-}>;
-type GetAccountInfoApiResponseWithJsonData = Readonly<{
-    value: Readonly<{
-        data: Readonly<{
-            program: string;
-            parsed: unknown;
-            space: U64UnsafeBeyond2Pow53Minus1;
-        }> | Base64EncodedDataResponse;
-    }> | null;
-}>;
 type GetAccountInfoApiCommonConfig = Readonly<{
@@ -51,21 +16,21 @@ commitment?: Commitment;
 }>;
-export interface GetAccountInfoApi {
+export interface GetAccountInfoApi extends IRpcApiMethods {
     /**
      * Returns all information associated with the account of provided public key
      */
-    getAccountInfo(address: Base58EncodedAddress, config: GetAccountInfoApiCommonConfig & GetAccountInfoApiSliceableCommonConfig & Readonly<{
+    getAccountInfo(address: Address, config: GetAccountInfoApiCommonConfig & GetAccountInfoApiSliceableCommonConfig & Readonly<{
         encoding: 'base64';
-    }>): GetAccountInfoApiResponseBase & GetAccountInfoApiResponseWithBase64EncodedData;
-    getAccountInfo(address: Base58EncodedAddress, config: GetAccountInfoApiCommonConfig & GetAccountInfoApiSliceableCommonConfig & Readonly<{
+    }>): GetAccountInfoApiResponseBase & NestInRpcResponseOrNull<AccountInfoWithBase64EncodedData>;
+    getAccountInfo(address: Address, config: GetAccountInfoApiCommonConfig & GetAccountInfoApiSliceableCommonConfig & Readonly<{
         encoding: 'base64+zstd';
-    }>): GetAccountInfoApiResponseBase & GetAccountInfoApiResponseWithBase64EncodedZStdCompressedData;
-    getAccountInfo(address: Base58EncodedAddress, config: GetAccountInfoApiCommonConfig & Readonly<{
+    }>): GetAccountInfoApiResponseBase & NestInRpcResponseOrNull<AccountInfoWithBase64EncodedZStdCompressedData>;
+    getAccountInfo(address: Address, config: GetAccountInfoApiCommonConfig & Readonly<{
         encoding: 'jsonParsed';
-    }>): GetAccountInfoApiResponseBase & GetAccountInfoApiResponseWithJsonData;
-    getAccountInfo(address: Base58EncodedAddress, config: GetAccountInfoApiCommonConfig & GetAccountInfoApiSliceableCommonConfig & Readonly<{
+    }>): GetAccountInfoApiResponseBase & NestInRpcResponseOrNull<AccountInfoWithJsonData>;
+    getAccountInfo(address: Address, config: GetAccountInfoApiCommonConfig & GetAccountInfoApiSliceableCommonConfig & Readonly<{
         encoding: 'base58';
-    }>): GetAccountInfoApiResponseBase & GetAccountInfoApiResponseWithBase58EncodedData_DEPRECATED;
-    getAccountInfo(address: Base58EncodedAddress, config?: GetAccountInfoApiCommonConfig): GetAccountInfoApiResponseBase & GetAccountInfoApiResponseWithDefaultData;
+    }>): GetAccountInfoApiResponseBase & NestInRpcResponseOrNull<AccountInfoWithBase58EncodedData>;
+    getAccountInfo(address: Address, config?: GetAccountInfoApiCommonConfig): GetAccountInfoApiResponseBase & NestInRpcResponseOrNull<AccountInfoWithBase58Bytes>;
 }
 export {};
 //# sourceMappingURL=getAccountInfo.d.ts.map

dist/types/rpc-methods/getBalance.d.ts

@@ -1,9 +0,11 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { Commitment, LamportsUnsafeBeyond2Pow53Minus1, RpcResponse, Slot } from './common';
+import { Address } from '@solana/addresses';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment, LamportsUnsafeBeyond2Pow53Minus1 } from '@solana/rpc-types';
+import { RpcResponse, Slot } from './common.js';
 type GetBalanceApiResponse = RpcResponse<LamportsUnsafeBeyond2Pow53Minus1>;
-export interface GetBalanceApi {
+export interface GetBalanceApi extends IRpcApiMethods {
     /**
      * Returns the balance of the account of provided Pubkey
      */
-    getBalance(address: Base58EncodedAddress, config?: Readonly<{
+    getBalance(address: Address, config?: Readonly<{
         commitment?: Commitment;
@@ -10,0 +12,0 @@ minContextSlot?: Slot;

dist/types/rpc-methods/getBlockHeight.d.ts

@@ -1,4 +0,6 @@
-import { Commitment, Slot, U64UnsafeBeyond2Pow53Minus1 } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment } from '@solana/rpc-types';
+import { Slot, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type GetBlockHeightApiResponse = U64UnsafeBeyond2Pow53Minus1;
-export interface GetBlockHeightApi {
+export interface GetBlockHeightApi extends IRpcApiMethods {
     /**
@@ -5,0 +7,0 @@ * Returns the current block height of the node

dist/types/rpc-methods/getBlockProduction.d.ts

@@ -1,8 +0,10 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { Commitment, RpcResponse, U64UnsafeBeyond2Pow53Minus1 } from './common';
+import { Address } from '@solana/addresses';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment } from '@solana/rpc-types';
+import { RpcResponse, Slot, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type NumberOfLeaderSlots = U64UnsafeBeyond2Pow53Minus1;
 type NumberOfBlocksProduced = U64UnsafeBeyond2Pow53Minus1;
 type SlotRange = Readonly<{
-    firstSlot: U64UnsafeBeyond2Pow53Minus1;
-    lastSlot: U64UnsafeBeyond2Pow53Minus1;
+    firstSlot: Slot;
+    lastSlot: Slot;
 }>;
@@ -18,3 +20,3 @@ type GetBlockProductionApiConfigBase = Readonly<{
     value: Readonly<{
-        byIdentity: Record<Base58EncodedAddress, [NumberOfLeaderSlots, NumberOfBlocksProduced]>;
+        byIdentity: Record<Address, [NumberOfLeaderSlots, NumberOfBlocksProduced]>;
     }>;
@@ -29,7 +31,7 @@ }>;
 }>;
-export interface GetBlockProductionApi {
+export interface GetBlockProductionApi extends IRpcApiMethods {
     /**
      * Returns recent block production information from the current or previous epoch.
      */
-    getBlockProduction<TIdentity extends Base58EncodedAddress>(config: GetBlockProductionApiConfigBase & Readonly<{
+    getBlockProduction<TIdentity extends Address>(config: GetBlockProductionApiConfigBase & Readonly<{
         identity: TIdentity;
@@ -36,0 +38,0 @@ }>): GetBlockProductionApiResponseBase & GetBlockProductionApiResponseWithSingleIdentity<TIdentity>;

dist/types/rpc-methods/getBlocks.d.ts

@@ -1,4 +0,6 @@
-import { Commitment, Slot } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment } from '@solana/rpc-types';
+import { Slot } from './common.js';
 type GetBlocksApiResponse = Slot[];
-export interface GetBlocksApi {
+export interface GetBlocksApi extends IRpcApiMethods {
     /**
@@ -5,0 +7,0 @@ * Returns a list of confirmed blocks between two slots

dist/types/rpc-methods/getBlockTime.d.ts

@@ -1,6 +0,7 @@
-import { UnixTimestamp } from '../unix-timestamp';
-import { Slot } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { UnixTimestamp } from '@solana/rpc-types';
+import { Slot } from './common.js';
 /** Estimated production time, as Unix timestamp (seconds since the Unix epoch) */
 type GetBlockTimeApiResponse = UnixTimestamp;
-export interface GetBlockTimeApi {
+export interface GetBlockTimeApi extends IRpcApiMethods {
     /**
@@ -7,0 +8,0 @@ * Returns the estimated production time of a block.

dist/types/rpc-methods/getEpochInfo.d.ts

@@ -1,2 +0,4 @@
-import { Commitment, Slot, U64UnsafeBeyond2Pow53Minus1 } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment } from '@solana/rpc-types';
+import { Slot, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type GetEpochInfoApiResponse = Readonly<{
@@ -16,3 +18,3 @@ /** the current slot */
 }>;
-export interface GetEpochInfoApi {
+export interface GetEpochInfoApi extends IRpcApiMethods {
     /**
@@ -19,0 +21,0 @@ * Returns the balance of the account of provided Pubkey

dist/types/rpc-methods/getEpochSchedule.d.ts

@@ -1,2 +0,3 @@
-import { U64UnsafeBeyond2Pow53Minus1 } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type GetEpochScheduleApiResponse = Readonly<{
@@ -14,3 +15,3 @@ /** the maximum number of slots in each epoch */
 }>;
-export interface GetEpochScheduleApi {
+export interface GetEpochScheduleApi extends IRpcApiMethods {
     /**
@@ -17,0 +18,0 @@ * Returns the epoch schedule information from this cluster's genesis config

dist/types/rpc-methods/getFirstAvailableBlock.d.ts

@@ -1,4 +0,5 @@
-import { Slot } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Slot } from './common.js';
 type GetFirstAvailableBlockApiResponse = Slot;
-export interface GetFirstAvailableBlockApi {
+export interface GetFirstAvailableBlockApi extends IRpcApiMethods {
     /**
@@ -5,0 +6,0 @@ * Returns the slot of the lowest confirmed block that has not been purged from the ledger

dist/types/rpc-methods/getInflationReward.d.ts

@@ -1,3 +0,5 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { Commitment, LamportsUnsafeBeyond2Pow53Minus1, Slot, U64UnsafeBeyond2Pow53Minus1 } from './common';
+import { Address } from '@solana/addresses';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment, LamportsUnsafeBeyond2Pow53Minus1 } from '@solana/rpc-types';
+import { Slot, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type GetInflationRewardApiResponse = Readonly<{
@@ -10,7 +12,7 @@ amount: LamportsUnsafeBeyond2Pow53Minus1;
 }>;
-export interface GetInflationRewardApi {
+export interface GetInflationRewardApi extends IRpcApiMethods {
     /**
      * Returns the current block height of the node
      */
-    getInflationReward(addresses: Base58EncodedAddress[], config?: Readonly<{
+    getInflationReward(addresses: Address[], config?: Readonly<{
         commitment?: Commitment;
@@ -17,0 +19,0 @@ epoch?: U64UnsafeBeyond2Pow53Minus1;

dist/types/rpc-methods/getLatestBlockhash.d.ts

@@ -1,3 +0,4 @@
-import { Blockhash } from '../blockhash';
-import { Commitment, RpcResponse, Slot, U64UnsafeBeyond2Pow53Minus1 } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import type { Blockhash, Commitment } from '@solana/rpc-types';
+import { RpcResponse, Slot, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type GetLatestBlockhashApiResponse = RpcResponse<{
@@ -9,3 +10,3 @@ /** a Hash as base-58 encoded string */
 }>;
-export interface GetLatestBlockhashApi {
+export interface GetLatestBlockhashApi extends IRpcApiMethods {
     /**
@@ -12,0 +13,0 @@ * Returns the latest blockhash

dist/types/rpc-methods/getMaxRetransmitSlot.d.ts

@@ -1,4 +0,5 @@
-import { Slot } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Slot } from './common.js';
 type GetMaxRetransmitSlotApiResponse = Slot;
-export interface GetMaxRetransmitSlotApi {
+export interface GetMaxRetransmitSlotApi extends IRpcApiMethods {
     /**
@@ -5,0 +6,0 @@ * Get the max slot seen from retransmit stage.

dist/types/rpc-methods/getMaxShredInsertSlot.d.ts

@@ -1,4 +0,5 @@
-import { Slot } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Slot } from './common.js';
 type GetMaxShredInsertSlotApiResponse = Slot;
-export interface GetMaxShredInsertSlotApi {
+export interface GetMaxShredInsertSlotApi extends IRpcApiMethods {
     /**
@@ -5,0 +6,0 @@ * Get the max slot seen from after shred insert.

dist/types/rpc-methods/getRecentPerformanceSamples.d.ts

@@ -1,2 +0,3 @@
-import { Slot, U64UnsafeBeyond2Pow53Minus1 } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Slot, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type PerformanceSample = Readonly<{
@@ -15,3 +16,3 @@ /** Slot in which sample was taken at */
 type GetRecentPerformanceSamplesApiResponse = readonly PerformanceSample[];
-export interface GetRecentPerformanceSamplesApi {
+export interface GetRecentPerformanceSamplesApi extends IRpcApiMethods {
     /**
@@ -18,0 +19,0 @@ * Returns a list of recent performance samples, in reverse slot order. Performance samples are taken every 60 seconds and include the number of transactions and slots that occur in a given time window.

dist/types/rpc-methods/getSignaturesForAddress.d.ts

@@ -1,9 +0,10 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { TransactionError } from '../transaction-error';
-import { TransactionSignature } from '../transaction-signature';
-import { UnixTimestamp } from '../unix-timestamp';
-import { Commitment, RpcResponse, Slot } from './common';
-type GetSignaturesForAddressTransaction = RpcResponse<{
+import { Address } from '@solana/addresses';
+import { Signature } from '@solana/keys';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment, UnixTimestamp } from '@solana/rpc-types';
+import { TransactionError } from '../transaction-error.js';
+import { Slot } from './common.js';
+type GetSignaturesForAddressTransaction = Readonly<{
     /** transaction signature as base-58 encoded string */
-    signature: TransactionSignature;
+    signature: Signature;
     /** The slot that contains the block with the transaction */
@@ -29,7 +30,7 @@ slot: Slot;
     /** start searching backwards from this transaction signature. If not provided the search starts from the top of the highest max confirmed block. */
-    before?: TransactionSignature;
+    before?: Signature;
     /** search until this transaction signature, if found before limit reached */
-    until?: TransactionSignature;
+    until?: Signature;
 }>;
-export interface GetSignaturesForAddressApi {
+export interface GetSignaturesForAddressApi extends IRpcApiMethods {
     /**
@@ -39,5 +40,5 @@ * Returns signatures for confirmed transactions that include the given address in their accountKeys list.
      */
-    getSignaturesForAddress(address: Base58EncodedAddress, config?: GetSignaturesForAddressConfig): GetSignaturesForAddressApiResponse;
+    getSignaturesForAddress(address: Address, config?: GetSignaturesForAddressConfig): GetSignaturesForAddressApiResponse;
 }
 export {};
 //# sourceMappingURL=getSignaturesForAddress.d.ts.map

dist/types/rpc-methods/getSlot.d.ts

@@ -1,4 +0,6 @@
-import { Commitment, Slot } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment } from '@solana/rpc-types';
+import { Slot } from './common.js';
 type GetSlotApiResponse = Slot;
-export interface GetSlotApi {
+export interface GetSlotApi extends IRpcApiMethods {
     /**
@@ -5,0 +7,0 @@ * Returns the slot that has reached the given or default commitment level

dist/types/rpc-methods/getSlotLeaders.d.ts

@@ -1,6 +0,7 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { Slot } from './common';
+import { Address } from '@solana/addresses';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Slot } from './common.js';
 /** array of Node identity public keys as base-58 encoded strings */
-type GetSlotLeadersApiResponse = Base58EncodedAddress[];
-export interface GetSlotLeadersApi {
+type GetSlotLeadersApiResponse = Address[];
+export interface GetSlotLeadersApi extends IRpcApiMethods {
     /**
@@ -7,0 +8,0 @@ * Returns the slot leaders for a given slot range

dist/types/rpc-methods/getStakeMinimumDelegation.d.ts

@@ -1,4 +0,6 @@
-import { Commitment, LamportsUnsafeBeyond2Pow53Minus1, RpcResponse } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment, LamportsUnsafeBeyond2Pow53Minus1 } from '@solana/rpc-types';
+import { RpcResponse } from './common.js';
 type GetStakeMinimumDelegationApiResponse = RpcResponse<LamportsUnsafeBeyond2Pow53Minus1>;
-export interface GetStakeMinimumDelegationApi {
+export interface GetStakeMinimumDelegationApi extends IRpcApiMethods {
     /**
@@ -5,0 +7,0 @@ * Returns the stake minimum delegation, in lamports.

dist/types/rpc-methods/getSupply.d.ts

@@ -1,3 +0,5 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { Commitment, LamportsUnsafeBeyond2Pow53Minus1, RpcResponse } from './common';
+import { Address } from '@solana/addresses';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment, LamportsUnsafeBeyond2Pow53Minus1 } from '@solana/rpc-types';
+import { RpcResponse } from './common.js';
 type GetSupplyConfig = Readonly<{
@@ -18,3 +20,3 @@ commitment?: Commitment;
         /** an array of account addresses of non-circulating accounts */
-        nonCirculatingAccounts: [Base58EncodedAddress];
+        nonCirculatingAccounts: [Address];
     }>;
@@ -27,3 +29,3 @@ }>;
 }>;
-export interface GetSupplyApi {
+export interface GetSupplyApi extends IRpcApiMethods {
     /**
@@ -30,0 +32,0 @@ * Returns information about the current supply.

dist/types/rpc-methods/getTokenLargestAccounts.d.ts

@@ -1,24 +0,13 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { StringifiedBigInt } from '../stringified-bigint';
-import { Commitment, RpcResponse } from './common';
-type GetTokenLargestAccountsApiResponse = RpcResponse<{
-    /** the address of the token account */
-    address: Base58EncodedAddress;
-    /** the raw token account balance without decimals, a string representation of u64 */
-    amount: StringifiedBigInt;
-    /** number of base 10 digits to the right of the decimal place */
-    decimals: number;
-    /**
-     * the token account balance, using mint-prescribed decimals
-     * @deprecated
-     */
-    uiAmount: number | null;
-    /** the token account balance as a string, using mint-prescribed decimals */
-    uiAmountString: string;
+import { Address } from '@solana/addresses';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment, TokenAmount } from '@solana/rpc-types';
+import { RpcResponse } from './common.js';
+type GetTokenLargestAccountsApiResponse = RpcResponse<TokenAmount & {
+    address: Address;
 }[]>;
-export interface GetTokenLargestAccountsApi {
+export interface GetTokenLargestAccountsApi extends IRpcApiMethods {
     /**
      * Returns the 20 largest accounts of a particular SPL Token type.
      */
-    getTokenLargestAccounts(tokenMint: Base58EncodedAddress, config?: Readonly<{
+    getTokenLargestAccounts(tokenMint: Address, config?: Readonly<{
         commitment?: Commitment;
@@ -25,0 +14,0 @@ }>): GetTokenLargestAccountsApiResponse;

dist/types/rpc-methods/getTransaction.d.ts

@@ -1,59 +0,12 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { Blockhash } from '../blockhash';
-import { StringifiedBigInt } from '../stringified-bigint';
-import { TransactionError } from '../transaction-error';
-import { UnixTimestamp } from '../unix-timestamp';
-import { Base58EncodedBytes, Base58EncodedDataResponse, Base64EncodedDataResponse, Commitment, LamportsUnsafeBeyond2Pow53Minus1, Slot, TransactionVersion, U64UnsafeBeyond2Pow53Minus1 } from './common';
-type TokenBalance = Readonly<{
-    /** Index of the account in which the token balance is provided for. */
-    accountIndex: number;
-    /** Pubkey of the token's mint. */
-    mint: Base58EncodedAddress;
-    /** Pubkey of token balance's owner. */
-    owner?: Base58EncodedAddress;
-    /** Pubkey of the Token program that owns the account. */
-    programId?: Base58EncodedAddress;
-    uiTokenAmount: {
-        /** Raw amount of tokens as a string, ignoring decimals. */
-        amount: StringifiedBigInt;
-        /** Number of decimals configured for token's mint. */
-        decimals: number;
-        /**
-         * Token amount as a float, accounting for decimals.
-         * @deprecated
-         */
-        uiAmount: number | null;
-        /** Token amount as a string, accounting for decimals. */
-        uiAmountString: string;
-    };
-}>;
-type TransactionRewardBase = Readonly<{
-    /** The public key of the account that received the reward */
-    pubkey: Base58EncodedAddress;
-    /** number of reward lamports credited or debited by the account */
-    lamports: LamportsUnsafeBeyond2Pow53Minus1;
-    /** account balance in lamports after the reward was applied */
-    postBalance: LamportsUnsafeBeyond2Pow53Minus1;
-}>;
-type TransactionRewardWithoutCommission = TransactionRewardBase & Readonly<{
-    /** type of reward */
-    rewardType: 'fee' | 'rent';
-}>;
-/** Commission is present only for voting and staking rewards */
-type TransactionRewardWithCommission = TransactionRewardBase & Readonly<{
-    /** type of reward */
-    rewardType: 'voting' | 'staking';
-    /** vote account commission when the reward was credited */
-    commission: number;
-}>;
-type TransactionReward = TransactionRewardWithoutCommission | TransactionRewardWithCommission;
-/** @deprecated */
-type TransactionStatus = {
-    Ok: null;
-} | {
-    Err: TransactionError;
-};
+import { Address } from '@solana/addresses';
+import { Signature } from '@solana/keys';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Base58EncodedBytes, Base58EncodedDataResponse, Base64EncodedDataResponse, Blockhash, Commitment, LamportsUnsafeBeyond2Pow53Minus1, UnixTimestamp } from '@solana/rpc-types';
+import { TransactionVersion } from '@solana/transactions';
+import { TransactionError } from '../transaction-error.js';
+import { Slot, TokenBalance, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
+import { Reward, TransactionStatus } from './common-transactions.js';
 type ReturnData = {
     /** the program that generated the return data */
-    programId: Base58EncodedAddress;
+    programId: Address;
     /** the return data itself */
@@ -78,3 +31,3 @@ data: Base64EncodedDataResponse;
     /** transaction-level rewards */
-    rewards: readonly TransactionReward[] | null;
+    rewards: readonly Reward[] | null;
     /**
@@ -92,3 +45,3 @@ * Transaction status
     /** public key for an address lookup table account. */
-    accountKey: Base58EncodedAddress;
+    accountKey: Address;
     /** List of indices used to load addresses of writable accounts from a lookup table. */
@@ -112,3 +65,3 @@ writableIndexes: readonly number[];
     message: {
-        accountKeys: readonly Base58EncodedAddress[];
+        accountKeys: readonly Address[];
         header: {
@@ -123,5 +76,5 @@ numReadonlySignedAccounts: number;
 type PartiallyDecodedTransactionInstruction = Readonly<{
-    accounts: readonly Base58EncodedAddress[];
+    accounts: readonly Address[];
     data: Base58EncodedBytes;
-    programId: Base58EncodedAddress;
+    programId: Address;
 }>;
@@ -134,3 +87,3 @@ type ParsedTransactionInstruction = Readonly<{
     program: string;
-    programId: Base58EncodedAddress;
+    programId: Address;
 }>;
@@ -141,3 +94,3 @@ type TransactionJsonParsed = TransactionBase & Readonly<{
             {
-                pubkey: Base58EncodedAddress;
+                pubkey: Address;
                 signer: boolean;
@@ -163,4 +116,4 @@ source: string;
     loadedAddresses: {
-        writable: readonly Base58EncodedAddress[];
-        readonly: readonly Base58EncodedAddress[];
+        writable: readonly Address[];
+        readonly: readonly Address[];
     };
@@ -183,7 +136,7 @@ }>;
 }>;
-export interface GetTransactionApi {
+export interface GetTransactionApi extends IRpcApiMethods {
     /**
      * Returns transaction details for a confirmed transaction
      */
-    getTransaction<TMaxSupportedTransactionVersion extends TransactionVersion | void = void>(address: Base58EncodedAddress, config: GetTransactionCommonConfig<TMaxSupportedTransactionVersion> & Readonly<{
+    getTransaction<TMaxSupportedTransactionVersion extends TransactionVersion | void = void>(signature: Signature, config: GetTransactionCommonConfig<TMaxSupportedTransactionVersion> & Readonly<{
         encoding: 'jsonParsed';
@@ -196,3 +149,3 @@ }>): (GetTransactionApiResponseBase & (TMaxSupportedTransactionVersion extends void ? Record<string, never> : {
     }) | null;
-    getTransaction<TMaxSupportedTransactionVersion extends TransactionVersion | void = void>(address: Base58EncodedAddress, config: GetTransactionCommonConfig<TMaxSupportedTransactionVersion> & Readonly<{
+    getTransaction<TMaxSupportedTransactionVersion extends TransactionVersion | void = void>(signature: Signature, config: GetTransactionCommonConfig<TMaxSupportedTransactionVersion> & Readonly<{
         encoding: 'base64';
@@ -205,3 +158,3 @@ }>): (GetTransactionApiResponseBase & (TMaxSupportedTransactionVersion extends void ? Record<string, never> : {
     }) | null;
-    getTransaction<TMaxSupportedTransactionVersion extends TransactionVersion | void = void>(address: Base58EncodedAddress, config: GetTransactionCommonConfig<TMaxSupportedTransactionVersion> & Readonly<{
+    getTransaction<TMaxSupportedTransactionVersion extends TransactionVersion | void = void>(signature: Signature, config: GetTransactionCommonConfig<TMaxSupportedTransactionVersion> & Readonly<{
         encoding: 'base58';
@@ -214,3 +167,3 @@ }>): (GetTransactionApiResponseBase & (TMaxSupportedTransactionVersion extends void ? Record<string, never> : {
     }) | null;
-    getTransaction<TMaxSupportedTransactionVersion extends TransactionVersion | void = void>(address: Base58EncodedAddress, config?: GetTransactionCommonConfig<TMaxSupportedTransactionVersion> & Readonly<{
+    getTransaction<TMaxSupportedTransactionVersion extends TransactionVersion | void = void>(signature: Signature, config?: GetTransactionCommonConfig<TMaxSupportedTransactionVersion> & Readonly<{
         encoding?: 'json';
@@ -217,0 +170,0 @@ }>): (GetTransactionApiResponseBase & (TMaxSupportedTransactionVersion extends void ? Record<string, never> : {

dist/types/rpc-methods/getTransactionCount.d.ts

@@ -1,4 +0,6 @@
-import { Commitment, Slot, U64UnsafeBeyond2Pow53Minus1 } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment } from '@solana/rpc-types';
+import { Slot, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type GetTransactionCountApiResponse = U64UnsafeBeyond2Pow53Minus1;
-export interface GetTransactionCountApi {
+export interface GetTransactionCountApi extends IRpcApiMethods {
     /**
@@ -5,0 +7,0 @@ * Returns the current Transaction count from the ledger

dist/types/rpc-methods/getVoteAccounts.d.ts

@@ -1,3 +0,5 @@
-import { Base58EncodedAddress } from '@solana/keys';
-import { Commitment, U64UnsafeBeyond2Pow53Minus1 } from './common';
+import { Address } from '@solana/addresses';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Commitment } from '@solana/rpc-types';
+import { Slot, U64UnsafeBeyond2Pow53Minus1 } from './common.js';
 type Epoch = U64UnsafeBeyond2Pow53Minus1;
@@ -7,7 +9,7 @@ type Credits = U64UnsafeBeyond2Pow53Minus1;
 type EpochCredit = [Epoch, Credits, PreviousCredits];
-type VoteAccount<TVotePubkey extends Base58EncodedAddress> = Readonly<{
+type VoteAccount<TVotePubkey extends Address> = Readonly<{
     /** Vote account address */
     votePubkey: TVotePubkey;
     /** Validator identity */
-    nodePubkey: Base58EncodedAddress;
+    nodePubkey: Address;
     /** the stake, in lamports, delegated to this vote account and active in this epoch */
@@ -24,9 +26,9 @@ activatedStake: U64UnsafeBeyond2Pow53Minus1;
     /** Current root slot for this vote account */
-    rootSlot: U64UnsafeBeyond2Pow53Minus1;
+    rootSlot: Slot;
 }>;
-type GetVoteAccountsApiResponse<TVotePubkey extends Base58EncodedAddress> = Readonly<{
+type GetVoteAccountsApiResponse<TVotePubkey extends Address> = Readonly<{
     current: readonly VoteAccount<TVotePubkey>[];
     delinquent: readonly VoteAccount<TVotePubkey>[];
 }>;
-type GetVoteAccountsConfig<TVotePubkey extends Base58EncodedAddress> = Readonly<{
+type GetVoteAccountsConfig<TVotePubkey extends Address> = Readonly<{
     commitment?: Commitment;
@@ -40,7 +42,7 @@ /** Only return results for this validator vote address */
 }>;
-export interface GetVoteAccountsApi {
+export interface GetVoteAccountsApi extends IRpcApiMethods {
     /** Returns the account info and associated stake for all the voting accounts in the current bank. */
-    getVoteAccounts<TVoteAccount extends Base58EncodedAddress>(config?: GetVoteAccountsConfig<TVoteAccount>): GetVoteAccountsApiResponse<TVoteAccount>;
+    getVoteAccounts<TVoteAccount extends Address>(config?: GetVoteAccountsConfig<TVoteAccount>): GetVoteAccountsApiResponse<TVoteAccount>;
 }
 export {};
 //# sourceMappingURL=getVoteAccounts.d.ts.map

dist/types/rpc-methods/index.d.ts

@@ -1,33 +0,61 @@
-import { IRpcApi } from '@solana/rpc-transport/dist/types/json-rpc-types';
-import { GetAccountInfoApi } from './getAccountInfo';
-import { GetBalanceApi } from './getBalance';
-import { GetBlockHeightApi } from './getBlockHeight';
-import { GetBlockProductionApi } from './getBlockProduction';
-import { GetBlocksApi } from './getBlocks';
-import { GetBlockTimeApi } from './getBlockTime';
-import { GetEpochInfoApi } from './getEpochInfo';
-import { GetEpochScheduleApi } from './getEpochSchedule';
-import { GetFirstAvailableBlockApi } from './getFirstAvailableBlock';
-import { GetInflationRewardApi } from './getInflationReward';
-import { GetLatestBlockhashApi } from './getLatestBlockhash';
-import { GetMaxRetransmitSlotApi } from './getMaxRetransmitSlot';
-import { GetMaxShredInsertSlotApi } from './getMaxShredInsertSlot';
-import { GetRecentPerformanceSamplesApi } from './getRecentPerformanceSamples';
-import { GetSignaturesForAddressApi } from './getSignaturesForAddress';
-import { GetSlotApi } from './getSlot';
-import { GetSlotLeadersApi } from './getSlotLeaders';
-import { GetStakeMinimumDelegationApi } from './getStakeMinimumDelegation';
-import { GetSupplyApi } from './getSupply';
-import { GetTokenLargestAccountsApi } from './getTokenLargestAccounts';
-import { GetTransactionApi } from './getTransaction';
-import { GetTransactionCountApi } from './getTransactionCount';
-import { GetVoteAccountsApi } from './getVoteAccounts';
-import { IsBlockhashValidApi } from './isBlockhashValid';
-import { MinimumLedgerSlotApi } from './minimumLedgerSlot';
-type Config = Readonly<{
-    onIntegerOverflow?: (methodName: string, keyPath: (number | string)[], value: bigint) => void;
-}>;
-export type SolanaRpcMethods = GetAccountInfoApi & GetBalanceApi & GetBlockHeightApi & GetBlockProductionApi & GetBlocksApi & GetBlockTimeApi & GetEpochInfoApi & GetEpochScheduleApi & GetFirstAvailableBlockApi & GetInflationRewardApi & GetLatestBlockhashApi & GetMaxRetransmitSlotApi & GetMaxShredInsertSlotApi & GetRecentPerformanceSamplesApi & GetSignaturesForAddressApi & GetSlotApi & GetSlotLeadersApi & GetStakeMinimumDelegationApi & GetSupplyApi & GetTokenLargestAccountsApi & GetTransactionApi & GetTransactionCountApi & GetVoteAccountsApi & IsBlockhashValidApi & MinimumLedgerSlotApi;
+import { IRpcApi } from '@solana/rpc-transport';
+import { ParamsPatcherConfig } from '../params-patcher.js';
+import { GetAccountInfoApi } from './getAccountInfo.js';
+import { GetBalanceApi } from './getBalance.js';
+import { GetBlockApi } from './getBlock.js';
+import { GetBlockCommitmentApi } from './getBlockCommitment.js';
+import { GetBlockHeightApi } from './getBlockHeight.js';
+import { GetBlockProductionApi } from './getBlockProduction.js';
+import { GetBlocksApi } from './getBlocks.js';
+import { GetBlocksWithLimitApi } from './getBlocksWithLimit.js';
+import { GetBlockTimeApi } from './getBlockTime.js';
+import { GetClusterNodesApi } from './getClusterNodes.js';
+import { GetEpochInfoApi } from './getEpochInfo.js';
+import { GetEpochScheduleApi } from './getEpochSchedule.js';
+import { GetFeeForMessageApi } from './getFeeForMessage.js';
+import { GetFirstAvailableBlockApi } from './getFirstAvailableBlock.js';
+import { GetGenesisHashApi } from './getGenesisHash.js';
+import { GetHealthApi } from './getHealth.js';
+import { GetHighestSnapshotSlotApi } from './getHighestSnapshotSlot.js';
+import { GetIdentityApi } from './getIdentity.js';
+import { GetInflationGovernorApi } from './getInflationGovernor.js';
+import { GetInflationRateApi } from './getInflationRate.js';
+import { GetInflationRewardApi } from './getInflationReward.js';
+import { GetLargestAccountsApi } from './getLargestAccounts.js';
+import { GetLatestBlockhashApi } from './getLatestBlockhash.js';
+import { GetLeaderScheduleApi } from './getLeaderSchedule.js';
+import { GetMaxRetransmitSlotApi } from './getMaxRetransmitSlot.js';
+import { GetMaxShredInsertSlotApi } from './getMaxShredInsertSlot.js';
+import { GetMinimumBalanceForRentExemptionApi } from './getMinimumBalanceForRentExemption.js';
+import { GetMultipleAccountsApi } from './getMultipleAccounts.js';
+import { GetProgramAccountsApi } from './getProgramAccounts.js';
+import { GetRecentPerformanceSamplesApi } from './getRecentPerformanceSamples.js';
+import { GetRecentPrioritizationFeesApi } from './getRecentPrioritizationFees.js';
+import { GetSignaturesForAddressApi } from './getSignaturesForAddress.js';
+import { GetSignatureStatusesApi } from './getSignatureStatuses.js';
+import { GetSlotApi } from './getSlot.js';
+import { GetSlotLeaderApi } from './getSlotLeader.js';
+import { GetSlotLeadersApi } from './getSlotLeaders.js';
+import { GetStakeActivationApi } from './getStakeActivation.js';
+import { GetStakeMinimumDelegationApi } from './getStakeMinimumDelegation.js';
+import { GetSupplyApi } from './getSupply.js';
+import { GetTokenAccountBalanceApi } from './getTokenAccountBalance.js';
+import { GetTokenAccountsByDelegateApi } from './getTokenAccountsByDelegate.js';
+import { GetTokenAccountsByOwnerApi } from './getTokenAccountsByOwner.js';
+import { GetTokenLargestAccountsApi } from './getTokenLargestAccounts.js';
+import { GetTokenSupplyApi } from './getTokenSupply.js';
+import { GetTransactionApi } from './getTransaction.js';
+import { GetTransactionCountApi } from './getTransactionCount.js';
+import { GetVersionApi } from './getVersion.js';
+import { GetVoteAccountsApi } from './getVoteAccounts.js';
+import { IsBlockhashValidApi } from './isBlockhashValid.js';
+import { MinimumLedgerSlotApi } from './minimumLedgerSlot.js';
+import { RequestAirdropApi } from './requestAirdrop.js';
+import { SendTransactionApi } from './sendTransaction.js';
+import { SimulateTransactionApi } from './simulateTransaction.js';
+type Config = ParamsPatcherConfig;
+export type SolanaRpcMethods = GetAccountInfoApi & GetBalanceApi & GetBlockApi & GetBlockCommitmentApi & GetBlockHeightApi & GetBlockProductionApi & GetBlocksApi & GetBlocksWithLimitApi & GetBlockTimeApi & GetClusterNodesApi & GetEpochInfoApi & GetEpochScheduleApi & GetFeeForMessageApi & GetFirstAvailableBlockApi & GetGenesisHashApi & GetHealthApi & GetHighestSnapshotSlotApi & GetIdentityApi & GetInflationGovernorApi & GetInflationRateApi & GetInflationRewardApi & GetLargestAccountsApi & GetLatestBlockhashApi & GetLeaderScheduleApi & GetMaxRetransmitSlotApi & GetMaxShredInsertSlotApi & GetMinimumBalanceForRentExemptionApi & GetMultipleAccountsApi & GetProgramAccountsApi & GetRecentPerformanceSamplesApi & GetRecentPrioritizationFeesApi & GetSignaturesForAddressApi & GetSignatureStatusesApi & GetSlotApi & GetSlotLeaderApi & GetSlotLeadersApi & GetStakeActivationApi & GetStakeMinimumDelegationApi & GetSupplyApi & GetTokenAccountBalanceApi & GetTokenAccountsByDelegateApi & GetTokenAccountsByOwnerApi & GetTokenLargestAccountsApi & GetTokenSupplyApi & GetTransactionApi & GetTransactionCountApi & GetVersionApi & GetVoteAccountsApi & IsBlockhashValidApi & MinimumLedgerSlotApi & RequestAirdropApi & SendTransactionApi & SimulateTransactionApi;
 export declare function createSolanaRpcApi(config?: Config): IRpcApi<SolanaRpcMethods>;
-export {};
+export type { GetAccountInfoApi, GetBalanceApi, GetBlockApi, GetBlockCommitmentApi, GetBlockHeightApi, GetBlockProductionApi, GetBlocksApi, GetBlocksWithLimitApi, GetBlockTimeApi, GetClusterNodesApi, GetEpochInfoApi, GetEpochScheduleApi, GetFeeForMessageApi, GetFirstAvailableBlockApi, GetGenesisHashApi, GetHealthApi, GetHighestSnapshotSlotApi, GetIdentityApi, GetInflationGovernorApi, GetInflationRateApi, GetInflationRewardApi, GetLargestAccountsApi, GetLatestBlockhashApi, GetLeaderScheduleApi, GetMaxRetransmitSlotApi, GetMaxShredInsertSlotApi, GetMinimumBalanceForRentExemptionApi, GetMultipleAccountsApi, GetProgramAccountsApi, GetRecentPerformanceSamplesApi, GetRecentPrioritizationFeesApi, GetSignaturesForAddressApi, GetSignatureStatusesApi, GetSlotApi, GetSlotLeaderApi, GetSlotLeadersApi, GetStakeActivationApi, GetStakeMinimumDelegationApi, GetSupplyApi, GetTokenAccountBalanceApi, GetTokenAccountsByDelegateApi, GetTokenAccountsByOwnerApi, GetTokenLargestAccountsApi, GetTokenSupplyApi, GetTransactionApi, GetTransactionCountApi, GetVersionApi, GetVoteAccountsApi, IsBlockhashValidApi, MinimumLedgerSlotApi, RequestAirdropApi, SendTransactionApi, SimulateTransactionApi, };
+export type { DataSlice, GetProgramAccountsDatasizeFilter, GetProgramAccountsMemcmpFilter, Slot } from './common.js';
 //# sourceMappingURL=index.d.ts.map

dist/types/rpc-methods/isBlockhashValid.d.ts

@@ -1,5 +0,6 @@
-import { Blockhash } from '../blockhash';
-import { Commitment, RpcResponse, Slot } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import type { Blockhash, Commitment } from '@solana/rpc-types';
+import { RpcResponse, Slot } from './common.js';
 type IsBlockhashValidApiResponse = RpcResponse<boolean>;
-export interface IsBlockhashValidApi {
+export interface IsBlockhashValidApi extends IRpcApiMethods {
     /**
@@ -6,0 +7,0 @@ * Returns whether a blockhash is still valid or not

dist/types/rpc-methods/minimumLedgerSlot.d.ts

@@ -1,4 +0,5 @@
-import { Slot } from './common';
+import type { IRpcApiMethods } from '@solana/rpc-transport';
+import { Slot } from './common.js';
 type MinimumLedgerSlotApiResponse = Slot;
-export interface MinimumLedgerSlotApi {
+export interface MinimumLedgerSlotApi extends IRpcApiMethods {
     /**
@@ -5,0 +6,0 @@ * Returns the lowest slot that the node has information about in its ledger.

package.json

 {
   "name": "@solana/rpc-core",
-  "version": "2.0.0-experimental.a7f0f86",
+  "version": "2.0.0-experimental.a81a78e",
   "description": "A library for making calls to the Solana JSON RPC API",
@@ -48,30 +48,29 @@ "exports": {
   ],
-  "dependencies": {
-    "@metaplex-foundation/umi-serializers-encodings": "^0.8.2",
-    "@solana/keys": "2.0.0-experimental.a7f0f86"
-  },
   "devDependencies": {
     "@solana/eslint-config-solana": "^1.0.2",
-    "@swc/core": "^1.3.18",
-    "@swc/jest": "^0.2.26",
-    "@types/jest": "^29.5.2",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
+    "@swc/jest": "^0.2.29",
+    "@types/jest": "^29.5.11",
+    "@typescript-eslint/eslint-plugin": "^6.13.2",
+    "@typescript-eslint/parser": "^6.3.0",
     "agadoo": "^3.0.0",
     "eslint": "^8.45.0",
-    "eslint-plugin-jest": "^27.2.3",
-    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-jest": "^27.4.2",
     "eslint-plugin-sort-keys-fix": "^1.1.2",
-    "jest": "^29.6.1",
-    "jest-environment-jsdom": "^29.6.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
     "jest-fetch-mock-fork": "^3.0.4",
-    "jest-runner-eslint": "^2.1.0",
+    "jest-runner-eslint": "^2.1.2",
     "jest-runner-prettier": "^1.0.0",
-    "postcss": "^8.4.12",
-    "prettier": "^2.8.8",
-    "ts-node": "^10.9.1",
-    "tsup": "6.7.0",
-    "typescript": "^5.1.6",
+    "prettier": "^3.1",
+    "tsup": "^8.0.1",
+    "typescript": "^5.2.2",
     "version-from-git": "^1.1.1",
-    "@solana/rpc-transport": "2.0.0-experimental.a7f0f86",
+    "@solana/addresses": "2.0.0-experimental.a81a78e",
+    "@solana/codecs-core": "2.0.0-experimental.a81a78e",
+    "@solana/codecs-strings": "2.0.0-experimental.a81a78e",
+    "@solana/keys": "2.0.0-experimental.a81a78e",
+    "@solana/rpc-parsed-types": "2.0.0-experimental.a81a78e",
+    "@solana/rpc-transport": "2.0.0-experimental.a81a78e",
+    "@solana/rpc-types": "2.0.0-experimental.a81a78e",
+    "@solana/transactions": "2.0.0-experimental.a81a78e",
     "build-scripts": "0.0.0",
@@ -91,10 +90,11 @@ "test-config": "0.0.0",
     "compile:js": "tsup --config build-scripts/tsup.config.package.ts",
-    "compile:typedefs": "tsc -p ./tsconfig.declarations.json",
+    "compile:typedefs": "tsc -p ./tsconfig.declarations.json && node node_modules/build-scripts/add-js-extension-to-types.mjs",
     "dev": "jest -c node_modules/test-config/jest-dev.config.ts --globalSetup test-config/test-validator-setup.js --globalTeardown test-config/test-validator-teardown.js --rootDir . --watch",
     "publish-packages": "pnpm publish --tag experimental --access public --no-git-checks",
+    "style:fix": "pnpm eslint --fix src/* && pnpm prettier -w src/* package.json",
     "test:lint": "jest -c node_modules/test-config/jest-lint.config.ts --rootDir . --silent",
     "test:prettier": "jest -c node_modules/test-config/jest-prettier.config.ts --rootDir . --silent",
     "test:treeshakability:browser": "agadoo dist/index.browser.js",
-    "test:treeshakability:native": "agadoo dist/index.node.js",
-    "test:treeshakability:node": "agadoo dist/index.native.js",
+    "test:treeshakability:native": "agadoo dist/index.native.js",
+    "test:treeshakability:node": "agadoo dist/index.node.js",
     "test:typecheck": "tsc --noEmit",
@@ -101,0 +101,0 @@ "test:unit:browser": "jest -c node_modules/test-config/jest-unit.config.browser.ts --globalSetup test-config/test-validator-setup.js --globalTeardown test-config/test-validator-teardown.js --rootDir . --silent",

README.md

@@ -18,7 +18,1 @@ [![npm][npm-image]][npm-url]
 This package defines a specification of the [Solana JSON-RPC](https://docs.solana.com/api/http). The inputs and outputs of each RPC method are described in terms of Typescript interfaces. You generally will not need to depend on this package directly, but rather use it as part of the RPC creation functions of the Solana JavaScript SDK [`@solana/web3.js@experimental`](https://github.com/solana-labs/solana-web3.js/tree/master/packages/library).
-
-## Contributing
-
-As of this moment, this package does not represent a specification of the full set of Solana JSON-RPC methods. If you find that you have need of a method that has not yet been specified, we would be grateful if you submitted a specification for it.
-
-Read the RPC method specification [contribution guide](https://github.com/solana-labs/solana-web3.js/issues/1278) to get started.

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

685558

increased by220.89%

Dependency count

0

decreased by-100%

Number of package files

168

increased by229.41%

Lines of code

6673

increased by195.92%

Worsened metrics

Dev dependency count

29

increased by11.54%

Number of lines in readme file

18

decreased by-25%

Dependency changes

• - Removed@metaplex-foundation/umi-serializers-encodings@^0.8.2

• - Removed@solana/keys@2.0.0-experimental.a7f0f86

• - Removed@metaplex-foundation/umi-options@0.8.9(transitive)

• - Removed@metaplex-foundation/umi-public-keys@0.8.9(transitive)

• - Removed@metaplex-foundation/umi-serializers@0.8.9(transitive)

• - Removed@metaplex-foundation/umi-serializers-core@0.8.9(transitive)

• - Removed@metaplex-foundation/umi-serializers-encodings@0.8.9(transitive)

• - Removed@metaplex-foundation/umi-serializers-numbers@0.8.9(transitive)

• - Removed@solana/keys@2.0.0-experimental.a7f0f86(transitive)