@psalomo/jsonrpc-client 1.0.1 → 1.0.2

package/dist/browser-standalone.js

@@ -48,9 +48,11 @@ class JsonRpcClientError extends Error {
 }
 class JsonRpcNetworkError extends Error {
     originalError;
-    constructor(message, originalError) {
+    responseBody;
+    constructor(message, originalError, responseBody) {
         super(message);
         this.originalError = originalError;
+        this.responseBody = responseBody;
         this.name = 'JsonRpcNetworkError';
     }
 }
@@ -119,23 +121,29 @@ class NearRpcClient {
                     signal: controller.signal,
                 });
                 clearTimeout(timeoutId);
-                if (!response.ok) {
-                    throw new JsonRpcNetworkError(`HTTP error! status: ${response.status}`);
-                }
                 let jsonResponse;
                 try {
                     jsonResponse = await response.json();
                 }
                 catch (parseError) {
+                    // If we can't parse JSON and it's not a 2xx response, include status info
+                    if (!response.ok) {
+                        throw new JsonRpcNetworkError(`HTTP error! status: ${response.status} - Failed to parse JSON response`, parseError);
+                    }
                     throw new JsonRpcNetworkError('Failed to parse JSON response', parseError);
                 }
-                // Validate basic JSON-RPC response structure first
-                if (this.validation) {
-                    this.validation.validateResponse(jsonResponse);
-                }
+                // Check for JSON-RPC error in the response
                 if (jsonResponse.error) {
                     throw new JsonRpcClientError(jsonResponse.error.message, jsonResponse.error.code, jsonResponse.error.data);
                 }
+                // If it's not a 2xx status and no JSON-RPC error, throw network error with body
+                if (!response.ok) {
+                    throw new JsonRpcNetworkError(`HTTP error! status: ${response.status}`, undefined, jsonResponse);
+                }
+                // Validate basic JSON-RPC response structure
+                if (this.validation) {
+                    this.validation.validateResponse(jsonResponse);
+                }
                 // Convert snake_case response back to camelCase
                 const camelCaseResult = jsonResponse.result
                     ? convertKeysToCamelCase(jsonResponse.result)
@@ -2762,190 +2770,328 @@ var JsonRpcRequestForValidatorsSchema = () => object({
   method: _enum(["validators"]),
   params: _lazy(() => RpcValidatorRequestSchema())
 });
