# EVM Provider

After setting up your wallet, you can access the EVM provider:

```javascript
import { useTomo, getWalletState } from '@tomo-inc/tomo-web-sdk';
// react
const { providers } = useTomo()
const { ethereumProvider } = providers;

// pure js
const ethereumProvider = window.tomo_ethereum
```

### Switch Chain ID

You can switch chains between different EVM networks (see [Supported Chains](/tomo-sdk/tomoevmkit/supported-chains.md) for the enabled network list). By default, you use the Ethereum mainnet.

```tsx
//interface
switchChain(chainId: string): Promise<void>

getChainId(): number | string


const chainId = '1'
// react
const current = await ethereumProvider.getChainId();
const res = await ethereumProvider.switchChain(chainId);

// pure js
const current = await window.tomo_ethereum.getChainId();
const res = await window.tomo_ethereum.switchChain(chainId);
```

### Get the EVM address

&#x20;The EVM address from the wallet state or provider.

```tsx
import { useTomo, getWalletState } from '@tomo-inc/tomo-web-sdk';
const { walletState, providers } = useTomo()

// get from wallet state
const address = walletState.address

// or get from provider
const address = await providers.ethereumProvider.request({ method: "eth_accounts" })?.[0]

/** pure js */
// get from wallet state
const address = getWalletState().address

// or get from provider
const address = await window.tomo_ethereum.request({ method: "eth_accounts" })?.[0]
```

## Provider Functions

`providers.ethereumProvider` exposes three functions for sending requests to the user's wallet:

### **Signing a Message**

It uses the Ethereum provider to sign a plaintext offchain message, which returns the message's signature with the message header. We also provide a shortcut for sign type data where the `msg` is a json string of the data.

{% code overflow="wrap" %}

```tsx
// interface
signMessage(msg: string, address:string): Promise<string>
signTypedData(address: string, msg: string): Promise<string>

 // react
 const personalSignResult = await ethereumProvider.request(msg, address);
 
 // pure js
 const personalSignResult = await window.tomo_ethereum.request(msg, address);
```

{% endcode %}

### **Send Transaction**

You can also send the transaction directly through this `sendTransaction` method. The return value is the transaction signature if signed and sent correctly.

<pre class="language-tsx" data-overflow="wrap"><code class="lang-tsx">// interface
sendTransaction(params: EvmTxParams): Promise&#x3C;any>
<strong>
</strong>interface EvmTxParams {
  from: string;
  to: string;
  value: string;
  gasPrice?: string;
  gasLimit?: string;
  maxFeePerGas?: string;
  maxPriorityFeePerGas?: string;
  data?: string;
}

<strong>const Tx= {
</strong>    from: address,
    to: address,
    value: "0x5af3107a4000",
    nonce: "0x0",
  },
// react
const res = await ethereumProvider.sendTransaction(Tx);

// pure js
const res = await window.tomo_ethereum.sendTransaction(Tx);
</code></pre>

### Requests

We also support the [standard ](https://ethereum.github.io/execution-apis/api-documentation/)wallet JSON RPC API for wallet actions

```tsx
//interface
request<Result = any, Params = any>(request: RequestArguments<Params>, context?: any): Promise<Result>


interface RequestArguments<T = any> {
    method: string;
    params?: T;
    id?: number;
}

const walletActions = {
  eth_requestAccounts: "eth_requestAccounts",
  eth_accounts: "eth_accounts",
  wallet_watchAsset: "wallet_watchAsset",
  eth_addEthereumChain: "eth_addEthereumChain",
  eth_switchEthereumChain: "eth_switchEthereumChain",
  wallet_switchEthereumChain: "wallet_switchEthereumChain",
  personal_sign: "personal_sign",
  eth_signTypedData_v4: "eth_signTypedData_v4",
  wallet_getPermissions: "wallet_getPermissions",
  wallet_requestPermissions: "wallet_requestPermissions",
  eth_sendTransaction: "eth_sendTransaction",
  eth_sendRawTransaction: "eth_sendRawTransaction",
  personal_ecRecover: "personal_ecRecover",
  eth_swapTransaction: "eth_swapTransaction",
  eth_approveTransaction: "eth_approveTransaction",
  eth_chainId: "eth_chainId",
};


const data = {
  method: "eth_sendTransaction",
  params: [
    {
      from: address,
      to: address,
      value: "0x5af3107a4000",
      nonce: "0x0",
    },
  ],
}
// react
const res = await ethereumProvider.request(data);

// pure js
const res = await window.tomo_ethereum.request(data);
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.tomo.inc/tomo-sdk/tomo-web-sdk/evm-provider.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.