Wallet, Network and Quote Learning Guides

Start with the problem you can observe

If the wallet looks empty, check the account and network before investigating a quote. If a token appears missing, compare its full contract address on the correct explorer. If you have a transaction hash, investigate that transaction separately from any estimate displayed in a form.

A quote, token permission and confirmed transfer provide different evidence. Reading a quote does not change a balance. An approval does not establish that an exchange happened. A transaction lookup should identify the chain and execution status rather than rely on a success message from a website.

Identify the network

• Identify Base Mainnet Before Using a Wallet

  Check Base chain ID 8453, its explorer and the difference between mainnet, Base Sepolia and a local fork before interpreting wallet balances.

Identify the asset

• Native ETH and WETH: Check the Right Balance

  Understand why native ETH and WETH have separate balances, which asset RunixCoin quotes on Base, and why renaming or selecting a token does not convert it.

• Verify Native USDC on Base by Network and Contract

  Use Circle’s registry to identify native USDC on Base and distinguish it from Ethereum USDC, bridged tokens and similarly named assets.

Understand an estimate

• Read a RunixCoin Base WETH-to-USDC Quote

  Walk through the quote-only RunixCoin form: exact WETH input, estimated USDC after the disclosed interface fee, separate gas and unavailable execution.

Review costs and permissions

• Plan a Native ETH Gas Reserve on Base

  Separate native ETH gas from token amounts on Base, understand why a fixed reserve cannot be guaranteed, and review estimates without signing or spending.

• Review an Exact Token Approval Before Signing

  Understand the owner, token, spender and amount in a token approval, why an allowance is not a swap, and how to review permissions without signing.

• Calculate Slippage and Read Minimum Output

  Use a hypothetical minimum-output calculation to distinguish slippage tolerance from interface fees, gas and an estimated swap result.

Investigate a problem

• Investigate a Pending Transaction Without Resubmitting

  Use the correct network, transaction hash and receipt to distinguish a pending transaction from an unsubmitted request or failed execution.

• Find a Balance When the Wallet Shows the Wrong Network

  Compare the account, network, explorer and token contract to investigate an apparently missing balance without moving funds or sharing recovery information.

Understand wallet responsibilities

• Connecting a Wallet Is Different From Authorizing an Action

  Distinguish a website connection, message signature, token approval and transaction, and understand why disconnecting does not erase on-chain allowances.

Practical wallet checks

• Before Your First RunixCoin Wallet Connection

  Inspect the site address, current quote limits, wallet choices and recovery responsibilities before deciding whether to connect to RunixCoin.

• Confirm Which Wallet Account a Website Is Using

  Compare the wallet’s selected account, site-visible public address and explorer address when several accounts or wallet connections are available.

• Check a Receive Address After Scanning Its QR Code

  Review the decoded address, selected network and asset separately when using a wallet receive QR code; scanning alone does not verify a destination.

• Understand RunixCoin’s Mainnet Native-Coin Rows

  Learn what the inspected Ethereum, Polygon and Base native-balance rows query, and why missing ERC-20 tokens or failed requests are separate issues.

• Check Public Wallet Evidence Without Connecting

  Use public addresses, network explorers and transaction receipts to investigate balances and activity without wallet signatures or token approvals.

• Share Useful Wallet Troubleshooting Details Carefully

  Prepare a minimal troubleshooting note with network, redacted account context, exact symptoms and public transaction evidence while keeping secrets private.

Token identity and units

• Identify a Token by Network and Contract, Not Symbol

  Build a token identity check from an authoritative registry, the selected network and full contract address before interpreting a balance or quote.

• Understand Token Decimals Before Reading a Raw Amount

  Use a token’s verified decimals to interpret integer balances, distinguish display rounding from lost funds and avoid confusing raw units with whole tokens.

Input and quote troubleshooting

• Enter an Exact WETH Amount in the Public Quote Form

  See accepted decimal WETH formats, eighteen-place precision, examples rejected before a request and why a valid amount does not verify a spendable balance.

