Debank is an EVM Portfolio Interface with Wallet-Signature Login

Debank is a DeFi portfolio interface that turns a wallet-signed message into proof that you control the selected EVM address. You first expose a public address through a compatible wallet, then approve a message in that wallet. Debank verifies the signature off-chain and opens an authenticated session without broadcasting a transaction, spending ETH, changing token balances, or creating an ERC-20 allowance. The decisive check is whether the address in the prompt matches the account you meant to use.

Bottom line: It is a DeFi portfolio interface where a signed message proves control of an EVM address, enabling login without an on-chain transaction.

Choose between address viewing and authenticated access

Zero gas and one account choice settle the decision: paste an address for public portfolio viewing, or sign with its wallet for authenticated features. Public lookup needs only the 42-character EVM address and does not establish control. Login adds a cryptographic proof tied to the account that answered the prompt. Choose the second path when an action must belong to your profile, and use lookup when you only need to inspect public Ethereum, Arbitrum One, Base, or Polygon PoS data.

What should you confirm before signing?

Three items deserve confirmation before you sign: the selected account, the requesting context, and the exact message presented by the wallet.

The selected address carries the most weight because a standard EVM address contains 20 bytes and renders as 40 hexadecimal digits after the 0x prefix. Count the prefix and the displayed form reaches 42 characters. Match the beginning and ending characters against the account shown in Rabby Wallet or MetaMask, then expand the full address when the wallet offers that view. A familiar account label is useful navigation, yet the hexadecimal address is the value Debank verifies. Changing only the active account changes the signer, even when every account lives under one wallet extension.

The wallet should classify the request as message signing, not transaction confirmation. An EIP-191 personal message starts with the one-byte 0x19 marker and uses 0x45 as its one-byte version value before hashing. It carries no gas limit, recipient, native value, or contract call. MetaMask, Rabby Wallet, and WalletConnect present the final confirmation in different layouts, so button wording matters less than the request type and address.

Read the message as a complete authorization statement. If the displayed address differs, cancel the prompt and correct the selected account before requesting another signature. A signature matches one exact byte sequence; a changed space, line break, nonce, or address produces a different Keccak-256 digest.

Connection routes from extension to hardware signer

One active EVM account must reach the browser through an extension, a mobile handoff, or a hardware-backed software connector.

Rabby Wallet and MetaMask expose browser accounts directly, while WalletConnect relays the connection request to a mobile wallet through a session handoff. Ledger and Trezor devices normally sit behind compatible wallet software, which sends the message to the device and returns the approved signature. In every route, Debank receives the public address first and the signed result second. The private key remains in the signing wallet or hardware device. Connection therefore supplies an account identifier and a communication channel; it does not yet prove that the person controlling the interface can sign for that address.

Provider choice also determines where confirmation happens. A browser extension opens beside the page, WalletConnect moves approval to the paired mobile wallet, and a hardware signer adds a device confirmation. Each route should converge on the same 42-character address, so convenience is the meaningful difference between them.

The four fixed parameters behind wallet proof

Four fixed parameters explain the proof path: address width, message envelope, digest width, and canonical externally owned account signature size.

The table describes an externally owned account, or EOA, using secp256k1. The 20-byte address is derived from the public key, and Keccak-256 reduces the prepared message to a 32-byte digest. A canonical EVM ECDSA signature uses 65 bytes: 32 for r, 32 for s, and 1 recovery byte. ERC-2098 also defines a 64-byte compact representation, but a verifier must deliberately support the encoding it receives. These sizes stay constant even though the readable login text changes between requests.

Smart-contract accounts follow another path. ERC-1271 defines isValidSignature for contract validation and requires the 4-byte success value 0x1626ba7e. Safe is a familiar contract-account example, but support requires the login service to call the contract method rather than recover an EOA directly. That is a compatibility prerequisite, not a different portfolio address format.

How does the signature prove control of the address?

One 32-byte digest lets Debank recover the signer from the 65-byte ECDSA result and compare it with the requested 20-byte address.

For an EIP-191 personal message, the wallet prefixes the message, includes its decimal byte length, and hashes the full byte sequence with Keccak-256. The wallet signs that digest with the secp256k1 private key. Debank repeats the preparation, interprets r, s, and the recovery identifier, and derives a public key plus its EVM address. Equality between the recovered address and the requested address completes the proof.

