docs: v6.7.0 catch-up

docs.json

@@ -198,7 +198,15 @@
                       "evm/precompiles/cosmwasm-precompiles/bank",
                       "evm/precompiles/cosmwasm-precompiles/cosmwasm"
                     ]
-                  }
+                  },
+                  "evm/precompiles/auth",
+                  "evm/precompiles/authz",
+                  "evm/precompiles/evidence",
+                  "evm/precompiles/feegrant",
+                  "evm/precompiles/mint",
+                  "evm/precompiles/params",
+                  "evm/precompiles/slashing",
+                  "evm/precompiles/upgrade"
                 ]
               }
             ]
@@ -1714,4 +1722,4 @@
   "icons": {
     "library": "fontawesome"
   }
-}
+}

evm/differences-with-ethereum.mdx

@@ -75,7 +75,7 @@
 | DIFFICULTY | Alias of PREVRANDAO | Alias of PREVRANDAO (EIP‑4399) | Returns the same value as PREVRANDAO. |
 | Blob‑related opcodes | Not supported (Pectra without blobs) | Supported post‑Cancun (EIP‑4844) | Blob transactions are not enabled on Sei. |
 
 ### PREVRANDAO
 
 Proof of Stake (PoS) Ethereum uses pseudo‑randomness to determine the next
 validator. Sei does not rely on the same method, so it does not have the
@@ -101,6 +101,10 @@
 Sei computes the block hash from the block header in Tendermint data format.
 As a result, it is different from Ethereum's block hash.
 
+The `BLOCKHASH` opcode returns the correct historical block hash for the previous 256 blocks, matching the EVM Yellow Paper's availability window. Sei maintains an on-chain ring of recent block hashes that is populated during `BeginBlock` from the parent block's hash, backed by a process-local cache, with a fallback to staking historical info. Before this change, `BLOCKHASH` for recent blocks (such as `height - 1`) returned an empty hash. Hashes outside the 256-block window, or hashes of future/current-height blocks, return zero, and `BLOCKHASH` values remain non-interchangeable with Ethereum because of the different header encoding.
+
+{/* For additional context, see the opcode differences table above. */}
+
 ## Base fee & tips
 
 Sei supports all non‑blob transaction types, including the Pectra `SetCode` transaction (EIP‑7702). However, for a legacy (non EIP‑1559)
@@ -210,7 +214,7 @@
 
 </Info>
 
 ## SSTORE gas cost
 
 On Sei, the gas cost of the `SSTORE` opcode is a configurable on-chain parameter. A governance proposal can adjust it without a chain upgrade. This lets governance tune storage costs based on EVM state size and network conditions.
 

evm/evm-parity/evm-compatibility.mdx

@@ -52,7 +52,7 @@ Standard EVM tools (viem, wagmi, ethers, Foundry, and Hardhat) work on Sei for a
 
 | Feature | Sei status | Notes |
 | --- | --- | --- |
-| `eth_getLogs` | Supported | |
+| `eth_getLogs` | Supported with differences | A single query may match at most `max_log_no_block` logs (default 10000) and `max_log_bytes` of estimated heap bytes (default 64 MiB). This applies to both bounded and open-ended block ranges. Exceeding either limit returns an error (`too many logs` / `too many log bytes`) advising you to narrow the block range or filter criteria, rather than silently truncating the result. [See RPC configuration.](/node/node-operators/rpc-configuration) |
 | Filter lifecycle (`eth_newFilter`, `eth_getFilterChanges`, `eth_getFilterLogs`, `eth_uninstallFilter`) | Supported | |
 | WebSocket subscriptions (`eth_subscribe`) | Supported | [See WebSocket Connections.](/evm/evm-parity/websocket) |
 

evm/evm-parity/gas-and-fees.mdx