-var JsonRpcResponseFor_ArrayOf_RangeOfUint64And_RpcErrorSchema = () => union([
-  object({
-    result: array(_lazy(() => RangeOfUint64Schema()))
-  }),
+var JsonRpcResponseFor_ArrayOf_RangeOfUint64And_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: array(_lazy(() => RangeOfUint64Schema()))
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_ArrayOf_ValidatorStakeViewAnd_RpcErrorSchema = () => union([
-  object({
-    result: array(_lazy(() => ValidatorStakeViewSchema()))
-  }),
+);
+var JsonRpcResponseFor_ArrayOf_ValidatorStakeViewAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: array(_lazy(() => ValidatorStakeViewSchema()))
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_CryptoHashAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => CryptoHashSchema())
-  }),
+);
+var JsonRpcResponseFor_CryptoHashAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => CryptoHashSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_GenesisConfigAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => GenesisConfigSchema())
-  }),
+);
+var JsonRpcResponseFor_GenesisConfigAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => GenesisConfigSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_Nullable_RpcHealthResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: union([_lazy(() => RpcHealthResponseSchema()), _null()])
-  }),
+);
+var JsonRpcResponseFor_Nullable_RpcHealthResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: union([_lazy(() => RpcHealthResponseSchema()), _null()])
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcBlockResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcBlockResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcBlockResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcBlockResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcChunkResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcChunkResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcChunkResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcChunkResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcClientConfigResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcClientConfigResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcClientConfigResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcClientConfigResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcCongestionLevelResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcCongestionLevelResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcCongestionLevelResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcCongestionLevelResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcGasPriceResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcGasPriceResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcGasPriceResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcGasPriceResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcLightClientBlockProofResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcLightClientBlockProofResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcLightClientBlockProofResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcLightClientBlockProofResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcLightClientExecutionProofResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcLightClientExecutionProofResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcLightClientExecutionProofResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcLightClientExecutionProofResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcLightClientNextBlockResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcLightClientNextBlockResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcLightClientNextBlockResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcLightClientNextBlockResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcNetworkInfoResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcNetworkInfoResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcNetworkInfoResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcNetworkInfoResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcProtocolConfigResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcProtocolConfigResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcProtocolConfigResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcProtocolConfigResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcQueryResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcQueryResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcQueryResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcQueryResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcReceiptResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcReceiptResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcReceiptResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcReceiptResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcSplitStorageInfoResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcSplitStorageInfoResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcSplitStorageInfoResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcSplitStorageInfoResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcStateChangesInBlockByTypeResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcStateChangesInBlockByTypeResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcStateChangesInBlockByTypeResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcStateChangesInBlockByTypeResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcStateChangesInBlockResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcStateChangesInBlockResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcStateChangesInBlockResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcStateChangesInBlockResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcStatusResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcStatusResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcStatusResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcStatusResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcTransactionResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcTransactionResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcTransactionResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
-var JsonRpcResponseFor_RpcValidatorResponseAnd_RpcErrorSchema = () => union([
-  object({
-    result: _lazy(() => RpcValidatorResponseSchema())
-  }),
+);
+var JsonRpcResponseFor_RpcValidatorResponseAnd_RpcErrorSchema = () => intersection(
+  union([
+    object({
+      result: _lazy(() => RpcValidatorResponseSchema())
+    }),
+    object({
+      error: _lazy(() => RpcErrorSchema())
+    })
+  ]),
   object({
-    error: _lazy(() => RpcErrorSchema())
+    id: string(),
+    jsonrpc: string()
   })
-]);
+);
 var KnownProducerViewSchema = () => object({
   accountId: _lazy(() => AccountIdSchema()),
   nextHops: optional(array(_lazy(() => PublicKeySchema()))),
@@ -3243,20 +3389,29 @@ var RpcCongestionLevelRequestSchema = () => union([
 var RpcCongestionLevelResponseSchema = () => object({
   congestionLevel: number()
 });
-var RpcErrorSchema = () => union([
-  object({
-    cause: _lazy(() => RpcRequestValidationErrorKindSchema()),
-    name: _enum(["REQUEST_VALIDATION_ERROR"])
-  }),
-  object({
-    cause: unknown(),
-    name: _enum(["HANDLER_ERROR"])
-  }),
+var RpcErrorSchema = () => intersection(
+  union([
+    object({
+      cause: _lazy(() => RpcRequestValidationErrorKindSchema()),
+      name: _enum(["REQUEST_VALIDATION_ERROR"])
+    }),
+    object({
+      cause: unknown(),
+      name: _enum(["HANDLER_ERROR"])
+    }),
+    object({
+      cause: unknown(),
+      name: _enum(["INTERNAL_ERROR"])
+    })
+  ]),
   object({
-    cause: unknown(),
-    name: _enum(["INTERNAL_ERROR"])
+    cause: optional(unknown()),
+    code: number(),
+    data: optional(unknown()),
+    message: string(),
+    name: optional(unknown())
   })
-]);
+);
 var RpcGasPriceRequestSchema = () => object({
   blockId: optional(union([_lazy(() => BlockIdSchema()), _null()]))
 });
@@ -3278,18 +3433,23 @@ var RpcLightClientBlockProofResponseSchema = () => object({
   blockHeaderLite: _lazy(() => LightClientBlockLiteViewSchema()),
   blockProof: array(_lazy(() => MerklePathItemSchema()))
 });
-var RpcLightClientExecutionProofRequestSchema = () => union([
-  object({
-    senderId: _lazy(() => AccountIdSchema()),
-    transactionHash: _lazy(() => CryptoHashSchema()),
-    type: _enum(["transaction"])
-  }),
+var RpcLightClientExecutionProofRequestSchema = () => intersection(
+  union([
+    object({
+      senderId: _lazy(() => AccountIdSchema()),
+      transactionHash: _lazy(() => CryptoHashSchema()),
+      type: _enum(["transaction"])
+    }),
+    object({
+      receiptId: _lazy(() => CryptoHashSchema()),
+      receiverId: _lazy(() => AccountIdSchema()),
+      type: _enum(["receipt"])
+    })
+  ]),
   object({
-    receiptId: _lazy(() => CryptoHashSchema()),
-    receiverId: _lazy(() => AccountIdSchema()),
-    type: _enum(["receipt"])
+    lightClientHead: _lazy(() => CryptoHashSchema())
   })
-]);
+);
 var RpcLightClientExecutionProofResponseSchema = () => object({
   blockHeaderLite: _lazy(() => LightClientBlockLiteViewSchema()),
   blockProof: array(_lazy(() => MerklePathItemSchema())),
@@ -4006,6 +4166,46 @@ var StakeActionSchema = () => object({
   publicKey: _lazy(() => PublicKeySchema()),
   stake: string()
 });
+var StateChangeCauseViewSchema = () => union([
+  object({
+    type: _enum(["not_writable_to_disk"])
+  }),
+  object({
+    type: _enum(["initial_state"])
+  }),
+  object({
+    txHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["transaction_processing"])
+  }),
+  object({
+    receiptHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["action_receipt_processing_started"])
+  }),
+  object({
+    receiptHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["action_receipt_gas_reward"])
+  }),
+  object({
+    receiptHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["receipt_processing"])
+  }),
+  object({
+    receiptHash: _lazy(() => CryptoHashSchema()),
+    type: _enum(["postponed_receipt"])
+  }),
+  object({
+    type: _enum(["updated_delayed_receipts"])
+  }),
+  object({
+    type: _enum(["validator_accounts_update"])
+  }),
+  object({
+    type: _enum(["migration"])
+  }),
+  object({
+    type: _enum(["bandwidth_scheduler_state_update"])
+  })
+]);
 var StateChangeKindViewSchema = () => union([
   object({
     accountId: _lazy(() => AccountIdSchema()),
@@ -4024,98 +4224,103 @@ var StateChangeKindViewSchema = () => union([
     type: _enum(["contract_code_touched"])
   })
 ]);
-var StateChangeWithCauseViewSchema = () => union([
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      amount: string(),
-      codeHash: _lazy(() => CryptoHashSchema()),
-      globalContractAccountId: optional(
-        union([_lazy(() => AccountIdSchema()), _null()])
-      ),
-      globalContractHash: optional(
-        union([_lazy(() => CryptoHashSchema()), _null()])
-      ),
-      locked: string(),
-      storagePaidAt: optional(number()),
-      storageUsage: number()
+var StateChangeWithCauseViewSchema = () => intersection(
+  union([
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        amount: string(),
+        codeHash: _lazy(() => CryptoHashSchema()),
+        globalContractAccountId: optional(
+          union([_lazy(() => AccountIdSchema()), _null()])
+        ),
+        globalContractHash: optional(
+          union([_lazy(() => CryptoHashSchema()), _null()])
+        ),
+        locked: string(),
+        storagePaidAt: optional(number()),
+        storageUsage: number()
+      }),
+      type: _enum(["account_update"])
     }),
-    type: _enum(["account_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema())
+      }),
+      type: _enum(["account_deletion"])
     }),
-    type: _enum(["account_deletion"])
-  }),
-  object({
-    change: object({
-      accessKey: _lazy(() => AccessKeyViewSchema()),
-      accountId: _lazy(() => AccountIdSchema()),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accessKey: _lazy(() => AccessKeyViewSchema()),
+        accountId: _lazy(() => AccountIdSchema()),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["access_key_update"])
     }),
-    type: _enum(["access_key_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["access_key_deletion"])
     }),
-    type: _enum(["access_key_deletion"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      gasKey: _lazy(() => GasKeyViewSchema()),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        gasKey: _lazy(() => GasKeyViewSchema()),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["gas_key_update"])
     }),
-    type: _enum(["gas_key_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      index: number(),
-      nonce: number(),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        index: number(),
+        nonce: number(),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["gas_key_nonce_update"])
     }),
