Solana Provider API

TokenPocket Extension injects a Solana Provider into the page. Developers can integrate Solana wallet capabilities through the traditional Provider interface or Wallet Standard.

Provider Injection

The following objects are available on the page:

window.solana
window.tokenpocket.solana

TokenPocket also supports Wallet Standard and can be discovered by standard wallet discovery flows.

Wallet Standard is recommended for new integrations. Existing dApps built around window.solana can continue using the traditional Provider interface.

Quick Start

Connect Wallet

const provider = window.solana;

const res = await provider.connect();

console.log(res.address);
console.log(res.publicKey.toBase58());
console.log(res.accounts);

Sign a Message

const message = new TextEncoder().encode('hello tokenpocket');
const res = await window.solana.signMessage(message);

console.log(res.signature);
console.log(res.publicKey.toBase58());

Sign a Transaction

const signedTx = await window.solana.signTransaction(transaction);

API List

connect

Connects the current site to a Solana account.

connect(options?: { silent?: boolean }): Promise<{
  accounts: WalletAccount[];
  publicKey: PublicKey;
  address: string;
}>

Parameters:

• silent: Whether to connect silently. Default is false.

Notes:

• When silent: true, an account is returned only if the wallet is unlocked and the current site already has an authorized address.

• The call throws an error if no connection is available.

Example:

const { address, publicKey } = await window.solana.connect();
console.log(address);
console.log(publicKey.toBase58());

disconnect

Disconnects the current session.

disconnect(): Promise<void>

Notes:

• Clears the current account state.

• Triggers the disconnect and accountChanged events.

Example:

await window.solana.disconnect();

signTransaction

Signs a single transaction.

signTransaction(
  transaction: Transaction | VersionedTransaction
): Promise<Transaction | VersionedTransaction>

Notes:

• Supports Transaction.

• Also handles VersionedTransaction compatibility.

• dApps are recommended to use legacy transactions.

• Returns the signed transaction object.

• If the wallet returns unitsConsumed or microLamports, the Provider automatically appends Compute Budget instructions.

Example:

const signedTx = await window.solana.signTransaction(transaction);

signAllTransactions

Signs multiple transactions.

signAllTransactions(
  transactions: Array<Transaction | VersionedTransaction>
): Promise<Array<Transaction | VersionedTransaction>>

Notes:

• The current implementation signs transactions one by one through signTransaction.

Example:

const signedTxs = await window.solana.signAllTransactions(transactions);

signMessage

Signs a message.

signMessage(
  message: Uint8Array | { message: Uint8Array }
): Promise<{
  signature: Uint8Array;
  publicKey: PublicKey;
}>

Notes:

• Supports a raw Uint8Array.

• Also accepts a { message } wrapper.

Example:

const message = new TextEncoder().encode('hello tokenpocket');
const res = await window.solana.signMessage(message);

console.log(res.signature);
console.log(res.publicKey.toBase58());

signAndSendTransaction

Signs and sends a transaction.

signAndSendTransaction(params: {
  recentBlockhash?: string;
  feePayer?: string;
  instructions?: Array<{
    keys: Array<{
      pubkey: string;
      isSigner: boolean;
      isWritable: boolean;
    }>;
    programId: string;
    data: number[] | Uint8Array | Buffer;
  }>;
}): Promise<{
  signature: string;
  publicKey: string;
}>

Notes:

• Builds a transaction from the provided instructions.

• Returns signature as a Base58 string.

• Returns publicKey as the signing address.

Example:

const result = await window.solana.signAndSendTransaction({
  recentBlockhash,
  feePayer,
  instructions,
});

console.log(result.signature);
console.log(result.publicKey);

Events

The Provider supports event subscriptions.

connect

Triggered after a successful connection.

window.solana.on('connect', (publicKey) => {
  console.log(publicKey?.toBase58?.());
});

disconnect

Triggered after disconnect.

window.solana.on('disconnect', () => {
  console.log('disconnected');
});

accountChanged

Triggered when the active account changes.

window.solana.on('accountChanged', (publicKey) => {
  if (!publicKey) {
    console.log('account cleared');
    return;
  }

  console.log(publicKey.toBase58());
});

When the user disconnects or the active account is cleared, accountChanged may receive null. Make sure your dApp handles that case.

Wallet Standard

TokenPocket currently supports these Wallet Standard features:

• standard:connect

• standard:events

• solana:signTransaction

• solana:signAndSendTransaction

• solana:signMessage

Official references:

• Wallet Standard docs

• Wallet Standard extensions

• Solana Wallet Adapter ecosystem reference

Supported chains:

[
  'solana:mainnet',
  'solana:devnet',
  'solana:testnet',
  'solana:localnet',
]

Notes:

• The currently declared supportedTransactionVersions value is ['legacy'].

• dApps should integrate against legacy transaction support.

Wallet Standard Example

const accounts = await wallet.features['standard:connect'].connect();

const outputs =
  await wallet.features['solana:signTransaction'].signTransaction({
    account: accounts.accounts[0],
    chain: 'solana:mainnet',
    transaction,
  });

Error Handling

Use try/catch for all Provider calls.

try {
  await window.solana.connect();
} catch (error) {
  console.error(error);
}

Common failure cases:

• User rejects the connection request.

• User rejects a signature request.

• Wallet is locked.

• The current site is not authorized.

• Transaction or message format is invalid.

Best Practices

• Prefer Wallet Standard for new integrations.

• Existing dApps can keep using window.solana.

• Treat transaction support as legacy.

• Handle exceptions for all connect and signing flows.

• Handle null values from accountChanged.

Compatibility Notes

• TokenPocket exposes both window.solana and window.tokenpocket.solana.

• Wallet Standard is recommended for new integrations.

• Existing Solana Provider integrations can continue to work directly.