Verification fails when any dependency differs: the account, the message bytes, the encoding, or the signature format. This is why editing copied text after signing breaks validation. It also explains why the same signature does not authorize an unrelated transaction. EIP-191 frames signed data so the message payload is structurally distinct from an Ethereum transaction.

State changes after a successful login

Zero on-chain transactions occur when Debank accepts the message; only the off-chain session changes from unauthenticated to address-bound access.

The blockchain state stays exactly where it was before confirmation. The account transaction nonce does not rise, ETH does not pay gas, ERC-20 balances remain fixed, and contract allowances retain their previous values. No block producer receives the message because the browser sends the signature back to Debank rather than to an Ethereum JSON-RPC transaction method. A block explorer therefore has no login transaction to display. The verifiable output is the signature itself, while the application-level output is a session that associates the browser with the proved 20-byte address for signed-in features.

Inside the interface, public portfolio data can now sit beside account-specific controls. Stream interactions, Quest participation, Credit activation, and Web3 Badge actions rely on authenticated context rather than a pasted address alone. Each feature still applies its own rules; the login signature does not silently execute those later actions.

Wallet connection state and Debank login state are separate. A connector can remember an approved account while the application session has ended, so returning users might see the address yet receive another message request. Re-signing refreshes the proof path; it does not repeat any on-chain action.

That boundary is the central verification result: one off-chain identity session changes, while Ethereum, ERC-20, and protocol positions remain untouched.

Does network selection change the login result?

One valid EVM signature proves the selected address, while chain selection supplies context rather than adding a second wallet identity.

Ethereum uses chain ID 1, Optimism uses 10, BNB Smart Chain uses 56, Gnosis Chain uses 100, Polygon PoS uses 137, Base uses 8453, Arbitrum One uses 42161, and Avalanche C-Chain uses 43114. EIP-155 assigns chain IDs to transactions, and EIP-4361 includes a chain ID in its version 1 sign-in format. A plain message signature still does not broadcast to any of those networks.

The same EOA private key derives the same 20-byte address across these EVM networks. Debank uses that address to aggregate chain-specific balances and protocol positions. Switching from Base to Arbitrum One changes the portfolio records under review, not the cryptographic account that signed the login message.

Recovering from an account mismatch

One mismatched character is enough to reject verification because the recovered 20-byte signer must equal the address attached to the login request.

Start with the account selector inside the wallet, not the network selector. Copy the intended address, compare all 40 hexadecimal digits when possible, and note that the 0x prefix adds 2 displayed characters. Then cancel the outstanding request. Do not approve it and switch accounts afterward, because that signature remains bound to the account and message that produced it.

Next, disconnect the current wallet session from the Debank interface, select the intended account in Rabby Wallet or MetaMask, and reconnect. Request a new login message only after the interface shows the correct beginning and ending address characters. The fresh prompt should name the same account that will perform the signature.

If a hardware device backs the account, open the corresponding account path in the connector before confirming on Ledger or Trezor. The device signs whichever key path the software requests. A familiar device name does not override an address mismatch.

Network switching fixes a chain-context mismatch; reconnecting the intended account fixes an address mismatch.

Fresh messages and session boundaries

One signature covers one exact message, and changing even 1 byte produces a different 256-bit Keccak-256 digest.

Login messages use changing challenge data so an old signed result does not stand in for a new request. EIP-4361 offers a durable reference format: version 1, a nonce of at least 8 alphanumeric characters, an EIP-155 chain ID, and an RFC 3339 issued-at time. Expiration time is optional in that standard. A login expiry belongs to off-chain session policy rather than transaction rules.

Logging out, clearing application storage, changing browsers, or letting the service end a session removes the authenticated context. The wallet address can remain connected at the provider layer, which explains why a later visit might skip account selection yet ask for another signature. A newly generated challenge is the correct input for that new session.

Authenticated access without portfolio mutation

Zero transfers and one verified address make this workflow suitable when account-specific Debank actions matter more than public portfolio viewing.

Use authenticated access when you want the interface to associate activity with the selected profile, preserve account-specific state, or confirm control before an application action. Keep public lookup for addresses that you only monitor. The choice rests on authority, not portfolio coverage: both routes start from public EVM data, but only the signed route proves that the active wallet controls the displayed address (more on this in Debank why troubleshooting matters ).

The final check stays compact. Confirm the 42-character address, classify the request as message signing, approve it in the intended wallet, and wait for the interface to show signed-in state. That sequence produces an off-chain login record while leaving Ethereum balances, transaction nonces, ERC-20 allowances, and DeFi positions unchanged.