> **Can't find what you're looking for?** Use `search_docs` on the docs MCP server at `https://docs.prividium.com/api/mcp` to find what you need. > > **Have feedback?** Use `submit_feedback` on the same MCP server. :::note[ACCESS LEVELS] | Label | Description | | ------------------------ | -------------------------------------------------------------- | | **Public** | No authentication required | | **Unrestricted** | Requires authentication; forwarded without restrictions | | **Forbidden** | Blocked; requires Full Sequencer RPC Access role | | **Full Read Access** | Requires Full Read Access (or Full Sequencer RPC Access) role | | **Current User Only** | Requires authentication; validates address belongs to caller | | **Permission Validated** | Requires authentication; checks contract-level permissions | | **Filtered** | Requires authentication; response filtered by user permissions | | **Mocked** | Returns a predefined constant value | | **Delegated** | Requires service authentication; forwarded without filtering | | **Bundler** | Requires authentication; validates ERC-4337 UserOperation | | **Deprecated** | Scheduled for removal | ::: ## Base RPC Methods Available at the `/rpc` endpoint. Public methods are accessible anonymously; non-public methods require authenticated user sessions. | Method | Access Level | | -------------------------------------------- | ------------------------------ | | `debug_getRawHeader` | Forbidden | | `debug_getRawBlock` | Forbidden | | `debug_getRawTransaction` | Forbidden | | `debug_getRawTransactions` | Forbidden | | `debug_getRawReceipts` | Forbidden | | `debug_traceBlock` | Forbidden | | `debug_traceBlockByHash` | Forbidden | | `debug_traceBlockByNumber` | Forbidden | | `debug_traceTransaction` | Forbidden | | `debug_traceCall` | Forbidden | | `debug_traceCallMany` | Forbidden | | `debug_chainConfig` | Forbidden | | `debug_codeByHash` | Forbidden | | `eth_protocolVersion` | Unrestricted | | `eth_syncing` | Unrestricted | | `eth_coinbase` | Unrestricted | | `eth_accounts` | Forbidden | | `eth_blockNumber` | Public | | `eth_chainId` | Public | | `eth_getBlockByHash` | Filtered | | `eth_getBlockByNumber` | Filtered | | `eth_getBlockTransactionCountByHash` | Filtered | | `eth_getBlockTransactionCountByNumber` | Filtered | | `eth_getUncleCountByBlockHash` | Forbidden | | `eth_getUncleCountByBlockNumber` | Forbidden | | `eth_getUncleByBlockHashAndIndex` | Forbidden | | `eth_getUncleByBlockNumberAndIndex` | Forbidden | | `eth_getRawTransactionByHash` | Forbidden | | `eth_getTransactionByHash` | Filtered | | `eth_getBlockReceipts` | Filtered | | `eth_getRawTransactionByBlockHashAndIndex` | Forbidden | | `eth_getTransactionByBlockHashAndIndex` | Forbidden | | `eth_getRawTransactionByBlockNumberAndIndex` | Forbidden | | `eth_getTransactionByBlockNumberAndIndex` | Forbidden | | `eth_getTransactionBySenderAndNonce` | Forbidden | | `eth_getTransactionReceipt` | Filtered | | `eth_getBalance` | Current User Only | | `eth_getStorageAt` | Forbidden | | `eth_getTransactionCount` | Current User Only | | `eth_getCode` | Current User Only | | `eth_getHeaderByNumber` | Forbidden | | `eth_getHeaderByHash` | Forbidden | | `eth_simulateV1` | Forbidden | | `eth_call` | Permission Validated | | `eth_callMany` | Forbidden | | `eth_createAccessList` | Forbidden | | `eth_estimateGas` | Permission Validated | | `eth_gasPrice` | Public | | `eth_getAccount` | Forbidden | | `eth_maxPriorityFeePerGas` | Unrestricted | | `eth_blobBaseFee` | Forbidden | | `eth_feeHistory` | Forbidden | | `eth_sendTransaction` | Forbidden | | `eth_sendRawTransaction` | Permission Validated, Sync (†) | | `eth_sendRawTransactionSync` | Forbidden | | `eth_sign` | Forbidden | | `eth_signTransaction` | Forbidden | | `eth_signTypedData` | Forbidden | | `eth_getProof` | Forbidden | | `eth_getAccountInfo` | Forbidden | | `eth_newFilter` | Full Read Access | | `eth_newBlockFilter` | Full Read Access | | `eth_newPendingTransactionFilter` | Forbidden | | `eth_getFilterChanges` | Full Read Access | | `eth_getFilterLogs` | Full Read Access | | `eth_uninstallFilter` | Full Read Access | | `eth_getLogs` | Filtered | | `eth_subscribe` | Forbidden | | `eth_unsubscribe` | Forbidden | | `net_version` | Public | | `ots_getHeaderByNumber` | Forbidden | | `ots_hasCode` | Forbidden | | `ots_getApiLevel` | Forbidden | | `ots_getInternalOperations` | Forbidden | | `ots_getTransactionError` | Forbidden | | `ots_traceTransaction` | Forbidden | | `ots_getBlockDetails` | Forbidden | | `ots_getBlockDetailsByHash` | Forbidden | | `ots_getBlockTransactions` | Forbidden | | `ots_searchTransactionsBefore` | Forbidden | | `ots_searchTransactionsAfter` | Forbidden | | `ots_getTransactionBySenderAndNonce` | Forbidden | | `ots_getContractCreator` | Forbidden | | `web3_clientVersion` | Public | | `web3_sha3` | Forbidden | | `txpool_inspect` | Forbidden | | `txpool_content` | Forbidden | | `txpool_status` | Forbidden | | `unstable_getBatchByBlockNumber` | Forbidden | | `unstable_getLocalRoot` | Forbidden | | `zks_getBridgeContracts` | Forbidden | | `zks_getBytecodeSupplierContract` | Forbidden | | `zks_getBridgehubContract` | Unrestricted | | `zks_getL2ToL1LogProof` | Unrestricted | | `zks_getGenesis` | Unrestricted | | `zks_getBlockMetadataByNumber` | Forbidden | | `zks_getProof` | Forbidden | | `prividium_accountDataDisclosure` (‡) | Permission Validated | | `prividium_storageDisclosureContract` (‡) | Permission Validated | | `prividium_tokenSupplyDisclosure` (‡) | Permission Validated | | `prividium_tokenBalanceDisclosure` (‡) | Permission Validated | | `who_am_i` | Deprecated | :::note[(‡) Selective disclosure is disabled by default] The `prividium_*Disclosure` methods are only registered when the zone sets `DISCLOSURE_METHODS_ENABLED=true`; otherwise calls return a method-not-found error. The feature is off by default because eth\_call-based disclosures carry integrity limitations — see [Selective Disclosure Integrity Limits](/developers/applications/security-limitations#5-selective-disclosure-integrity-limits-eth_call-disclosures). ::: :::note[(†) `eth_sendRawTransaction` is sync-backed] The proxy still exposes `eth_sendRawTransaction` and returns a tx hash on success, but on zksync-os chains it internally forwards through the chain's `eth_sendRawTransactionSync` so authoritative block-build rejections surface as JSON-RPC errors instead of stuck-in-mempool txs. Callers should handle two extra error codes on this method: * `-32003` — tx rejected at execution (policy denial or `InvalidTransaction`). Will not be mined. * `-32005` — sequencer rate limit. The tx was not admitted; retry after `error.data.retryAfterMs`. A tx that is admitted but not mined within the chain's sync timeout returns its hash; poll `eth_getTransactionReceipt` to confirm it mined. See [RPC Error Codes](/rpc/rpc-error-codes#chain-side-errors-on-eth_sendrawtransaction). ::: :::note[Supported transaction envelopes] `eth_sendRawTransaction` on `/rpc` and `/rpc/wallet/:token` accepts legacy (type 0), EIP-2930 (type 1) and EIP-1559 (type 2) transactions. EIP-4844 blob transactions (type 3) and EIP-7702 set-code transactions (type 4) are rejected with `-32602 Unsupported transaction` before any permission check. The proxy authorizes a transaction from its `to`, calldata and value, and neither a blob nor a code delegation is visible there. ::: :::note[Native transfers and empty calldata] `eth_sendRawTransaction` needs no permission row for a bare native transfer to an address without code, but the signer must be a wallet of the authenticated caller. Anonymous callers receive `-32090` (authentication required); transfers signed by a wallet not associated with the caller receive `-32001 Forbidden`. `eth_call` and `eth_estimateGas` always require an authenticated caller. A call with empty calldata to an address with code runs that contract's `receive()` or `fallback()`, so it needs `from` and is authorized against the contract's `receive()` permission, the same rule `eth_sendRawTransaction` applies. A call with empty calldata to an address without code only checks that `from` belongs to the caller; `from` may be omitted. The code check and the forwarded call use the same block: a tag such as `latest` is first pinned to a block number. `pending` and EIP-1898 block objects such as `{ blockHash }` always take the contract permission check. Ordinary native-transfer simulations to EOAs are therefore refused with `-32001 Forbidden` for those parameters; use `latest` or an explicit block number instead. Empty-calldata simulations can reveal whether an address has code: an EOA call can succeed while an unauthorized contract call returns `Forbidden`. This limited disclosure remains possible alongside existing gas and transaction outcomes, even when `eth_getCode` is restricted. For EIP-712 domain discovery, a signed-in user may omit `from` on an `eth_call` whose calldata is exactly the `eip712Domain()` selector. The contract's function permission, or its template permission, must authorize that user. Contract permissions override template permissions, and organization restrictions still apply. Public and role-based rules work normally. Argument restrictions fail without a caller wallet; an OR rule can still allow access through the user's role. Without a matching permission, the call is refused. Tenant and M2M authentication still require `from` to identify the user. Other contract calls require an associated `from` address. The global `eip712Domain()` exemption has been removed: calls with `from` also need a matching permission. Before upgrading, ensure that both the application contract and the SSO account have a domain-read permission allowing the signing user. The SSO signer reads the application's domain first, then the account's domain. Local development grants public read access through the `sso-smart-account` template. Verify that template's permissions and account registrations in each deployed SSO zone; each application needs its own contract or template permission. There is no bytecode-based exemption. Calls without `from` use the zero address as `msg.sender`, so only grant this permission where exposing the domain read is intended. When the sequencer enforces read simulations through the policy listener, it also needs an associated `from` address to identify the user. The proxy's authenticated session is not forwarded to that listener. Calls without `from`, including domain reads and empty-calldata simulations, therefore fail there, even with a public permission. SSO signing flows that omit `from` remain unsupported under this enforcement mode. Clients must supply an associated `from` address and have the required method permission. ::: ## Bundler RPC Methods (ERC-4337) Available at `/rpc` when the bundler is enabled. Requires account abstraction support. | Method | Access Level | | ------------------------------ | ------------ | | `eth_sendUserOperation` | Bundler | | `eth_estimateUserOperationGas` | Bundler | | `eth_getUserOperationByHash` | Bundler | | `eth_getUserOperationReceipt` | Bundler | | `eth_supportedEntryPoints` | Bundler | :::note[`eth_estimateUserOperationGas` takes no state overrides] A request carrying the optional third argument, state overrides, is refused with `-32001` before it reaches the bundler, as `eth_call` refuses one. ::: ## Service RPC Methods (legacy) Available at the `/rpc/service` endpoint for service-to-service integration (e.g. webhooks). Service authentication is a legacy mechanism; new machine integrations use M2M applications and the standard `/rpc` endpoint. | Method | Access Level | | --------------------------- | ------------ | | `eth_blockNumber` | Delegated | | `eth_getBlockByNumber` | Delegated | | `eth_getLogs` | Delegated | | `eth_getTransactionByHash` | Delegated | | `eth_getTransactionReceipt` | Delegated | ## Wallet RPC Methods Available at the `/rpc/wallet/:token` endpoint for pre-authorized transaction sessions. | Method | Access Level | | ----------------------------------------- | ------------------------------ | | `eth_chainId` | Public | | `eth_blockNumber` | Public | | `eth_sendRawTransaction` | Permission Validated, Sync (†) | | `eth_getBlockByHash` | Mocked | | `eth_getBlockByNumber` | Mocked | | `eth_getTransactionReceipt` | Filtered | | `eth_getBalance` | Filtered | | `eth_getCode` | Mocked | | `eth_gasPrice` | Public | | `web3_clientVersion` | Public | | `eth_call` | Forbidden | | `eth_getStorageAt` | Forbidden | | `eth_newFilter` | Forbidden | | `eth_newPendingTransactionFilter` | Forbidden | | `eth_getTransactionByBlockHashAndIndex` | Forbidden | | `eth_getTransactionByBlockNumberAndIndex` | Forbidden | | `eth_accounts` | Forbidden | | `eth_estimateGas` | Forbidden | | `eth_getTransactionCount` | Forbidden | | `eth_getTransactionByHash` | Forbidden | | `eth_getLogs` | Forbidden | | `eth_feeHistory` | Forbidden | | `eth_maxPriorityFeePerGas` | Forbidden | | `eth_getFilterLogs` | Forbidden | | `eth_getFilterChanges` | Forbidden | | `eth_uninstallFilter` | Forbidden | | `eth_newBlockFilter` | Forbidden | | `eth_getBlockTransactionCountByNumber` | Forbidden | | `eth_getBlockTransactionCountByHash` | Forbidden | | `eth_getBlockReceipts` | Forbidden | | `eth_protocolVersion` | Forbidden | | `eth_syncing` | Forbidden | | `eth_coinbase` | Forbidden | | `eth_getCompilers` | Forbidden | | `eth_hashrate` | Forbidden | | `eth_getUncleCountByBlockHash` | Forbidden | | `eth_getUncleCountByBlockNumber` | Forbidden | | `eth_mining` | Forbidden | | `net_version` | Forbidden |