> ## 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.

# Kotlin Blockchain Interaction

> Send transactions, call contracts, verify signatures, and sign messages with the Kotlin OMS Wallet SDK.

All wallet operations require a selected wallet.

```kotlin theme={null}
val walletAddress = requireNotNull(client.wallet.walletAddress) {
    "No wallet selected"
}
```

## Supported Networks

Use the SDK network registry when passing `network` to wallet and indexer calls.

```kotlin theme={null}
import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.findNetworkById
import com.omsclient.kotlin_sdk.findNetworkByName

val amoy = findNetworkById(80002) ?: Network.AMOY
val polygon = findNetworkByName("polygon")

println("${amoy.displayName} ${polygon?.id}")

for (network in client.supportedNetworks) {
    println("${network.id} ${network.displayName} ${network.nativeTokenSymbol}")
}
```

**Parameters**

`findNetworkById` takes a numeric chain ID. `findNetworkByName` takes a registry name such as `polygon`, `amoy`, or `base-sepolia`.

**Returns**

`client.supportedNetworks` returns every `Network` supported by the SDK build. Top-level `supportedNetworks` returns the same list. Lookup helpers return `Network?`.

## Send A Transaction

`sendTransaction` sends native tokens. Values are raw base-unit integers. Use `parseUnits` for display amounts.

```kotlin theme={null}
import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.utils.parseUnits

val result = client.wallet.sendTransaction(
    network = Network.AMOY,
    to = "0xRecipient",
    value = parseUnits("0.01", 18),
)

println("Transaction id: ${result.txnId}")
println("Status: ${result.status}")
println("Transaction hash: ${result.txnHash}")
```

**Parameters**

| Parameter         | Type                               | Description                                                               |
| ----------------- | ---------------------------------- | ------------------------------------------------------------------------- |
| `network`         | `Network`                          | Supported SDK network, such as `Network.POLYGON` or `Network.AMOY`.       |
| `to`              | `String`                           | Recipient address.                                                        |
| `value`           | `BigInteger`                       | Raw base-unit native token value.                                         |
| `waitForStatus`   | `Boolean`                          | Defaults to `true`. Set to `false` to return immediately after execution. |
| `statusPolling`   | `TransactionStatusPollingOptions?` | Optional fast poll, slow poll, and timeout configuration.                 |
| `selectFeeOption` | `FeeOptionSelector?`               | Optional callback for selecting a fee option.                             |

**Returns**

Returns `SendTransactionResponse`.

| Field     | Type                | Description                                       |
| --------- | ------------------- | ------------------------------------------------- |
| `txnId`   | `String`            | Wallet transaction ID.                            |
| `status`  | `TransactionStatus` | Latest transaction status returned by OMS Wallet. |
| `txnHash` | `String?`           | Onchain transaction hash when available.          |

## Send Raw Calldata

Use the transaction request overload when you already have encoded calldata.

```kotlin theme={null}
import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.models.SendTransactionRequest
import com.omsclient.kotlin_sdk.models.TransactionMode
import java.math.BigInteger

val transferCalldata = "0xa9059cbb000000000000000000000000..."

val result = client.wallet.sendTransaction(
    network = Network.AMOY,
    request = SendTransactionRequest(
        to = "0xTokenContract",
        value = BigInteger.ZERO,
        data = transferCalldata,
        mode = TransactionMode.Relayer,
    ),
)

println("Contract transaction hash: ${result.txnHash}")
```

**Parameters**

| Parameter         | Type                               | Description                                                                   |
| ----------------- | ---------------------------------- | ----------------------------------------------------------------------------- |
| `network`         | `Network`                          | Supported SDK network.                                                        |
| `request`         | `SendTransactionRequest`           | Request with `to`, raw `value`, optional encoded calldata `data`, and `mode`. |
| `waitForStatus`   | `Boolean`                          | Defaults to `true`. Set to `false` to return immediately after execution.     |
| `statusPolling`   | `TransactionStatusPollingOptions?` | Optional fast poll, slow poll, and timeout configuration.                     |
| `selectFeeOption` | `FeeOptionSelector?`               | Optional callback for selecting a fee option.                                 |

**Returns**

Returns `SendTransactionResponse`.

## Call A Contract With Method And Args

Use `callContract` for state-changing contract methods. The SDK prepares the contract call, executes it, and polls for transaction status.

```kotlin theme={null}
import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.models.AbiArg
import com.omsclient.kotlin_sdk.utils.parseUnits
import kotlinx.serialization.json.JsonPrimitive

val amount = parseUnits("1", 6)

val result = client.wallet.callContract(
    network = Network.AMOY,
    contract = "0xTokenContract",
    method = "transfer(address,uint256)",
    args = listOf(
        AbiArg(type = "address", value = JsonPrimitive("0xRecipient")),
        AbiArg(type = "uint256", value = JsonPrimitive(amount.toString())),
    ),
)

println("Contract transaction hash: ${result.txnHash}")
```

**Parameters**

| Parameter         | Type                               | Description                                                               |
| ----------------- | ---------------------------------- | ------------------------------------------------------------------------- |
| `network`         | `Network`                          | Supported SDK network.                                                    |
| `contract`        | `String`                           | Contract address to call.                                                 |
| `method`          | `String`                           | ABI method signature, such as `transfer(address,uint256)`.                |
| `args`            | `List<AbiArg>?`                    | Method arguments as ABI args.                                             |
| `mode`            | `TransactionMode`                  | Transaction mode. Defaults to `TransactionMode.Relayer`.                  |
| `waitForStatus`   | `Boolean`                          | Defaults to `true`. Set to `false` to return immediately after execution. |
| `statusPolling`   | `TransactionStatusPollingOptions?` | Optional fast poll, slow poll, and timeout configuration.                 |
| `selectFeeOption` | `FeeOptionSelector?`               | Optional callback for selecting a fee option.                             |