@@ -61,7 +61,7 @@
 In practice, when your priority tip plus the base fee stays below `maxFeePerGas`, the receipt reports `baseFee + maxPriorityFeePerGas`, not `maxFeePerGas`. To compute what a transaction paid, use the receipt's `effectiveGasPrice`, not `maxFeePerGas`.
 
 
 ## SSTORE cost
 
 On Sei, governance can adjust the gas cost of `SSTORE` (a write to contract storage). The current cost is **72,000 gas** on both Sei Mainnet and Sei Testnet. For details, see [Differences with Ethereum](/evm/differences-with-ethereum#sstore-gas-cost). Treat this number as the current value, not a constant. Do not hard-code storage write estimates in your application.
 
@@ -92,6 +92,48 @@
 
 <Warning>Estimate the absolute storage-write cost with a live `eth_estimateGas` call against a Sei RPC. A Foundry `forge test --gas-report --fork-url <sei rpc>` report forks the chain *state*, but it runs the standard EVM gas schedule of revm. It therefore shows `SSTORE` at the Ethereum cost (approximately 22,100) instead of the Sei cost (approximately 72,000). Use the report for relative profiling of your own logic.</Warning>
 
+
+## Precompile calldata decode cost
+
+Sei's dynamic-gas precompiles (such as bank, wasmd, oracle, ibc, json, distribution, pointer, pointerview, addr, and p256) now charge gas for ABI-decoding a call's calldata *before* the arguments are decoded. The charge covers a length-proportional scan of the input plus the cost of copying any `string` payloads the decoder would materialize — a cost that can be significantly larger than the raw calldata length when a single string is referenced by many array or tuple slots.
+
+The `json`, `p256`, and `pointerview` precompiles use this dynamic gas model as well. Their metering works as follows:
+
+- **`json`** — charges 100 gas per byte of the JSON payload being parsed, consumed against the call's gas meter.
+- **`pointerview`** — self-meters based on the state reads performed during pointer lookups, rather than a flat charge.
+- **`p256`** — charges a fixed **3,450 gas** verification cost, matching RIP-7212's `P256VERIFY`. Because this flat charge is levied outside the verification's panic recovery, a call that forwards too little gas to cover it fails the transaction with an out-of-gas error rather than reverting the call.
+
+Two consequences for callers:
+
+- A precompile call that forwards too little gas to cover the decode is reverted before the precompile runs, instead of being decoded for free.
+- Overall gas used for dynamic-gas precompile calls has increased slightly, since the decode is now metered.
+
+Because this charge depends on the exact shape and size of your calldata, do not hard-code gas limits for precompile calls. Always size them with a live `eth_estimateGas` call against a Sei RPC:
+
+<CodeGroup>
+
+```ts viem
+const gas = await client.estimateGas({
+  account,
+  to: precompileAddress,
+  data: encodedCalldata,
+});
+
+// Add a buffer for safety during high-activity periods
+const gasWithBuffer = (gas * 120n) / 100n; // 20% buffer
+```
+
+```ts ethers
+const gas = await provider.estimateGas({
+  from: signer.address,
+  to: precompileAddress,
+  data: encodedCalldata,
+});
+```
+
+</CodeGroup>
+
+
 ## Summary
 
 | Behavior | Ethereum | Sei |

evm/evm-parity/websocket.mdx

@@ -3,7 +3,7 @@
 description: 'Connecting to Sei via WebSocket for real-time block and event subscriptions'
 ---
 
 # WebSocket connections
 
 Sei supports `eth_subscribe` over WebSocket. With the WebSocket transports in standard libraries, you can subscribe to new blocks, event logs, and pending transactions.
 
@@ -115,6 +115,26 @@
 - Pending transaction subscriptions (`newPendingTransactions`) are supported at the RPC level, but Sei does not guarantee Ethereum-style pending state visibility.
 
 
+## Frame size and concurrency limits
+
+The WebSocket plane shares its admission-control settings with the HTTP JSON-RPC plane through the `[evm]` section of `app.toml`. Two limits apply to every WebSocket connection:
+
+### Frame size (`max_request_body_bytes`)
+
+Each inbound WebSocket frame is capped by `[evm].max_request_body_bytes`, the same knob that bounds HTTP request bodies. The default is 5 MiB (`5242880`). Frames larger than this limit cause the connection to close with WebSocket close code `1009` (message too big); no JSON-RPC error response is returned.
+
+<Warning>
+  Earlier node releases used a hardcoded 10 MiB frame cap on the WebSocket plane. Both planes now share `max_request_body_bytes` with a 5 MiB default. Operators whose WebSocket clients send frames in the 5–10 MiB range (for example large `eth_sendRawTransaction` batches or wide filter payloads) should set `max_request_body_bytes = 10485760` in `app.toml` before upgrading. Note that this also raises the HTTP body limit to 10 MiB.
+</Warning>
+
+### Concurrent request budget (`max_concurrent_request_bytes` and `ws_admission_timeout`)
+
+`[evm].max_concurrent_request_bytes` bounds the total size of JSON-RPC request bytes admitted for processing concurrently. The WebSocket plane and the HTTP plane each get their own independent budget, so peak in-flight request bytes process-wide can reach twice this value.
+
+When a WebSocket connection cannot be admitted immediately because the budget is exhausted, it blocks and waits for budget to free up. `[evm].ws_admission_timeout` bounds how long it waits (default `30s`; zero or negative values use the go-ethereum default of 30s). If the wait expires, the peer receives JSON-RPC error `-32005` ("timed out waiting for concurrent request-byte budget") and the connection is closed, dropping any active subscriptions along with it.
+
+
+
 
 ## `newHeads` under Autobahn consensus
 

evm/precompiles/auth.mdx

@@ -0,0 +1,111 @@
+---
+title: Auth Precompile
+description: Query account information, auth module parameters, and the next account number from the EVM.
+---
+
+The Auth precompile exposes read-only access to the Cosmos SDK `auth` module, letting Solidity contracts look up account details, the auth module parameters, and the next account number. All of its methods are views and never mutate state.
+
+## Address
+
+The Auth precompile is available at the fixed address `0x000000000000000000000000000000000000100D`.
+
+## Solidity Interface
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+address constant AUTH_PRECOMPILE_ADDRESS = 0x000000000000000000000000000000000000100D;
+
+IAuth constant AUTH_CONTRACT = IAuth(AUTH_PRECOMPILE_ADDRESS);
+
+interface IAuth {
+    // Queries
+
+    /**
+     * @notice Get account information for the given address
+     * @param addr The EVM address (must be associated with a Sei address)
+     * @return account Account details
+     */
+    function account(
+        address addr
+    ) external view returns (Account memory account);
+
+    /**
+     * @notice Get all accounts, paginated
+     * @param pageKey Pagination key (empty bytes for the first page)
+     * @return response Accounts response with pagination
+     */
+    function accounts(
+        bytes memory pageKey
+    ) external view returns (AccountsResponse memory response);
+
+    /**
+     * @notice Get the auth module parameters
+     * @return params Auth module parameters
+     */
+    function params() external view returns (AuthParams memory params);
+
+    /**
+     * @notice Get the next account number
+     * @return count The next account number
+     */
+    function nextAccountNumber() external view returns (uint64 count);
+
+    // Structs
+
+    struct Account {
+        string accountAddress;
+        uint64 accountNumber;
+        uint64 sequence;
+    }
+
+    struct AccountsResponse {
+        Account[] accounts;
+        bytes nextKey;
+    }
+
+    struct AuthParams {
+        uint64 maxMemoCharacters;
+        uint64 txSigLimit;
+        uint64 txSizeCostPerByte;
+        uint64 sigVerifyCostEd25519;
+        uint64 sigVerifyCostSecp256k1;
+        bool disableSeqnoCheck;
+    }
+}
+```
+
+## Methods
+
+### account
+
+```solidity
+function account(address addr) external view returns (Account memory account);
+```
+
+Returns the `Account` details (address, account number, and sequence) for the Sei address associated with `addr`. The EVM address must be associated with a Sei address; if it is not, or if no account exists for the resolved address, the call reverts.
+
+### accounts
+
+```solidity
+function accounts(bytes memory pageKey) external view returns (AccountsResponse memory response);
+```
+
+Returns a paginated list of all accounts. Pass empty `bytes` for the first page, then supply the returned `nextKey` to fetch subsequent pages.
+
+### params
+
+```solidity
+function params() external view returns (AuthParams memory params);
+```
+
+Returns the auth module parameters, including `maxMemoCharacters`, `txSigLimit`, `txSizeCostPerByte`, `sigVerifyCostEd25519`, `sigVerifyCostSecp256k1`, and `disableSeqnoCheck`.
+
+### nextAccountNumber
+
+```solidity
+function nextAccountNumber() external view returns (uint64 count);
+```
+
+Returns the next account number. This is a read-only view and does not increment the persisted global account number counter, so repeated calls return the same value.

evm/precompiles/authz.mdx

@@ -0,0 +1,151 @@
+---
+title: Authz Precompile
+description: Query authorization grants from the Cosmos authz module directly from EVM smart contracts on Sei.
+---
+
+The Authz precompile exposes read-only queries from the Cosmos `authz` module to EVM smart contracts. It lets contracts inspect authorization grants between a granter and a grantee, as well as all grants issued or received by a given account.
+
+## Address
+
+The Authz precompile is available at the fixed address:
+
+```
+0x000000000000000000000000000000000000100E
+```
+
+## Interface
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+address constant AUTHZ_PRECOMPILE_ADDRESS = 0x000000000000000000000000000000000000100e;
+
+IAuthz constant AUTHZ_CONTRACT = IAuthz(AUTHZ_PRECOMPILE_ADDRESS);
+
+interface IAuthz {
+    // Queries
+
+    /**
+     * @notice Get grants between a granter and a grantee, optionally filtered by message type URL
+     * @param granter The granter's EVM address (must be associated with a Sei address)
+     * @param grantee The grantee's EVM address (must be associated with a Sei address)
+     * @param msgTypeUrl The message type URL to filter by (empty string for all)
+     * @param pageKey Pagination key (empty bytes for the first page)
+     * @return response Grants response with pagination
+     */
+    function grants(
+        address granter,
+        address grantee,
+        string memory msgTypeUrl,
+        bytes memory pageKey
+    ) external view returns (GrantsResponse memory response);
+
+    /**
+     * @notice Get all grants granted by a granter
+     * @param granter The granter's EVM address (must be associated with a Sei address)
+     * @param pageKey Pagination key (empty bytes for the first page)
+     * @return response Grant authorizations response with pagination
+     */
+    function granterGrants(
+        address granter,
+        bytes memory pageKey
+    ) external view returns (GrantAuthorizationsResponse memory response);
+
+    /**
+     * @notice Get all grants granted to a grantee
+     * @param grantee The grantee's EVM address (must be associated with a Sei address)
+     * @param pageKey Pagination key (empty bytes for the first page)
+     * @return response Grant authorizations response with pagination
+     */
+    function granteeGrants(
+        address grantee,
+        bytes memory pageKey
+    ) external view returns (GrantAuthorizationsResponse memory response);
+
+    // Structs
+
+    struct Grant {
+        bytes authorization;
+        int64 expiration;
+    }
+
+    struct GrantsResponse {
+        Grant[] grants;
+        bytes nextKey;
+    }
+
+    struct GrantAuthorization {
+        string granter;
+        string grantee;
+        bytes authorization;
+        int64 expiration;
+    }
+
+    struct GrantAuthorizationsResponse {
+        GrantAuthorization[] grants;
+        bytes nextKey;
+    }
+}
+```
+
+## Methods
+
+All methods on this precompile are read-only `view` queries. They do not mutate state.
+
+### grants
+
+Returns the grants between a specific granter and grantee, optionally filtered by a message type URL.
+
+```solidity
+function grants(
+    address granter,
+    address grantee,
+    string memory msgTypeUrl,
+    bytes memory pageKey
+) external view returns (GrantsResponse memory response);
+```
+
+- `granter` — the granter's EVM address, which must be associated with a Sei address.
+- `grantee` — the grantee's EVM address, which must be associated with a Sei address.
+- `msgTypeUrl` — the message type URL to filter by. Pass an empty string to return all grants.
+- `pageKey` — the pagination key; pass empty bytes to request the first page.
+
+Each returned `Grant` contains the `authorization` encoded as JSON bytes and an `expiration` expressed as a Unix timestamp in seconds. The `nextKey` field of the response is the pagination key for the next page (empty when the result set is exhausted).
+
+### granterGrants
+
+Returns every grant issued by a given granter.
+
+```solidity
+function granterGrants(
+    address granter,
+    bytes memory pageKey
+) external view returns (GrantAuthorizationsResponse memory response);
+```
+
+- `granter` — the granter's EVM address, which must be associated with a Sei address.
+- `pageKey` — the pagination key; pass empty bytes to request the first page.
+
+Each returned `GrantAuthorization` includes the bech32 `granter` and `grantee` addresses, the `authorization` encoded as JSON bytes, and an `expiration` as a Unix timestamp in seconds.
+
+### granteeGrants
+
+Returns every grant received by a given grantee.
+
+```solidity
+function granteeGrants(
+    address grantee,
+    bytes memory pageKey
+) external view returns (GrantAuthorizationsResponse memory response);
+```
+
+- `grantee` — the grantee's EVM address, which must be associated with a Sei address.
+- `pageKey` — the pagination key; pass empty bytes to request the first page.
+
+The response mirrors `granterGrants`, listing each `GrantAuthorization` with its granter, grantee, JSON-encoded authorization, and expiration.
+
+## Notes
+
+- The addresses passed to these methods must be associated with a Sei address; querying an unassociated address reverts.
+- The `authorization` field is returned as JSON-encoded bytes and includes an `@type` discriminator (for example, a `SendAuthorization`).

evm/precompiles/cosmwasm-precompiles/addr.mdx

@@ -65,6 +65,8 @@ function associatePubKey(
 ) external returns (string memory seiAddr, address evmAddr);
 ```
 
+<Info> Both `associate()` and `associatePubKey()` are classified as transaction (state-mutating) methods on the precompile — the precompile's `IsTransaction` returns true for each of them — so each must be sent as a transaction rather than called as a read-only view. </Info>
+
 ### Query functions
 
 ```solidity