• What to Check After a RunixCoin Quote Times Out

  Interpret the public form’s twenty-second quote deadline, retry deliberately and separate a missing estimate from a pending blockchain transaction.

Transaction outcome investigations

• Read a Failed Transaction Receipt Before Retrying

  Interpret a failed receipt, separate included execution from quote errors, and gather useful evidence before deciding whether another request is appropriate.

• Investigate a Successful Transaction With No Expected Token Row

  Check the operation, recipient, token contract and network when a successful receipt does not match the token balance you expected to see.

• Check What Happened When No Transaction Hash Is Available

  Separate quotes, rejected prompts, signatures and possible submissions when no hash is visible, using wallet activity and public evidence without resending.

• A Confirmed Approval Does Not Prove a Swap Was Sent

  Track permission changes and exchange transactions separately when an approval succeeded but there is no evidence of the expected swap or output.

• Investigate Unexpected Native Value in a Wallet Request

  Separate native transaction value from token amounts and gas, then compare an unexpected wallet request with the intended action before signing.

Understanding network cost evidence

• Why a Failed Included Transaction Can Still Cost Gas

  Distinguish an included revert from an unsubmitted error, inspect actual gas evidence and keep previous approvals separate when investigating a network charge.

• Distinguish a Gas Limit From a Gas Price

  Read gas units, price per unit and a hypothetical execution-fee calculation without confusing a transaction limit with its actual cost or a complete Base fee.

• Investigate Insufficient Gas With a Token Balance Present

  Compare the fee-paying balance, account, network and transaction value when token holdings appear sufficient but a wallet reports insufficient transaction funds.

Token holdings and permissions

• Separate Token Ownership From Permission to Spend

  Compare a token balance with an owner-to-spender allowance, understand why one can be positive while the other is zero, and review both without approving.

• Handle an Unfamiliar Token Without Following Its Instructions

  Investigate an unexpected token safely, separate an unsolicited holding from a wallet compromise, and avoid claim links, misleading prices and signature requests.

Network identity, data and test environments

• Use Base Sepolia Evidence Without Confusing It With Mainnet

  Separate Base Sepolia practice from mainnet readiness, identify test assets, and record what a test actually demonstrates before drawing conclusions.

• Compare Decimal and Hexadecimal Chain IDs Correctly

  Read numeric chain identifiers in wallet and RPC screens, compare decimal and hexadecimal values, and understand why a matching number is only one check.

• Why a Local Base Fork Is Not a Mainnet Swap Test

  Understand copied chain state, local transaction results and fork resets, and separate simulation evidence from an actually included mainnet transaction.

• What an RPC Response Can and Cannot Establish

  Identify which wallet facts come from a remote node, compare read-only evidence, and avoid treating a balance response or simulation as a safety guarantee.

• Understand Privacy When Looking Up a Public Wallet Address

  See what a balance query reveals to its recipient, distinguish public chain data from request metadata, and prepare troubleshooting details without exposing secrets.

• Separate a Network View Change From Moving Assets

  Understand application and wallet network selection, confirm the active chain after a change, and avoid mistaking a dropdown selection for bridging or execution.

• Why One Address Can Show Different Balances on Different Chains

  Compare the same public address across networks without adding incompatible holdings, and build a network-specific inventory from receipts and balances.

• Choose the Right Explorer Before Looking Up a Transaction

  Select a network-specific explorer from authoritative references, distinguish missing results from failed receipts, and inspect public data without a connection.

• Match Gas Currency to the Network You Intend to Use

  Distinguish ETH and POL gas currencies across RunixCoin’s listed mainnets and testnets, and avoid treating a matching ticker as transferable gas funds.

RPC availability checks

• What to Check When a Blockchain Data Request Is Rate Limited

  Recognize HTTP 429 and temporary data-request failures, retry carefully, and separate a provider reading limit from a transaction or token failure.

Practical security and signing review

• Check a Wallet Website Address Before Trusting Its Interface

  Inspect the hostname and navigation source before connecting a wallet, recognize misleading URL layouts, and understand what HTTPS and familiar branding cannot prove.

