# Integrate Embedded Wallets with the TON Blockchain

> Integrate Embedded Wallets with the TON Blockchain | Embedded Wallets

While using the Embedded Wallets Web SDK (formerly Web3Auth) for a non-EVM chain like [TON](https://ton.org/), you can obtain the user's private key from the provider. Using this private key, you can use the corresponding libraries of the blockchain to make blockchain calls like getting the user's `account`, `balance`, `send transaction`, etc. We have highlighted a few methods here to get you started quickly.

:::note

The SDKs are now branded as MetaMask Embedded Wallet SDKs (formerly Web3Auth Plug and Play SDKs). Package names and APIs remain Web3Auth (for example, Web3Auth React SDK), and code snippets may reference `web3auth` identifiers.

:::

## Installation

```bash npm2yarn
npm install --save @web3auth/no-modal @web3auth/auth-adapter @web3auth/base tonweb @orbs-network/ton-access
```

## Initializing provider

### Getting the `rpc`

```typescript

const rpc = await getHttpEndpoint()
```

## TON Libraries

`TonWeb` is a JavaScript/TypeScript library that provides a high-level interface for interacting with the TON blockchain. It allows for the creation and management of wallets, signing transactions, and interacting with smart contracts.

`@orbs-network/ton-access` is a lightweight library that helps discover and connect to TON blockchain nodes. It provides an endpoint to the TON network, ensuring you can reliably connect to the blockchain for your operations.

## Get accounts

Using `getKeyPairFromPrivateKey()` and TON's wallet libraries, you can retrieve the user's account address.

```typescript

const rpc = await getHttpEndpoint()

export default class TonRPC {
  private provider: IProvider
  private tonweb: TonWeb

  constructor(provider: IProvider) {
    this.provider = provider
    this.tonweb = new TonWeb(new TonWeb.HttpProvider(rpc))
  }

  async getAccounts(): Promise<string> {
    try {
      const privateKey = await this.getPrivateKey()
      const keyPair = this.getKeyPairFromPrivateKey(privateKey)
      const WalletClass = this.tonweb.wallet.all['v3R2']
      const wallet = new WalletClass(this.tonweb.provider, {
        publicKey: keyPair.publicKey,
      })
      const address = await wallet.getAddress()
      return address.toString(true, true, true)
    } catch (error) {
      console.error('Error getting accounts:', error)
      return ''
    }
  }

  async getPrivateKey(): Promise<string> {
    try {
      return await this.provider.request({
        method: 'private_key',
      })
    } catch (error) {
      console.error('Error getting private key:', error)
      throw error
    }
  }

  public getKeyPairFromPrivateKey(privateKey: string): {
    publicKey: Uint8Array
    secretKey: Uint8Array
  } {
    const privateKeyBytes = new Uint8Array(
      privateKey.match(/.{1,2}/g)!.map(byte => parseInt(byte, 16))
    )

    if (privateKeyBytes.length !== 32) {
      const adjustedPrivateKey = new Uint8Array(32)
      adjustedPrivateKey.set(privateKeyBytes.slice(0, 32))
      return TonWeb.utils.nacl.sign.keyPair.fromSeed(adjustedPrivateKey)
    }

    return TonWeb.utils.nacl.sign.keyPair.fromSeed(privateKeyBytes)
  }
}
```

## Get balance

Using the account address we received in the previous step, we can fetch the balance using an RPC call to `tonweb.getBalance()`.

```typescript

export default class TonRPC {
  async getBalance(): Promise<string> {
    try {
      const address = await this.getAccounts()
      const balance = await this.tonweb.getBalance(address)
      return TonWeb.utils.fromNano(balance)
    } catch (error) {
      console.error('Error getting balance:', error)
      return '0'
    }
  }
}
```

## Send transaction

```typescript

export default class TonRPC {
  async sendTransaction(): Promise<any> {
    try {
      const privateKey = await this.getPrivateKey()
      const keyPair = this.getKeyPairFromPrivateKey(privateKey)
      const WalletClass = this.tonweb.wallet.all['v3R2']
      const wallet = new WalletClass(this.tonweb.provider, {
        publicKey: keyPair.publicKey,
      })

      const address = await wallet.getAddress()
      console.log('Wallet address:', address.toString(true, true, true))

      const balance = await this.tonweb.getBalance(address)
      console.log('Wallet balance:', TonWeb.utils.fromNano(balance))

      const isDeployed = balance !== '0'
      console.log('Is wallet deployed:', isDeployed)

      if (!isDeployed) {
        console.log(
          'Wallet not deployed or has zero balance. Please deploy the wallet and fund it before sending transactions.'
        )
        return { error: 'Wallet not deployed or has zero balance' }
      }

      let seqno
      for (let i = 0; i < 3; i++) {
        try {
          seqno = await wallet.methods.seqno().call()
          console.log('Current seqno:', seqno)
          if (seqno !== null) break
        } catch (seqnoError) {
          console.error(`Error getting seqno (attempt ${i + 1}):`, seqnoError)
        }
        await new Promise(resolve => setTimeout(resolve, 2000))
      }

      if (seqno === null) {
        throw new Error('Failed to retrieve seqno after multiple attempts')
      }

      const transfer = wallet.methods.transfer({
        secretKey: keyPair.secretKey,
        toAddress: 'EQD4FPq-PRDieyQKkizFTRtSDyucUIqrj0v_zXJmqaDp6_0t',
        amount: TonWeb.utils.toNano('0.01'),
        seqno: seqno,
        payload: 'Hello, TON!',
        sendMode: 3,
      })

      console.log('Prepared transfer:', transfer)

      const result = await transfer.send()
      console.log('Transaction result:', result)

      return {
        transactionHash: result.hash,
      }
    } catch (error) {
      console.error('Error sending transaction:', error)
      return { error: error.message }
    }
  }
}
```