Open-source wallet infrastructure

Like WalletConnect, but without WalletConnect.

WalletConnect built the standard for mobile wallet connectivity. Then came the dashboards, the API keys, the monthly bills, and the single point of failure. WalletCast gives you the same seamless experience — built on open protocols, without asking anyone's permission.

npm install @walletcast/sdk View on GitHub

Zero Onboarding

Forget creating developer accounts or waiting for approvals. Install the SDK, generate a QR, and you're connected. Zero friction.

100% Free, No Limits

No payment tiers, no per-user fees, no credit cards. Public and open infrastructure, the way it should have always been.

Truly Decentralized

You don't depend on our servers. WalletCast uses P2P and Nostr routing. If we disappear tomorrow, your dApp keeps working perfectly.

Drop-in Replacement

Compatible with standard provider interfaces (EIP-1193). Switching from your current solution takes a couple lines of code.

How it works

Generate keypair

Dapp creates an ephemeral keypair and renders a QR code with wallet-specific deep links.

Scan QR code

User scans the QR — their wallet opens the connector page in its in-app browser.

Bridge RPC calls

The connector detects window.ethereum and bridges all RPC calls over encrypted Nostr messages.

Connected

Dapp receives signed transactions and wallet events in real-time. No relay signup. No tracking.

See it in action

WalletCast connection flow — choose wallet, scan QR, connected

1Choose wallet 2Scan QR code 3Connected

MetaMask

Trust Wallet

Coinbase Wallet

Phantom

OKX Wallet

Get started in 3 lines

import { WalletCast } from '@walletcast/sdk'; const { provider, accounts } = await WalletCast.connect(); // That's it. Chain and accounts detected from the wallet.

Ready to build?

npm install @walletcast/sdk

Read the docs View on GitHub

Documentation

Everything you need to integrate WalletCast into your dapp.

Quickstart

1. Install

npm install @walletcast/sdk

2. Connect

import { WalletCast } from '@walletcast/sdk';

const { provider, accounts, type, chainId, disconnect } = await WalletCast.connect();

// type is 'injected' (used window.ethereum) or 'walletcast' (QR deep link)
console.log(`Connected via ${type} on chain ${chainId}:`, accounts);

WalletCast.connect() automatically restores saved sessions, detects injected wallets, and shows a QR modal if no injected wallet is found.

3. Use the provider

const balance = await provider.request({
  method: 'eth_getBalance',
  params: [accounts[0], 'latest']
});

API Reference

WalletCast.connect(options?)

High-level API that handles everything: session restore, injected wallet detection, and QR modal.

Options

Option	Type	Default	Description
`rpcUrl`	string	—	Public RPC for read methods
`chainId`	number	—	Detected from wallet if omitted
`connectorUrl`	string	`'https://walletcast.net/'`	Connector page URL
`nostrRelays`	string[]	defaults	Nostr relay URLs
`preferInjected`	boolean	`true`	Check injected wallet first
`theme`	`'dark' \| 'light' \| 'system'`	`'dark'`	QR modal theme
`walletId`	WalletId	—	Skip picker, show specific wallet QR

Returns ConnectResult

Field	Type	Description
`provider`	EIP1193Provider	Use for all RPC calls
`type`	`'injected' \| 'walletcast'`	Connection method used
`accounts`	string[]	Connected wallet accounts
`chainId`	string	Hex chain ID (e.g. "0x1")
`disconnect`	() => Promise<void>	Disconnect and clear session

WalletCast.createDeepLinkProvider(config)

Lower-level API for custom UI. Generates deep links but doesn't show any modal.

import { WalletCast, toSVGDataURL } from '@walletcast/sdk';

const { provider, links, approval } = WalletCast.createDeepLinkProvider({
  connectorUrl: 'https://walletcast.net/',
});

const qrSvg = toSVGDataURL(links.metamask.universal, { moduleSize: 6 });
const accounts = await approval;

WalletCast.detectInjectedWallet()

Check for an injected EIP-1193 provider without triggering connection.

const injected = await WalletCast.detectInjectedWallet();
if (injected) { /* use injected wallet */ }

Framework Examples

import { BrowserProvider } from 'ethers';
import { WalletCast } from '@walletcast/sdk';

const { provider } = await WalletCast.connect();
const signer = await new BrowserProvider(provider).getSigner();
const tx = await signer.sendTransaction({
  to: '0x...', value: parseEther('0.01')
});

import { createWalletClient, custom } from 'viem';
import { mainnet } from 'viem/chains';
import { WalletCast } from '@walletcast/sdk';

const { provider } = await WalletCast.connect();
const client = createWalletClient({
  chain: mainnet, transport: custom(provider),
});

import { useState, useCallback } from 'react';
import { WalletCast } from '@walletcast/sdk';

function useWalletCast() {
  const [result, setResult] = useState(null);

  const connect = useCallback(async () => {
    const res = await WalletCast.connect();
    setResult(res);
    res.provider.on('disconnect', () => setResult(null));
    return res;
  }, []);

  const disconnect = useCallback(async () => {
    await result?.disconnect();
    setResult(null);
  }, [result]);

  return { provider: result?.provider, accounts: result?.accounts ?? [],
    isConnected: !!result, connect, disconnect };
}

Events

provider.on('connect', ({ chainId }) => { /* ... */ });
provider.on('disconnect', () => { /* ... */ });
provider.on('accountsChanged', (accounts) => { /* ... */ });
provider.on('chainChanged', (chainId) => { /* ... */ });

Supported Wallets

ID	Wallet	Deep Link	Universal Link
`metamask`	MetaMask	`metamask://dapp/...`	`metamask.app.link/dapp/...`
`trust`	Trust Wallet	`trust://open_url?...`	`link.trustwallet.com/...`
`coinbase`	Coinbase Wallet	`cbwallet://dapp?...`	`go.cb-w.com/dapp?...`
`phantom`	Phantom	`phantom://browse/...`	`phantom.app/ul/browse/...`
`okx`	OKX Wallet	`okx://wallet/dapp/...`	—

Session Persistence

Sessions are automatically managed by WalletCast.connect(). Saved to localStorage with 24-hour TTL. Restored silently on page reload via ping/pong. Cleared on disconnect() or when the connector sends a disconnect message.

Why WalletCast?

Connecting a mobile wallet to a desktop dapp should not require a centralized relay service, an API key, or trust in any third party. WalletCast replaces the entire WalletConnect infrastructure with encrypted Nostr messages — an open protocol anyone can relay.

Architecture

WalletCast vs WalletConnect

Feature	WalletConnect	WalletCast
Centralized relay	Required	None
Project ID / signup	Required	None
Message privacy	Relay can observe	E2E encrypted
Self-hostable relay	Complex	Any Nostr relay
Connector size	~200KB+ SDK	~55KB single file
Protocol	Proprietary	Nostr (open)
Vendor lock-in	Yes	None

Self-Hosting

The connector is a single self-contained HTML file (~55KB). Deploy it anywhere and pass your URL:

npm install @walletcast/deep-link
# Build connector.html — deploy to any static host

WalletCast.connect({
  connectorUrl: 'https://your-domain.com/connector.html'
});