• Avoid Choosing a Recipient From Misleading Transaction History

  Understand address poisoning, distinguish a history entry from a trusted recipient record, and verify a complete destination independently before any future transfer.

• Investigate an Address That Changes After Copy and Paste

  Compare the source address, pasted destination and wallet review screen, distinguish clipboard substitution from a wrong source, and stop when values disagree.

• Read the Domain and Message in an EIP-712 Signing Request

  Review typed-data domain fields and message intent, distinguish readable structure from trustworthy permissions, and decline requests whose effects remain unclear.

• Prepare a Wallet Troubleshooting Screen Share Without Revealing Recovery Data

  Choose a narrow view for wallet help, keep recovery and export screens private, and replace risky demonstrations with sanitized public observations.

• Why Closing a Page Cannot Undo an Included Transaction

  Separate a closed dialog, a pending request and an included chain result, and understand why interface controls cannot promise to reverse a confirmed transfer.

• Evaluate an Unexpected Message Offering Wallet Help

  Assess unsolicited wallet-support messages, verify destinations independently, and recognize requests for secrets, signatures or payments disguised as account repairs.

Wallet request and reporting problems

• After Declining a Wallet Prompt: Check What Was Rejected

  Interpret a rejected wallet request, separate connection from signing and submission, and decide whether a retry is appropriate without assuming a failed trade.

• When a Wallet Provider Cannot Reach the Requested Chain

  Distinguish provider disconnection from account authorization and quote failures, then compare network identity and read-only evidence before retrying.

• Write a Useful Wallet Error Report Without Exposing Secrets

  Prepare a minimal reproducible wallet report with public context, expected behavior and sanitized errors while excluding recovery data, signatures and private endpoints.

Network choices and cross-chain investigations

• Ethereum Mainnet in a Wallet: Separate It from Base

  Understand the Ethereum wallet choice, distinguish Ethereum holdings from Base balances, and check where a transaction actually happened before using a quote.

• Use Ethereum Sepolia to Practise Reading Transaction Evidence

  Plan a Sepolia learning exercise around network identity, test assets, receipts and evidence limits without confusing it with Base Sepolia or real-money testing.

• Understand the Polygon PoS Choice and Its POL Gas Balance

  Identify Polygon mainnet by chain ID 137, distinguish native POL gas from tokens, and understand Ethereum checkpoints without assuming a Polygon swap is available.

• Polygon Amoy: Keep Practice POL Separate from Mainnet Funds

  Identify Polygon Amoy, understand its Sepolia parent and test POL, and prepare a repeatable transaction-reading exercise without mistaking test activity for production.

• Layer-Two Execution and Ethereum Settlement: What to Check

  Separate an L2 transaction receipt from Ethereum settlement and bridge withdrawal completion, using Base as an example without promising fixed timings or security outcomes.

• Bridge, Swap or Wrap? Identify the Change You Need

  Classify a planned asset change by network and token identity, distinguish same-chain swapping from bridging and wrapping, and recognize RunixCoin’s quote-only limits.

• Review a Bridge Destination Before Considering a Transfer

  Prepare a destination checklist for an external bridge: receiving account, network, asset contract, service acceptance and destination gas, with no transaction submission.

• Investigate a Bridge Arrival Using Public Evidence

  Trace an external bridge transfer from source receipt to destination evidence, distinguish waiting stages from failure, and avoid treating one hash as proof of arrival.

Native and bridged stablecoin identities

• Base USDC and USDbC: Compare the Contracts Before Acting

  Identify Circle-native USDC and bridged USDbC on Base, compare their distinct contracts and understand why a matching dollar label cannot establish route compatibility.

• Polygon USDC and USDC.e: Identify the Asset You Actually Hold

  Distinguish native USDC from bridged USDC.e on Polygon using issuer contract references, then check balances and receiving-service acceptance without implying swap support.

Fee calculations and permission boundaries

• Convert Wei and Gwei Without Confusing Gas Units

  Work through ETH fee-unit conversions, distinguish gas quantity from gas price, and identify why an execution-fee calculation may not represent the whole Base fee.

