# Alcor Signer > Alcor Signer (sign.alcor.exchange) is a passkey wallet for Antelope networks — Telos, WAX, XPR Network and Vaulta (formerly EOS). It lives on its own origin, holds the keys and signs transactions for Alcor Exchange apps, so the trading app itself never holds a key. No extension, no app to install, no seed phrase to type in: a passkey on the device (Face ID, Touch ID, Windows Hello, Android fingerprint, a security key) is the wallet. The site is a static page with no backend, no build step and no third-party code. Everything it shows is read from the chain; everything it stores in the browser is a cache that can be rebuilt from the passkey. ## What it does - **Create a key.** A passkey is created for `sign.alcor.exchange`. On Antelope it becomes a native `PUB_WA_` key: the chain itself checks the WebAuthn signature and the site it was made for. - **Recovery phrase.** The same passkey derives 24 words (BIP-39, through the WebAuthn PRF extension). The words give owner keys on every network (BIP-32/44) and bring the accounts back if the passkey is lost. The words are deterministic: the same passkey always gives the same words. To get new words, the passkey itself is replaced. - **Find accounts.** Accounts are found on-chain by key, on all networks at once. A new device needs no server: the public key is recovered from the passkey's own signature. - **Bring an existing account.** Import with a private key (the passkey is added to the account; the old key can be removed), or link from another wallet by adding the passkey to the account's permission. - **Export.** The owner key of an account derived from the 24 words can be exported as WIF for Anchor or cleos. The passkey itself can't be exported by anything, and Fast sign keys are never exported. - **Sign.** An app sends actions, and Alcor Signer shows what the transaction does and signs it. - **Prove an account.** An app asks the person to prove they control an account (Sign-In with Antelope): Alcor Signer shows the app's statement and signs a message with the passkey. It is never a transaction and never raw bytes or a digest, so it can't be turned into one. ## Signing modes Each account has one mode per browser: - **Passkey** — every signature needs the device (Face ID or the like). - **Fast** — a browser key added to the account's `active` permission. Signs with a button in the Alcor Signer window, no Face ID. The key is a non-extractable WebCrypto key, derived again from the passkey if the browser data is cleared. - **Auto** — Alcor trades (swaps, limit orders, liquidity, staking on Alcor contracts) are signed at once, without a window. Anything else opens the window as in Fast. A trade with no minimum to receive, an unknown memo or a recipient other than the signer always opens the window. Permission changes (`updateauth`, `linkauth` and the like, `setcode`, `setabi`, any `eosio.msig` action) are never accepted from an app. They are started only inside Alcor Signer and always signed with the passkey. ## How it protects the user - **Separate origin.** A passkey works only on the site it was made for. Malicious code on the trading app can't sign anything with it — the browser won't hand it out there, and the chain checks the site name inside every signature. - **What you see is what you sign.** The app sends only actions. Alcor Signer builds the transaction itself (network ID, reference block, expiration) from its own node list, decodes it back and draws the screen from the decoded transaction, not from the request. - **Fixed networks.** The app only names a network. Nodes and chain IDs are hardcoded; a node that reports another chain ID is a refusal. - **Checked ABIs.** Contract ABIs are pinned by hash. An ABI that doesn't match must be confirmed by a second node, and then the screen shows a warning. - **Readable summary.** Swaps, orders, transfers, bridge moves and staking are shown in plain words. Missing minimums, foreign recipients and unknown memos get red and yellow warnings that are never hidden. - **Strict headers.** CSP without inline code, Trusted Types, `connect-src` only to the listed nodes, framing allowed only for Alcor's own app. - **Clicks, not keys.** A signature takes a click on the button after the screen is shown. No hotkeys, no autofocus on the sign button, and the button ignores clicks right after the window gets focus. ## Networks - Telos - WAX - XPR Network - Vaulta (formerly EOS) All four share one passkey and one recovery phrase. EVM networks are planned through keys derived from the same 24 words. ## Who can use it - **Alcor Exchange apps** (`alcor.exchange`, `app.alcor.exchange` and the network subdomains) get everything above, Auto sign included. - **Other dApps** connect through the WharfKit wallet plugin `@alcorexchange/wallet-plugin-alcor-signer`. This is early access: Alcor Signer answers only the sites on its list. To get listed, write to the Alcor team in Telegram, [t.me/alcorexchange](https://t.me/alcorexchange), with the exact origins (production and staging, with `https://` and the port). Requests from any other site are ignored: the plugin reports that the window "did not open in time, or does not accept requests from" the site. A dApp gets the Alcor Signer window and nothing more: - Sign in to an existing account, sign transactions, and ask for a proof of the account. A dApp can't ask the window to create a wallet or open account settings. - Every transaction opens the window and takes a click. No Auto sign, and the dApp can't read or change the signing mode. If the user has turned on Fast, it signs with the button, without Face ID. - The sign-in and signing screens say the site is not an Alcor site. - No embedding: a dApp can't put Alcor Signer in an iframe. - The dApp pays its own CPU and NET. - The rest is as for Alcor: Alcor Signer builds the transaction, and permission changes are never signed for an app. ## Integration ```ts import { SessionKit } from '@wharfkit/session' import { WebRenderer } from '@wharfkit/web-renderer' import { WalletPluginAlcorSigner } from '@alcorexchange/wallet-plugin-alcor-signer' const sessionKit = new SessionKit({ appName: 'yourapp', chains: [{ id: '1064487b3cd1a897ce03ae5b6a865651747e2e152090f99c1d19d44e01aea5a4', url: 'https://wax.greymass.com' }], ui: new WebRenderer(), walletPlugins: [new WalletPluginAlcorSigner()], }) ``` - Alcor Signer takes the actions and sets the reference block and expiration from its own nodes. The plugin returns that transaction with the signatures and fails unless its actions match the dApp's byte for byte. This needs Session Kit's `allowModify`, which is on by default. - Context-free actions, transaction extensions and `delay_sec` are refused. - Browser only. The key is a passkey on the user's device, so there is no Node.js or server-side signing. - Safari opens a window only right after a click. When it holds the window back, the plugin shows a button in the WharfKit dialog that opens it. ## Prove an account (Sign-In with Antelope) From plugin version 0.2.0. Session Kit has no message signing, so it is a method of the plugin: ```ts const proof = await session.walletPlugin.proveAccount({ chain: session.chain.id, account: String(session.actor), statement: 'Sign in to yourapp', // up to 300 characters, one line, shown to the person nonce, // 16–64 letters and digits, issued by your server expiresAt: '2026-01-31T12:10:00Z', // UTC to the second, at most an hour ahead }) // { message, signature: 'SIG_WA_…', fields: { domain, uri, account, permission, statement, chainId, nonce, issuedAt, expiresAt } } ``` The message is CAIP-122 (the fields of Sign-In with Ethereum) with an Antelope account line; the signature covers `sha256("\x19Antelope Signed Message:\n" + byte length + text)`. Alcor Signer sets `domain` and `uri` from the requesting page's origin and `chainId` from its own registry. Only the passkey signs, on a click. Verify on the server that relies on it: rebuild the text from `fields`, check the domain is yours and the nonce is the one you issued (then burn it), check it has not expired, recover the key and check that it alone satisfies `account@permission` on chain now. [`src/proof.ts`](https://github.com/alcorexchange/alcor-examples/blob/main/src/proof.ts) in alcor-examples does all of it with nothing to deploy; [`contract/msgproof.cpp`](https://github.com/alcorexchange/alcor-examples/blob/main/contract/msgproof.cpp) does it in a contract. A proof says who controls the account; it is not permission to move funds. ## Links - [Alcor Signer](https://sign.alcor.exchange): the wallet - [Alcor Exchange](https://alcor.exchange): the DEX that uses it - [WharfKit plugin on npm](https://www.npmjs.com/package/@alcorexchange/wallet-plugin-alcor-signer) - [Plugin source](https://github.com/alcorexchange/wallet-plugin-alcor-signer) - [Developer guide](https://docs.alcor.exchange/alcor-signer): integration, proofs, errors, for people and agents - [Examples](https://github.com/alcorexchange/alcor-examples): proof verification on a backend and in a contract - [Alcor in Telegram](https://t.me/alcorexchange): getting a site listed, questions