-    type: _enum(["gas_key_nonce_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      publicKey: _lazy(() => PublicKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        publicKey: _lazy(() => PublicKeySchema())
+      }),
+      type: _enum(["gas_key_deletion"])
     }),
-    type: _enum(["gas_key_deletion"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      keyBase64: _lazy(() => StoreKeySchema()),
-      valueBase64: _lazy(() => StoreValueSchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        keyBase64: _lazy(() => StoreKeySchema()),
+        valueBase64: _lazy(() => StoreValueSchema())
+      }),
+      type: _enum(["data_update"])
     }),
-    type: _enum(["data_update"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      keyBase64: _lazy(() => StoreKeySchema())
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        keyBase64: _lazy(() => StoreKeySchema())
+      }),
+      type: _enum(["data_deletion"])
     }),
-    type: _enum(["data_deletion"])
-  }),
-  object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema()),
-      codeBase64: string()
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema()),
+        codeBase64: string()
+      }),
+      type: _enum(["contract_code_update"])
     }),
-    type: _enum(["contract_code_update"])
-  }),
+    object({
+      change: object({
+        accountId: _lazy(() => AccountIdSchema())
+      }),
+      type: _enum(["contract_code_deletion"])
+    })
+  ]),
   object({
-    change: object({
-      accountId: _lazy(() => AccountIdSchema())
-    }),
-    type: _enum(["contract_code_deletion"])
+    cause: _lazy(() => StateChangeCauseViewSchema())
   })
-]);
+);
 var StateItemSchema = () => object({
   key: _lazy(() => StoreKeySchema()),
   value: _lazy(() => StoreValueSchema())
@@ -4558,7 +4763,7 @@ Object.entries(PATH_TO_METHOD_MAP).forEach(([path, method]) => {
 var RPC_METHODS = Object.values(PATH_TO_METHOD_MAP);
 
 // Auto-generated static RPC functions for tree-shaking
-// Generated at: 2025-07-26T17:05:05.177Z
+// Generated at: 2025-07-28T13:29:57.104Z
 // Total functions: 28
 //
 // This file is automatically generated by tools/codegen/generate-client-interface.ts