…fier` (#15430)

`record_contract_call` was using AccountContract (the on-chain stored
value) to determine which contract code hash to record for distribution
to validators. This is incorrect for the old ETH wallet accounts: the
stored hash is the magic bytes hash, not the actual contract code hash,
and for accounts using global contracts the wrong trie key was used.
This is a better alternative to #15415.

- Move record_contract_call from TrieUpdate method to a standalone
function in function_call.rs that dispatches on
RuntimeContractIdentifier, which already has the correctly resolved code
hash and contract type
- Remove GlobalEthWallet variant and old_hash() — no longer needed since
the standalone function records the correct code hash directly from the
resolved identifier
- Remove LegacyEthWallet::magic_bytes_hash() as it has no remaining
callers
- Carry GlobalContractIdentifier in the Global variant and AccountId in
the AccountLocal variant so record_contract_call can construct the
correct trie key without extra arguments
- Convert AccountLocal and Global to named-field struct variants
- Drop Copy from RuntimeContractIdentifier since
GlobalContractIdentifier contains AccountId
- Add a regression test: extend
test_eth_implicit_global_contract_mainnet_upgrade with a stateless
validator that has its compiled contract cache cleared, verifying the
global contract is properly distributed via the witness

Stacked on #15429.

---------

Co-authored-by: Claude Opus 4.6 <[email protected]>

…ract resolution (#15429)

Follow-up to the `record_contract_call` issue introduced in #15132. The
root cause was that `AccountContract` (as stored on-chain) doesn't
always represent the effective contract being executed — ETH implicit
accounts with magic bytes actually run a different contract than what
their `code_hash` field says. The resolution logic lived only inside
`RuntimeContractExt` (used by the VM), so other runtime code paths like
`record_contract_call` received raw `code_hash` values that didn't match
the actually-executed contract. While #15415 patched the immediate
testnet issue, the fundamental problem remained: contract resolution was
duplicated, incomplete, and error-prone.

This PR introduces `RuntimeContractIdentifier` — a lightweight enum that
eagerly resolves the effective contract at a single point, then gets
passed through the entire runtime instead of raw `code_hash:
CryptoHash`. This makes it impossible for different code paths to
disagree about which contract is being executed.

- Move contract resolution logic (ETH implicit accounts, global
contracts, legacy wallet contracts) from lazy evaluation inside
`RuntimeContractExt` to eager resolution at
`RuntimeContractIdentifier::resolve()` construction time
- Introduce `LegacyEthWallet` enum in `near-wallet-contract` to identify
wallet contract variants by chain
- Simplify `RuntimeContractExt` to just `storage + identifier`, removing
`account_id`, `config`, `chain_id` fields
- Centralize all special-case contract handling in
`RuntimeContractIdentifier::resolve()` in the new `contract_code` module
- Move `AccountContractAccessExt` and `GlobalContractAccessExt` traits
from `global_contracts` to `contract_code` module
- Pass `RuntimeContractIdentifier` through the runtime instead of raw
`code_hash: CryptoHash`

<details>
<summary>Proof that this is a pure refactor (no behavior
changes)</summary>

Traced every `AccountContract` variant through every code path (lib.rs
main execution, pipelining, state_viewer, function_call) comparing old
vs new behavior:

**`AccountContract::None`**:
- Old: `AccountContractAccessExt::hash()` → `NotDeployed` →
`CryptoHash::default()`. `RuntimeContractExt::get_code()` →
`storage.get(default)` → None. `record_contract_call` gets `default`.
- New: `RuntimeContractIdentifier::None`. `hash()` → default,
`get_code()` → None. `old_hash()` → default.
- **Identical.**

**`AccountContract::Local(h)` — non-eth-implicit**:
- Old: `code_hash = h`. `hash()` = h, `get_code()` = `storage.get(h)`.
`record_contract_call` gets h.
- New: `AccountLocal(h)`. `hash()` = h, `get_code()` = `storage.get(h)`.
`old_hash()` = h.
- **Identical.**

**`AccountContract::Local(h)` — eth implicit, wallet match,
`eth_implicit_global_contract` = false**:
- Old: `code_hash = h` (magic bytes hash). `RuntimeContractExt::hash()`
→ wallet match → `*wc.hash()` (actual contract hash). `get_code()` →
`Some(wc)`. `record_contract_call` gets h.
- New: `LegacyEthWallet(legacy)`. `hash()` =
`*legacy.contract().hash()`. `get_code()` = `Some(legacy.contract())`.
`old_hash()` = `legacy.magic_bytes_hash()` = h.
- **Identical.**

**`AccountContract::Local(h)` — eth implicit, wallet match,
`eth_implicit_global_contract` = true**:
- Old: `code_hash = h` (magic bytes). `RuntimeContractExt::hash()` →
wallet match → `eth_wallet_global_contract_hash(chain_id)`. `get_code()`
→ `storage.get(global_hash)`. `record_contract_call` gets h.
- New: `GlobalEthWallet { account_stored_hash: h, global_contract_hash:
global_hash }`. `hash()` = `global_hash`. `get_code()` =
`storage.get(global_hash)`. `old_hash()` = h.
- **Identical.** (The `GlobalEthWallet` variant exists specifically to
preserve this: `old_hash()` returns the account-stored magic bytes hash
for `record_contract_call`, while `hash()` returns the global contract
hash for VM execution.)

**`AccountContract::Local(h)` — eth implicit, NO wallet match**:
- Old: `wallet_contract(h)` returns None → falls through → `hash()` = h,
`get_code()` = `storage.get(h)`. `record_contract_call` gets h.
- New: `LegacyEthWallet::resolve(h)` returns None → `AccountLocal(h)`.
Same behavior.
- **Identical.**

**`AccountContract::Global(h)`**:
- Old: `AccountContractAccessExt::hash()` → `CodeHash(h)` → returns h.
`hash()` = h, `get_code()` = `storage.get(h)`. `record_contract_call`
gets h.
- New: `resolve()` → `CodeHash(h)` → `Global(h)`. Same behavior.
- **Identical.**

**`AccountContract::GlobalByAccount(id)`**:
- Old: `AccountContractAccessExt::hash()` → `AccountId(id)` →
`gci.hash(store)` with `DEFAULT` access → resolved hash. Error message:
`"Global contract identifier not found"`. `hash()` = resolved,
`get_code()` = `storage.get(resolved)`. `record_contract_call` gets
resolved.
- New: `resolve()` → `AccountId(id)` → `gci.hash(store, DEFAULT)` →
resolved hash → `Global(resolved)`. Error message: `"Global contract
identifier not found"`. Same behavior.
- **Identical.**

**Pipelining**: Old code matched `account.contract()` to extract
`code_hash` and passed it to `RuntimeContractExt { code_hash,
account_id, config, chain_id }`. New code does block checks first, then
calls `RuntimeContractIdentifier::resolve()` with `NO_SIDE_EFFECTS`. The
`GlobalByAccount` trie lookup uses the same `get_ref` with
`NO_SIDE_EFFECTS`. All `Contract` trait method results are identical.

**State viewer**: Same analysis as lib.rs — uses `DEFAULT` access,
identical results.

</details>

---------

Co-authored-by: Claude Opus 4.6 <[email protected]>