# Gno Wallet Standard

## Summary

The Wallet standard defines a universal API for wallet and application interactions. This doc introduces a wallet standard for the Gno ecosystem.

## Motivation

Most web wallets today are browser extensions. They interact with dApps by injecting themselves into the global window object, expecting the dApp to detect them by reading this object. This approach has several issues:

1. DApps must know how to find these objects and often support only a limited number of wallets, which might not be relevant to users.
2. DApps need to continuously scan the window object to detect wallets injected before and after loading, leading to constant background processes.
3. This detection method can cause race conditions if a dApp loads before a wallet, potentially missing new wallets.

This proposal suggests adopting a generalized event-based communication model between wallets and dApps in Gno to address all these issues.

## Rationale

This [chain agnostic solution](https://github.com/wallet-standard/wallet-standard) has been introduced as a generalized standard for wallets and dapps communication and has already been implemented on [Solana](https://github.com/wallet-standard/wallet-standard) and [Sui](https://docs.sui.io/standards/wallet-standard), and the [Ethereum](https://eips.ethereum.org/EIPS/eip-6963) community recently proposed a similar solution.

## Specification

The Wallet Standard is a chain-agnostic set of interfaces and conventions designed to improve how applications interact with injected wallets. The Gno team will create a similar repository (https://github.com/aptos-labs/wallet-standard) to specify which APIs must or should be implemented for wallets.

**Standard Features**

`gno:connect` method to establish a connection between a dapp and a wallet.

// `silent?: boolean` - gives ability to trigger connection without user prompt (for example, for auto-connect)
// `networkInfo?: NetworkInfo` - defines the network that the dapp will use (shortcut for connect and change network)

connect(silent?: boolean, networkInfo?: NetworkInfo): Promise<UserResponse<AccountInfo>>;

`gno:disconnect` method to disconnect a connection established between a dapp and a wallet

disconnect(): Promise<void>;

`gno:getAccount` to get the current connected account in the wallet

getAccount():Promise<UserResponse<AccountInfo>>

`gno:getNetwork` to get the current network in the wallet

getNetwork(): Promise<UserResponse<NetworkInfo>>;

`gno:signTransaction` for the current connected account in the wallet to sign a transaction using the wallet.

// `transaction: AnyRawTransaction` - a generated raw transaction created with Gno’ TS SDK

signTransaction(transaction: AnyRawTransaction):AccountAuthenticator

`gno:signMessage` for the current connected account in the wallet to sign a message using the wallet.

// `message: GnoSignMessageInput` - a message to sign

signMessage(message: GnoSignMessageInput):Promise<UserResponse<GnoSignMessageOutput>>;

`gno:onAccountChange` event for the wallet to fire when an account has been changed in the wallet.

// `newAccount: AccountInfo` - The new connected account

onAccountChange(newAccount: AccountInfo): Promise<void>

`gno:onNetworkChange` event for the wallet to fire when the network has been changed in the wallet.

// `newNetwork: NetworkInfo` - The new wallet current network

onNetworkChange(newNetwork: NetworkInfo):Promise<void>

`gno:signAndSubmitTransaction*` method to sign and submit a transaction using the current connected account in the wallet.

// `SignAndSubmitTransactionInput` - the transaction details in a JSON format

signAndSubmitTransaction(SignAndSubmitTransactionInput): Promise<UserResponse<{string:hash}>>;

`gno:changeNetwork*` event for the dapp to send to the wallet to change the wallet’s current network

// `network:NetworkInfo` - The network for the wallet to change to

changeNetwork(network:NetworkInfo):Promise<UserResponse<{success: boolean,reason?: string}>>

**Types**

> Note: `UserResponse` type is used for when a user rejects a rejectable request. For example, when user wants to connect but instead closes the window popup.

export enum UserResponseStatus {
  APPROVED = 'Approved',
  REJECTED = 'Rejected'
}

export interface UserApproval<TResponseArgs> {
 status: UserResponseStatus.APPROVED
 args: TResponseArgs
}

export interface UserRejection {
 status: UserResponseStatus.REJECTED
}

export type UserResponse<TResponseArgs> = UserApproval<TResponseArgs> | UserRejection;

export interface AccountInfo = { account: Account, ansName?: string }

export interface NetworkInfo {
  name: Network
  chainId: number
  url?: string
}

export type GnoSignMessageInput = {
TBD
}

export type GnoSignMessageOutput = {
TBD
}

**Errors**

A wallet must throw a GnoWalletError. The standard requires to support `Unauthorized` and `InternalError` but a wallet can throw a custom `GnoWalletError` error

Using the default message

if (error) {
  throw new GnoWalletError(GnoWalletErrorCode.Unauthorized);
}

Using a custom message

if (error) {
  throw new GnoWalletError(
    GnoWalletErrorCode.Unauthorized,
    "My custom unauthorized message"
  );
}

Using a custom error

if (error) {
  throw new GnoWalletError(-32000, "Invalid Input");
}

**Register and Get Wallet**
After you have a compatible interface for your wallet, use the registerWallet function to register it.

registerWallet(new YourWallet());

To query the installed wallets in a user's browser, use the get function of getWallets.

const availableWallets = getWallets().get();