• Why a Maximum Network Fee Can Exceed the Final Charge

  Read EIP-1559 fee caps separately from effective gas price, use a hypothetical calculation, and distinguish unspent fee headroom from a separate refund transaction.

• A Gas Estimate Failed: Diagnose the Request Before Signing

  Separate RPC transport errors from simulated execution failures, review transaction inputs and state, and understand why raising a gas limit cannot resolve every estimate error.

• Read Both Components of a Base Network Fee

  Distinguish Base L2 execution costs from L1 publication-related costs, reconcile an estimate carefully and keep network fees separate from RunixCoin’s interface-fee disclosure.

• Price Impact: Why Trade Size Can Change the Average Rate

  Understand how a trade can affect pool pricing, compare hypothetical average rates and distinguish price impact from slippage tolerance, gas and interface fees.

• Small Leftover Balances: Compare Costs Before Trying to Move Them

  Assess a small token balance against network costs, asset identity and remaining permissions without assuming it is recoverable, valuable or economical to move.

• Unlimited Token Allowances Can Outlive a Planned Trade

  Compare an exact allowance with an unlimited permission, understand exposure to later token deposits and distinguish a spending authorization from a completed exchange.

• Identify the Spender in a Token Approval Request

  Distinguish the token contract, allowance spender and eventual recipient, then review their chain-specific identities without assuming a familiar application name proves authorization.

• What Setting a Token Allowance to Zero Does and Does Not Do

  Understand the scope of a zero allowance, separate revocation from website disconnection and past transfers, and verify permission state without submitting a transaction here.

• A Gasless Signature Can Still Authorize Token Spending

  Understand ERC-2612 permit fields and separate Permit2 models, review signature permissions and deadlines, and avoid treating the absence of an immediate gas charge as harmless.

Transaction queues and explorer evidence

• A Dropped Transaction Is a Pending-Pool Observation

  Interpret a dropped transaction label, check whether another node or replacement has evidence, and avoid confusing disappearance with a failed receipt or guaranteed cancellation.

• Two Transaction Hashes, One Nonce: Read the Replacement

  Compare an original transaction with its replacement by sender, chain and nonce, then inspect what the included request actually did instead of trusting a cancellation label.

• Why an Earlier Account Nonce Can Hold Up Later Transactions

  Read an ordinary account’s nonce queue, distinguish order from signing time and application counters, and investigate the earliest unresolved request without creating new transactions.

• Read Internal Contract Activity Beside the Parent Transaction

  Understand explorer internal-activity views, distinguish contract calls from separately signed transactions and token logs, and investigate an ETH movement using the parent receipt.

Confirmed fee records

• Record a Confirmed Network Fee Without Double Counting

  Build a transaction-cost record with chain, receipt, native fee components and separate token movements, while keeping estimates and currency conversions clearly labeled.

Token movement evidence

• Use ERC-20 Transfer Logs to Investigate a Token Movement

  Read token Transfer events by emitter, sender, recipient and raw units, distinguish them from approvals and transaction destinations, and compare them with balance evidence.

Browser and mobile wallet contexts

• Before Clearing Wallet-Site Browser Data, Check Recovery Readiness

  Distinguish cached pages from persistent site data and wallet storage, preserve recovery options, and use read-only checks before destructive browser troubleshooting.

• Why the Same Wallet Website Can Look Different in Another Profile

  Separate browser profiles, site origins, wallet providers and public chain balances when a familiar website appears empty or shows a different account.

• Check Context When a Web Link Opens a Mobile Wallet

  Review destination domain, account, network and requested action during a mobile wallet handoff, and distinguish opening an app from authorizing or submitting a transaction.

• Multiple Wallet Extensions: Verify Which Provider Answered

  Understand why several installed wallet extensions can complicate provider selection, compare the responding wallet and account, and avoid recovery imports as a troubleshooting shortcut.

Asset behavior, backing and evidence

• A Stablecoin Target Is Different from a Market Quote

  Separate a stablecoin price target, an exchange rate, issuer redemption conditions and a wallet valuation before interpreting an estimated USDC amount.

