> ## Documentation Index
> Fetch the complete documentation index at: https://docs.initia.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Sending Transactions

Sending transactions using InitiaJS is straightforward. First, import the
necessary classes and functions.

```ts theme={null}
import {
  Wallet,
  RESTClient,
  MnemonicKey,
  MsgSend,
  Tx,
  WaitTxBroadcastResult,
} from '@initia/initia.js'
```

Next, set up your environment variables. You will need the following:

* `MNEMONIC`: The mnemonic of the account that will be sending the transaction.
* `REST_URL`: The URL of the Initia REST.
* `GAS_PRICES`: The gas prices for the transaction.
* `SENDER_ADDRESS`: The address of the account that will be sending the
  transaction.
* `RECIPIENT_ADDRESS`: The address of the account that will be receiving the
  transaction.
* `AMOUNT`: The amount of tokens to send.

```ts theme={null}
if (!process.env.MNEMONIC) {
  throw new Error('MNEMONIC environment variable is required')
}
const mnemonic = process.env.MNEMONIC
const restUrl = process.env.REST_URL || 'https://rest.testnet.initia.xyz'
const gasPrices = process.env.GAS_PRICES || '0.015uinit' // Will be INIT for mainnet

const senderAddress =
  process.env.SENDER_ADDRESS || 'init1w4cqq6udjqtvl5xx0x6gjeyzgwtze8c05kysnu'
const recipientAddress =
  process.env.RECIPIENT_ADDRESS || 'init1w4cqq6udjqtvl5xx0x6gjeyzgwtze8c05kysnu'
const amount = process.env.AMOUNT || '1000uinit'
```

You can then use these variables to ultimately create the `wallet` client, as
well as the `sendMsg` object. Since for this example you're making a token
transfer, we'll use the `MsgSend` object. But the SDK provides many other
message types for different actions related to staking, governance, and more.

```ts theme={null}
const key: MnemonicKey = new MnemonicKey({ mnemonic }) // Create a key from the mnemonic
const restClient: RESTClient = new RESTClient(restUrl, { gasPrices })
const wallet: Wallet = new Wallet(restClient, key)

const sendMsg: MsgSend = new MsgSend(senderAddress, recipientAddress, amount)
```

Next, create the function to send the transaction.

* First, create the transaction by calling `wallet.createAndSignTx`. This
  function takes in the raw message object, signs it using the `wallet`, and
  returns a signed transaction object.
* Then, broadcast the transaction by calling `restClient.tx.broadcast`. This
  function takes in the signed transaction object and broadcasts it to the
  network.

```ts theme={null}
async function sendTransaction(): Promise<WaitTxBroadcastResult> {
  try {
    const signedTx: Tx = await wallet.createAndSignTx({
      msgs: [sendMsg],
      memo: 'memo',
    })

    const result: WaitTxBroadcastResult =
      await restClient.tx.broadcast(signedTx)
    console.log('Transaction successful')
    console.log('Transaction hash:', result.txhash)
    return result
  } catch (error: unknown) {
    if (error instanceof Error) {
      console.error('Transaction failed:', error.message)
    } else {
      console.error('Transaction failed with an unknown error')
    }
    throw error
  }
}
```

Finally, call the function to send the transaction.

```ts theme={null}
sendTransaction()
  .then(() => process.exit(0))
  .catch(() => process.exit(1))
```

If you then run the script using `npx ts-node src/sending-transactions.ts`, you
should see an output similar to the following:

```
Transaction successful
Transaction hash: 4F0B810D15FA7D6A2B9EC2B98B263B0A20E791A8DABCB549620445941B25C699
```

### Full Example

```ts src/sending-transactions.ts theme={null}
import {
  Wallet,
  RESTClient,
  MnemonicKey,
  MsgSend,
  Tx,
  WaitTxBroadcastResult,
} from '@initia/initia.js'

const mnemonic = process.env.MNEMONIC
const restUrl = process.env.REST_URL || 'https://rest.testnet.initia.xyz'
const gasPrices = process.env.GAS_PRICES || '0.015uinit' // Will be INIT for mainnet

const senderAddress =
  process.env.SENDER_ADDRESS || 'init1w4cqq6udjqtvl5xx0x6gjeyzgwtze8c05kysnu'
const recipientAddress =
  process.env.RECIPIENT_ADDRESS || 'init1w4cqq6udjqtvl5xx0x6gjeyzgwtze8c05kysnu'
const amount = process.env.AMOUNT || '1000uinit'

const key: MnemonicKey = new MnemonicKey({ mnemonic })
const restClient: RESTClient = new RESTClient(restUrl, { gasPrices })
const wallet: Wallet = new Wallet(restClient, key)

const sendMsg: MsgSend = new MsgSend(senderAddress, recipientAddress, amount)

async function sendTransaction(): Promise<WaitTxBroadcastResult> {
  try {
    const signedTx: Tx = await wallet.createAndSignTx({
      msgs: [sendMsg],
      memo: 'memo',
    })

    const result: WaitTxBroadcastResult =
      await restClient.tx.broadcast(signedTx)
    console.log('Transaction successful')
    console.log('Transaction hash:', result.txhash)
    return result
  } catch (error: unknown) {
    if (error instanceof Error) {
      console.error('Transaction failed:', error.message)
    } else {
      console.error('Transaction failed with an unknown error')
    }
    throw error
  }
}

sendTransaction()
  .then(() => process.exit(0))
  .catch(() => process.exit(1))
```