**Returns**

Returns `SendTransactionResponse`.

## Select A Fee Option

When a prepared transaction returns fee options, pass a selector callback. The selector receives fee options enriched with the wallet balance for each fee token when available.

Use `FeeOptionSelector.firstAvailable` when you want the SDK to choose the first fee option whose `availableRaw` balance covers the quoted fee `value`. This is the standard selector for apps that do not need a custom fee-token picker.

On testnets, fee options are automatically sponsored, so you usually do not need to choose a fee token.

```kotlin theme={null}
import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.models.FeeOptionSelector
import com.omsclient.kotlin_sdk.utils.parseUnits

val result = client.wallet.sendTransaction(
    network = Network.AMOY,
    to = "0xRecipient",
    value = parseUnits("0", 18),
    selectFeeOption = FeeOptionSelector.firstAvailable,
)
```

Use a custom selector when the app needs to prefer a specific token.

```kotlin theme={null}
val result = client.wallet.sendTransaction(
    network = Network.AMOY,
    to = "0xRecipient",
    value = parseUnits("0", 18),
    selectFeeOption = FeeOptionSelector { feeOptions ->
        feeOptions.firstOrNull { it.feeOption.token.symbol == "USDC" }?.selection
    },
)
```

If you do not pass a selector, the SDK uses the first required fee option, or no fee option when the transaction is sponsored.

**Parameters**

`selectFeeOption` receives a list of `FeeOptionWithBalance` values. Each item includes `feeOption`, `selection`, and optional `balance`, `available`, `availableRaw`, and `decimals` fields.

**Returns**

Return `FeeOptionSelection?`.

## Polling And Status

Transaction helpers execute and poll for transaction status. Fetch status directly when you have a Wallet transaction ID.

```kotlin theme={null}
import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.utils.parseUnits

val tx = client.wallet.sendTransaction(
    network = Network.AMOY,
    to = "0xRecipient",
    value = parseUnits("0", 18),
    waitForStatus = false,
)

val status = client.wallet.getTransactionStatus(txnId = tx.txnId)

println("Status: ${status.status}")
println("Transaction hash: ${status.txnHash}")
```

**Parameters**

| Parameter | Type     | Description                                                            |
| --------- | -------- | ---------------------------------------------------------------------- |
| `txnId`   | `String` | Wallet transaction ID returned by `sendTransaction` or `callContract`. |

**Returns**

Returns `TransactionStatusResponse`.

## Sign A Message

```kotlin theme={null}
import com.omsclient.kotlin_sdk.Network

val signature = client.wallet.signMessage(
    network = Network.AMOY,
    message = "Hello from OMS",
)

println("Signature: $signature")
```

**Parameters**

| Parameter | Type      | Description                |
| --------- | --------- | -------------------------- |
| `network` | `Network` | Supported SDK network.     |
| `message` | `String`  | Plaintext message to sign. |

**Returns**

Returns `String`, the hex-encoded signature.

## Verify A Message Signature

```kotlin theme={null}
val isValid = client.wallet.isValidMessageSignature(
    network = Network.AMOY,
    message = "Hello from OMS",
    signature = signature,
)

println("Signature valid: $isValid")
```

**Parameters**

| Parameter   | Type      | Description                                                  |
| ----------- | --------- | ------------------------------------------------------------ |
| `network`   | `Network` | Supported SDK network.                                       |
| `message`   | `String`  | Original plaintext message.                                  |
| `signature` | `String`  | Hex-encoded signature to verify against the selected wallet. |

**Returns**

Returns `Boolean`.

## Sign Typed Data

Use `signTypedData` for EIP-712 typed data. Build the payload with `JsonElement` values.

```kotlin theme={null}
import kotlinx.serialization.json.add
import kotlinx.serialization.json.buildJsonArray
import kotlinx.serialization.json.buildJsonObject
import kotlinx.serialization.json.put

val typedData = buildJsonObject {
    put("domain", buildJsonObject {
        put("name", "Example App")
        put("version", "1")
        put("chainId", 80002)
    })
    put("types", buildJsonObject {
        put("Message", buildJsonArray {
            add(buildJsonObject {
                put("name", "contents")
                put("type", "string")
            })
        })
    })
    put("primaryType", "Message")
    put("message", buildJsonObject {
        put("contents", "Hello from OMS")
    })
}

val typedSignature = client.wallet.signTypedData(
    network = Network.AMOY,
    typedData = typedData,
)
```

**Parameters**

| Parameter   | Type          | Description                 |
| ----------- | ------------- | --------------------------- |
| `network`   | `Network`     | Supported SDK network.      |
| `typedData` | `JsonElement` | EIP-712 typed-data payload. |

**Returns**

Returns `String`, the hex-encoded signature.

## Verify Typed Data

Verify an EIP-712 typed-data signature against the selected wallet.

```kotlin theme={null}
val typedDataValid = client.wallet.isValidTypedDataSignature(
    network = Network.AMOY,
    typedData = typedData,
    signature = typedSignature,
)
```

**Parameters**

| Parameter   | Type          | Description                          |
| ----------- | ------------- | ------------------------------------ |
| `network`   | `Network`     | Supported SDK network.               |
| `typedData` | `JsonElement` | Original EIP-712 typed-data payload. |
| `signature` | `String`      | Hex-encoded signature to verify.     |

**Returns**

Returns `Boolean`.