Beacon links decentralized applications (dApps) with crypto wallets, enabling users to authenticate and sign transactions without manual copy‑paste steps. The protocol runs on a lightweight JSON‑RPC bridge, compatible with the Tezos ecosystem and beyond.
Key Takeaways
- Beacon provides a secure, peer‑to‑peer channel between a wallet and an app.
- It supports multiple wallet types, including hardware, mobile, and browser extensions.
- Integration requires only a few lines of client‑side code.
- Built‑in permission handling reduces phishing risk.
- Beacon is open‑source, with active development on GitHub.
What Is Beacon?
Beacon is an open‑source wallet integration protocol that implements the Wallet Standard described in the Beacon computing model. It exposes a minimal API that any dApp can call to request account access, sign payloads, and broadcast operations.
At its core, Beacon consists of three parts:
- Beacon SDK: a JavaScript library that runs in the browser.
- Beacon Channel: a secure WebSocket or post‑message bridge.
- Wallet Adapter: a thin wrapper that conforms to the wallet’s native API.
Why Beacon Matters
Wallet onboarding is a major friction point in crypto UX. According to Investopedia, over 70 % of users abandon dApps when asked to manually copy addresses. Beacon eliminates that step by letting the wallet confirm permissions directly.
From a security standpoint, the protocol forces the wallet to verify the request origin, reducing the risk of malicious page injection. The Bank for International Settitions notes that standardized wallet‑app communication lowers systemic phishing exposure.
How Beacon Works
The workflow follows a three‑phase handshake modeled as a simple state machine:
- Initiation: dApp calls
beacon.request({ type: 'connect' }). The SDK generates a uniquerequestIdand a QR‑code or deep link for mobile wallets. - Authorization: Wallet displays the dApp name, requested permissions, and a secure origin fingerprint. User approves, and the wallet returns a signed
authResponsecontaining the public key and an optional account label. - Interaction: Subsequent calls such as
beacon.request({ type: 'signPayload', payload: '...' })are routed through the established channel. The wallet signs the payload and sends the result back, which the dApp uses to broadcast the transaction.
The protocol can be expressed as:
State = { idle, connecting, authorized, error }
Transition(request) → new State
Each request is idempotent and can be replayed if the channel drops, thanks to the requestId tracking.
Used in Practice
A typical web integration looks like this:
<script src="https://unpkg.com/@airgap/beacon-sdk@latest/distBeacon/beacon.min.js"></script>
<script>
const wallet = new beacon.Wallet('MyApp');
document.getElementById('connect').addEventListener('click', async () => {
try {
const result = await wallet.client.requestPermissions();
console.log('Connected:', result.address);
} catch (err) {
console.error('Connection failed:', err.message);
}
});
</script>
On the mobile side, a wallet app listens for the deep link tezos://beacon?request=..., parses the JSON payload, and returns the signed response via the same URL scheme.
Risks / Limitations
- Network dependency: Both parties must be online for the handshake to complete.
- Platform support: Beacon is optimized for Tezos‑compatible wallets; Ethereum‑focused dApps may prefer WalletConnect.
- Permission drift: Granting unlimited signing rights can be dangerous; always request the minimal scope needed.
- Version mismatch: SDK updates can break compatibility if the wallet does not follow the same specification.
Beacon vs. WalletConnect vs. MetaMask Injection
Beacon, WalletConnect, and MetaMask’s window.ethereum are all wallet‑integration solutions, but they differ in scope and architecture:
- Transport: Beacon uses a direct peer‑to‑peer channel (QR/deep link), while WalletConnect relies on a relay server, and MetaMask injection works via browser APIs.
- Ecosystem: Beacon is native to Tezos, WalletConnect is chain‑agnostic but server‑dependent, and MetaMask is Ethereum‑centric.
- Security model: Beacon’s origin verification occurs in the wallet app; WalletConnect adds a middle‑man relay, which could be a single point of failure if compromised.
What to Watch
- Cross‑chain extensions: Emerging standards aim to let Beacon bridge Tezos, Ethereum, and other L1s in a single session.
- Hardware wallet support: Ledger and Trezor integrations are in beta, offering tamper‑proof signing.
- Regulatory动向: Upcoming BIS guidelines on digital asset custody may influence how wallet‑app permissions are standardized.
FAQ
1. Does Beacon work with any blockchain?
Beacon is designed primarily for Tezos, but its core ideas can be ported to other protocols that support a similar permission model.
2. How do I handle users who deny wallet access?
Capture the rejection error and prompt the user with clear instructions, such as “Please enable the wallet extension and try again.”
3. Can I request multiple accounts in a single session?
Yes. Use beacon.request({ type: 'connect', accounts: ['tz1...', 'tz2...'] }). The wallet will ask the user to approve each address.
4. What happens if the wallet app is closed after the initial handshake?
The channel remains active until the dApp session ends or the user revokes permissions. Re‑opening the wallet restores the connection automatically.
5. Is Beacon open‑source?
Yes. The full implementation is available on GitHub under the MIT license.
6. How does Beacon protect against phishing?
The wallet displays the exact origin URL and a cryptographic fingerprint of the request, making it hard for malicious pages to impersonate a trusted dApp.
7. Can Beacon be used in mobile web apps?
Absolutely. Mobile browsers support deep linking, so the wallet can be launched via a custom URL scheme and communicate back through the same mechanism.
8. Are there fees associated with using Beacon?
Beacon itself does not charge fees. Transaction fees are paid to the blockchain network (e.g., Tezos), just as with any other wallet interaction.