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

# Send transactions with React Native

> Send native transfers, encoded calls, and ABI contract calls through one transaction lifecycle.

Transaction operations require an active wallet session. `sendTransaction` and `callContract` are alternate input forms for the same prepare, fee, execute, and status lifecycle.

## Send a native transfer

Pass an exported network, a recipient, and a raw base-unit value:

```typescript theme={null}
import {
  Networks,
  parseUnits,
} from '@0xsequence/oms-react-native-sdk'

const transaction = await omsWallet.wallet.sendTransaction({
  network: Networks.amoy,
  to: '0x1111111111111111111111111111111111111111',
  value: parseUnits('0.01', 18),
})
```

`parseUnits` returns an integer string. Use the transferred token's decimals when converting user-facing values. It rounds excess fractional precision to the nearest base unit by default; pass `{ roundingMode: 'reject' }` when the input must match that precision exactly.

## Use encoded calldata

Use the same method when your app already has encoded calldata. Set `value` to the native-token amount sent with the call:

```typescript theme={null}
const transaction = await omsWallet.wallet.sendTransaction({
  network: Networks.amoy,
  to: '0x2222222222222222222222222222222222222222',
  value: '0',
  data: '0x095ea7b300000000000000000000000011111111111111111111111111111111111111110000000000000000000000000000000000000000000000000000000000000001',
})
```

## Call a contract by method

Use `callContract` when you have a method signature and typed argument values instead of encoded calldata:

```typescript theme={null}
const transaction = await omsWallet.wallet.callContract({
  network: Networks.amoy,
  contractAddress: '0x2222222222222222222222222222222222222222',
  method: 'transfer(address,uint256)',
  args: [
    {
      type: 'address',
      value: '0x1111111111111111111111111111111111111111',
    },
    { type: 'uint256', value: parseUnits('1', 6) },
  ],
})
```

`callContract` accepts the same execution mode, fee selector, wait setting, and polling options as `sendTransaction`.

## Understand the lifecycle

Both methods perform one lifecycle:

<Steps>
  <Step title="Prepare">
    The SDK resolves the transaction input for the selected network and obtains the execution quote.
  </Step>

  <Step title="Resolve fees">
    Sponsored transactions continue without app fee selection. When payment is required, the SDK passes quoted options to `selectFeeOption`.
  </Step>

  <Step title="Execute">
    The SDK submits the prepared wallet transaction and returns its `txnId`.
  </Step>

  <Step title="Wait for status">
    By default, the method polls until status resolves or polling times out. An onchain `txnHash` appears when available.
  </Step>
</Steps>

Leave `mode` undefined to use the SDK's default execution behavior. Set `'native'` or `'relayer'` only when your application explicitly controls that choice.

## Select a fee

Testnet transactions are sponsored and skip fee selection. For a non-sponsored mainnet transaction, use the built-in selector to choose the first quoted token whose raw available balance covers the fee:

```typescript theme={null}
import { FeeOptionSelectors } from '@0xsequence/oms-react-native-sdk'

const transaction = await omsWallet.wallet.sendTransaction({
  network: Networks.polygon,
  to: '0x1111111111111111111111111111111111111111',
  value: '0',
  selectFeeOption: FeeOptionSelectors.firstAvailable,
})
```

If you omit `selectFeeOption`, the SDK uses the first option returned by OMS without checking whether the wallet can afford it.

For custom selection, return an option's `selection`. This example prefers a quoted USDC fee and returns `undefined` when none is available:

```typescript theme={null}
const transaction = await omsWallet.wallet.sendTransaction({
  network: Networks.polygon,
  to: '0x1111111111111111111111111111111111111111',
  value: '0',
  selectFeeOption: (options) =>
    options.find((option) => option.feeOption.token.symbol === 'USDC')
      ?.selection,
})
```

Each option contains `feeOption`, `selection`, and optional balance and available-amount fields. The callback can return synchronously or as a promise.

## Read the result

Both transaction methods return:

| Field              | Type              | Meaning                                               |                                     |                                        |             |                      |
| ------------------ | ----------------- | ----------------------------------------------------- | ----------------------------------- | -------------------------------------- | ----------- | -------------------- |
| `txnId`            | `string`          | Wallet transaction ID. Preserve it for status checks. |                                     |                                        |             |                      |
| `status`           | \`'quoted'        | 'pending'                                             | 'executed'                          | 'failed'                               | 'unknown'\` | Latest known status. |
| `txnHash`          | \`string          | undefined\`                                           | Onchain hash when one is available. |                                        |             |                      |
| `statusResolution` | \`'not-requested' | 'resolved'                                            | 'timed-out'\`                       | Outcome of post-submit status waiting. |             |                      |

`waitForStatus` defaults to `true`. A timed-out status resolution does not remove `txnId`; check that ID before retrying the write.

## Control status waiting

Return after submission without waiting:

```typescript theme={null}
const transaction = await omsWallet.wallet.sendTransaction({
  network: Networks.amoy,
  to: '0x1111111111111111111111111111111111111111',
  value: '0',
  waitForStatus: false,
})
```

Check the latest status later:

```typescript theme={null}
const latest = await omsWallet.wallet.getTransactionStatus(transaction.txnId)
console.log(latest.status, latest.txnHash)
```

Override polling only when the default wait behavior does not fit your UI:

```typescript theme={null}
const transaction = await omsWallet.wallet.sendTransaction({
  network: Networks.amoy,
  to: '0x1111111111111111111111111111111111111111',
  value: '0',
  statusPolling: {
    timeoutMs: 120000,
    intervalMs: 3000,
    fastIntervalMs: 500,
    fastPollCount: 6,
  },
})
```

Message and typed-data signatures do not submit transactions. Use [sign and verify](/wallets/sdk/react-native/sign-and-verify) for those operations.