• USDC Issuer Controls: What Token Ownership Does Not Remove

  Understand USDC contract pause, blacklist and upgrade roles, separate them from wallet control, and collect useful evidence when a token operation fails.

• Read a Wrapped Asset’s Backing and Exit Mechanism

  Evaluate what a wrapped token represents, how backing is held, who can change the mechanism and what evidence supports redemption on the intended network.

• Why a Rebasing Token Balance Can Change Without a Transfer

  Distinguish token units, underlying shares and rebasing mechanics, then compare balances at identified blocks without assuming every change requires a transfer event.

• Transfer-Tax Tokens: Sent Amount and Received Amount Can Differ

  Investigate token-level transfer deductions, distinguish them from network gas and interface fees, and avoid assuming a quote supports unusual token mechanics.

• Compare Token Balances at the Same Block

  Record block numbers and hashes with token balance observations, distinguish latest from historical state, and interpret differences without assuming one display is wrong.

• A Token Catalog Entry Does Not Establish a Swap Route

  Separate token discovery, contract identity, provider quoting and execution readiness when a wallet lists assets that cannot be exchanged through its public form.

Wallet access and device lifecycle

• A Locked Wallet Can Still Have Publicly Visible Balances

  Distinguish local wallet locking from public chain visibility, website account access and existing token permissions before interpreting a locked-state screen.

• Plan a Wallet Device Change Before Retiring the Old Device

  Prepare a non-sensitive account inventory, identify wallet-specific recovery requirements and separate account continuity from transaction and website-session history.

• A Website Session and a Blockchain Account Have Different Lifetimes

  Separate a wallet website tab, provider connection, local storage and onchain account state when reconnecting or investigating a session that appears to have ended.

Account authority, signing and evidence

• Account-Code Delegation Needs More Than a Token-Allowance Review

  Understand why an EIP-7702 authorization can affect account behavior beyond one token, which context matters, and why sponsored execution still requires careful review.

• Review Both Layers of a Permit2 Spending Request

  Separate the token approval to Permit2 from downstream signature permissions, then review token, spender, amounts and time bounds without treating a signature as harmless.

• Compare Intent with the Hardware Wallet’s Own Display

  Use a separate signing-device display to review addresses and transaction details, understand decoding limits, and avoid mistaking device confirmation for a guarantee of safety.

• A Public Address Can Still Reveal Sensitive Context

  Understand how a public wallet address can link balances, transfers and identity, then share only the evidence needed for a particular troubleshooting task.

• Review Browser Extension Access Around Wallet Activity

  Understand extension host access and permissions, distinguish browser access from onchain authority, and inspect unexpected permission changes through official documentation.

• A Successful Simulation Is Evidence with a Defined Scope

  Review simulation chain state, sender, calldata, value and overrides, then distinguish predicted execution from contract safety or a guaranteed live outcome.

• How to Assess an Audit or Security Claim

  Check the named report, reviewed code version, scope, findings and deployed implementation before treating a badge or test result as meaningful security evidence.

• Private-Key Exposure Is an Account-Control Problem

  Distinguish exposure of an account signing secret from a website password problem, understand why local locking is insufficient, and avoid sharing further sensitive evidence.

• Recognize Recovery Offers That Create a Second Loss

  Assess unsolicited recovery guarantees, advance-payment demands and requests for wallet secrets after a loss, while preserving public evidence without promising asset recovery.

• NFT Operator Approval Can Cover More Than One Item

  Distinguish ERC-721 item approval from approval for all and ERC-1155 operator permissions, then review collection, chain, operator and scope without submitting a change.

Practical protocol vocabulary

• Block: A Chain Observation You Can Identify and Compare

  Learn how a block number, hash, timestamp and transaction list help locate an observation, and why a block on another network is a different context.

• Calldata: The Encoded Instructions Behind a Contract Request

  Understand function selectors, encoded arguments and decoding limits, then compare transaction data with destination, value and the action you intended.

