Kotlin Blockchain Interaction - Polygon Developer Docs

All wallet operations require a selected wallet.

val walletAddress = requireNotNull(client.wallet.walletAddress) {
    "No wallet selected"
}

Supported Networks

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

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.

import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.utils.parseUnits

val result = client.wallet.sendTransaction(
    network = Network.AMOY,
    to = "0x1111111111111111111111111111111111111111",
    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 Encoded Calldata

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

import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.models.SendTransactionRequest
import java.math.BigInteger

val transferCalldata = "0xa9059cbb000000000000000000000000..."

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

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 optional `mode`. `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.

Convert Token Values

Use parseUnits before sending display amounts to the wallet API, and formatUnits when showing raw base-unit balances in the UI.

import com.omsclient.kotlin_sdk.utils.formatUnits
import com.omsclient.kotlin_sdk.utils.parseUnits

val rawUsdc = parseUnits("1.23", 6)
println(rawUsdc) // 1230000

val displayUsdc = formatUnits(rawUsdc, 6)
println(displayUsdc) // "1.23"

Parameters

Function	Parameter	Type	Description
`parseUnits`	`value`	`String`	Display amount to convert.
`parseUnits`	`decimals`	`Int`	Token decimals.
`formatUnits`	`value`	`BigInteger`	Raw base-unit integer to format.
`formatUnits`	`decimals`	`Int`	Token decimals.

Returns parseUnits returns BigInteger. formatUnits returns String.

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. Contract argument values use JsonPrimitive from kotlinx.serialization.json.

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 = "0x2222222222222222222222222222222222222222",
    method = "transfer(address,uint256)",
    args = listOf(
        AbiArg(type = "address", value = JsonPrimitive("0x1111111111111111111111111111111111111111")),
        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`	Advanced execution option. 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. On testnets, all transactions are sponsored and do not require picking a fee option. 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.

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.POLYGON,
    to = "0x1111111111111111111111111111111111111111",
    value = parseUnits("0", 18),
    selectFeeOption = FeeOptionSelector.firstAvailable,
)

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

val result = client.wallet.sendTransaction(
    network = Network.POLYGON,
    to = "0x1111111111111111111111111111111111111111",
    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. 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.

import com.omsclient.kotlin_sdk.Network
import com.omsclient.kotlin_sdk.utils.parseUnits

val tx = client.wallet.sendTransaction(
    network = Network.AMOY,
    to = "0x1111111111111111111111111111111111111111",
    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.

Field	Type	Description
`status`	`TransactionStatus`	Latest Wallet transaction status.
`txnHash`	`String?`	Onchain transaction hash when available.

Sign A Message

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

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.

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.

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.

​Supported Networks

​Send A Transaction

​Send Encoded Calldata

​Convert Token Values

​Call A Contract With Method And Args

​Select A Fee Option

​Polling And Status

​Sign A Message

​Verify A Message Signature

​Sign Typed Data

​Verify Typed Data

Supported Networks

Send A Transaction

Send Encoded Calldata

Convert Token Values

Call A Contract With Method And Args

Select A Fee Option

Polling And Status

Sign A Message

Verify A Message Signature

Sign Typed Data

Verify Typed Data