• Liquidity: Available Exchange Capacity Depends on Price and Amount

  Understand pool liquidity and active price ranges, why a route may price different sizes differently, and why total locked value does not guarantee a particular trade.

• Receipt: Evidence of Included Execution, with Specific Limits

  Read transaction receipt status, block identity, gas fields and logs, while separating inclusion evidence from quote IDs, pending requests and intended recipient outcomes.

• Finality: Stronger Chain Evidence Than First Inclusion

  Distinguish pending, included and finalized observations, understand network-specific settlement stages, and avoid treating an explorer counter as universal assurance.

• Router: A Contract That Can Coordinate Several Operations

  Understand why a swap router differs from a token contract, pool or spender, and why reviewing the route requires more than recognizing the top-level destination.

Fee coverage, data costs and time limits

• Sponsored Gas Does Not Mean Every Cost Is Removed

  Distinguish who funds network processing from exchange fees and requested authority, then review sponsorship conditions without assuming RunixCoin offers sponsored transactions.

• Encoded Transaction Data Can Affect L2 Fees Independently of Amount

  Understand why a transaction carrying more encoded instructions can have a different data-related network cost even when its token amount is smaller.

• A Transaction Deadline Limits Time, Not Just Output

  Distinguish an encoded transaction deadline from quote freshness and minimum output, understand what expiry can imply, and avoid extending an old request without review.

• A Dollar Gas Estimate Is a Conversion, Not a Fixed Dollar Bill

  Separate the native-currency network charge from a displayed dollar valuation, keep price timestamps, and reconcile hypothetical changes without confusing units.

Network prompts and provider capabilities

• Review an Unfamiliar Add-Network Prompt Before Accepting

  Compare chain ID, RPC URL, explorer and currency metadata with official network documentation, and distinguish adding a network from switching or verifying it.

• A Reachable RPC Endpoint May Still Reject a Particular Method

  Distinguish transport reachability, RPC errors, wallet-only methods and historical-state availability before treating an unsupported query as a zero balance or chain outage.

Connection, receiving and address checks

• Agree on the Receiving Network Before Sharing Payment Instructions

  Build a sender-recipient checklist around exact network, asset contract and receiving requirements, and understand why a matching EVM address alone is insufficient.

• Find an ERC-20 Balance Missing from a Wallet’s Token List

  Check network, account, issuer contract and read-only balance evidence, then distinguish displaying a token from transferring, approving or validating its value.

• Address Checksums Help Detect Mistakes Without Proving Identity

  Understand ERC-55 mixed-case checksums, why address-format validity cannot verify a recipient or network, and how to handle a checksum warning without guessing a correction.

• A Wallet Name Must Resolve to the Intended Address and Network

  Distinguish a human-readable name from its resolved address, review destination-chain records and missing results, and avoid assuming RunixCoin supports name-based transfers.

• Review the Origin and Accounts in a Browser-Wallet Connection

  Prepare a browser-wallet connection review around the exact website origin, selected provider, exposed accounts and requested methods without granting spending authority.

Approval workflow costs

• Budget Approval and Swap Network Costs as Separate Steps

  Distinguish allowance-setting costs from exchange execution, account for failed or additional requests, and avoid assuming one quote covers every step of a token workflow.

Interpreting the net rate

• Read the Net Exchange Rate in the Correct Direction and Units

  Calculate a hypothetical net USDC-per-WETH rate, distinguish its reciprocal and fee basis, and avoid treating an estimated rate as a portfolio valuation or guarantee.

Changes to existing token authority

• Changing an Existing Allowance Needs a Timing Review

  Understand why an ERC-20 approval replaces an allowance, how spending can occur while a change is pending, and why a submitted decrease is not an immediate limit.

What these guides do not establish

Listing a network, displaying a token or receiving a quote does not prove an executable mainnet route. Local fork and testnet results cannot establish real-money end-to-end execution. Where an estimate, asset identity or transaction state cannot be verified, keep it unresolved rather than signing additional requests to test an assumption.

Technical references appear beside the relevant guidance. Never provide recovery phrases or private keys for help interpreting a balance or quote. For current product scope, use the linked network and limits guide.