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

# React Native API reference

> Complete public API reference for the OMS Wallet React Native SDK.

## OMSWallet

### `OMSWallet`

```ts theme={null}
export declare class OMSWallet {
    readonly wallet: OMSWalletClient;
    readonly indexer: OMSIndexerClient;
    constructor(_config: OMSWalletParams);
}
```

### `OMSWalletParams`

```ts theme={null}
export type OMSWalletParams = {
    publishableKey: string;
};
```

## Authentication and sessions

### `OMSWalletClient.getWalletAddress`

```ts theme={null}
getWalletAddress(): Promise<string | undefined>;
```

### `OMSWalletClient.getSession`

```ts theme={null}
getSession(): Promise<OMSWalletSessionState>;
```

### `OMSWalletClient.onSessionExpired`

```ts theme={null}
onSessionExpired(_listener: (event: OMSWalletSessionExpiredEvent) => void): EventSubscription;
```

### `OMSWalletClient.startEmailAuth`

```ts theme={null}
startEmailAuth(_params: StartEmailAuthParams): Promise<void>;
```

### `OMSWalletClient.completeEmailAuth`

```ts theme={null}
completeEmailAuth(_params: CompleteEmailAuthParams): Promise<CompleteAuthResult>;
```

### `OMSWalletClient.signInWithOidcIdToken`

```ts theme={null}
signInWithOidcIdToken(_params: SignInWithOidcIdTokenParams): Promise<CompleteAuthResult>;
```

### `OMSWalletClient.startOidcRedirectAuth`

```ts theme={null}
startOidcRedirectAuth(_params: StartOidcRedirectAuthParams): Promise<StartOidcRedirectAuthResult>;
```

### `OMSWalletClient.handleOidcRedirectCallback`

```ts theme={null}
handleOidcRedirectCallback(_params: HandleOidcRedirectCallbackParams): Promise<OidcRedirectAuthResult>;
```

### `OMSWalletClient.listWallets`

```ts theme={null}
listWallets(): Promise<WalletAccount[]>;
```

### `OMSWalletClient.useWallet`

```ts theme={null}
useWallet(_walletId: string): Promise<WalletActivationResult>;
```

### `OMSWalletClient.createWallet`

```ts theme={null}
createWallet(_params?: CreateWalletParams): Promise<WalletActivationResult>;
```

### `OMSWalletClient.signOut`

```ts theme={null}
signOut(): Promise<void>;
```

### `OMSWalletClient.getIdToken`

```ts theme={null}
getIdToken(_params?: GetIdTokenParams): Promise<string>;
```

### `OMSWalletClient.listAccess`

```ts theme={null}
listAccess(_params?: ListAccessParams): Promise<CredentialInfo[]>;
```

### `OMSWalletClient.listAccessPages`

```ts theme={null}
listAccessPages(_params?: ListAccessPagesParams): AsyncGenerator<ListAccessResponse, void, void>;
```

### `OMSWalletClient.listAccessPage`

```ts theme={null}
listAccessPage(_params?: ListAccessPageParams): Promise<ListAccessResponse>;
```

### `OMSWalletClient.revokeAccess`

```ts theme={null}
revokeAccess(_targetCredentialId: string): Promise<void>;
```

### `OmsRelayOidcProviders`

```ts theme={null}
export declare const OmsRelayOidcProviders: Readonly<{
    google: OmsRelayOidcProvider;
    apple: OmsRelayOidcProvider;
}>;
```

### `WalletType`

```ts theme={null}
export type WalletType = 'ethereum';
```

### `WalletSelectionBehavior`

```ts theme={null}
export type WalletSelectionBehavior = 'automatic' | 'manual';
```

### `OMSWalletEmailSessionAuth`

```ts theme={null}
export type OMSWalletEmailSessionAuth = {
    type: 'email';
    email: string;
};
```

### `OMSWalletOidcSessionAuthFlow`

```ts theme={null}
export type OMSWalletOidcSessionAuthFlow = 'redirect' | 'id-token';
```

### `OMSWalletOidcSessionAuth`

```ts theme={null}
export type OMSWalletOidcSessionAuth = {
    type: 'oidc';
    flow: OMSWalletOidcSessionAuthFlow;
    issuer: string;
    provider: string | undefined;
    providerLabel: string | undefined;
    email: string | undefined;
};
```

### `OMSWalletSessionAuth`

```ts theme={null}
export type OMSWalletSessionAuth = OMSWalletEmailSessionAuth | OMSWalletOidcSessionAuth;
```

### `OMSWalletSessionState`

```ts theme={null}
export type OMSWalletSessionState = {
    walletAddress: string | undefined;
    expiresAt: string | undefined;
    auth: OMSWalletSessionAuth | undefined;
};
```

### `OMSWalletSessionExpiredEvent`

```ts theme={null}
export type OMSWalletSessionExpiredEvent = {
    session: OMSWalletSessionState;
    expiredAt: string;
};
```

### `WalletAccount`

```ts theme={null}
export type WalletAccount = {
    id: string;
    type: WalletType;
    address: string;
    reference?: string;
};
```

### `WalletActivationResult`

```ts theme={null}
export type WalletActivationResult = {
    walletAddress: string;
    wallet: WalletAccount;
};
```

### `CredentialInfo`

```ts theme={null}
export type CredentialInfo = {
    credentialId: string;
    expiresAt: string;
    isCaller: boolean;
};
```

### `PendingWalletSelection`

```ts theme={null}
export type PendingWalletSelection = {
    walletType: WalletType;
    wallets: WalletAccount[];
    credential: CredentialInfo;
    selectWallet(walletId: string): Promise<WalletActivationResult>;
    createAndSelectWallet(reference?: string): Promise<WalletActivationResult>;
};
```

### `CompleteAuthResult`

```ts theme={null}
export type CompleteAuthResult = {
    type: 'walletSelected';
    walletAddress: string;
    wallet: WalletAccount;
    wallets: WalletAccount[];
    credential: CredentialInfo;
    pendingSelection?: undefined;
} | {
    type: 'walletSelection';
    walletAddress: undefined;
    wallet: undefined;
    wallets: WalletAccount[];
    credential: CredentialInfo;
    pendingSelection: PendingWalletSelection;
};
```

### `StartEmailAuthParams`

```ts theme={null}
export type StartEmailAuthParams = {
    email: string;
    sessionLifetimeSeconds?: number;
};
```

### `CompleteEmailAuthParams`

```ts theme={null}
export type CompleteEmailAuthParams = {
    code: string;
    walletSelection?: WalletSelectionBehavior;
    walletType?: WalletType;
};
```

### `SignInWithOidcIdTokenParams`

```ts theme={null}
export type SignInWithOidcIdTokenParams = {
    idToken: string;
    issuer: string;
    audience: string;
    walletSelection?: WalletSelectionBehavior;
    walletType?: WalletType;
    sessionLifetimeSeconds?: number;
    provider?: string;
    providerLabel?: string;
};
```

### `OidcAuthMode`

```ts theme={null}
export type OidcAuthMode = 'auth-code' | 'auth-code-pkce';
```

### `OmsRelayOidcProvider`

An opaque SDK-owned registry value. It must come from
`OmsRelayOidcProviders`; object literals are invalid.

```ts theme={null}
export type OmsRelayOidcProvider = {
    readonly provider: 'google' | 'apple';
};
```

### `CustomOidcProviderConfig`

```ts theme={null}
export type CustomOidcProviderConfig = {
    issuer: string;
    clientId: string;
    authorizationUrl: string;
    providerRedirectUri: string;
    provider?: string;
    providerLabel?: string;
    scopes?: string[];
    authorizeParams?: Record<string, string>;
    authMode?: OidcAuthMode;
};
```

### `OidcProviderConfig`

```ts theme={null}
export type OidcProviderConfig = OmsRelayOidcProvider | CustomOidcProviderConfig;
```

### `StartOidcRedirectAuthParams`

```ts theme={null}
export type StartOidcRedirectAuthParams = {
    walletType?: WalletType;
    walletSelection?: WalletSelectionBehavior;
    sessionLifetimeSeconds?: number;
    loginHint?: string;
} & ({
    provider: OmsRelayOidcProvider;
    omsRelayReturnUri: string;
    authorizeParams?: never;
} | {
    provider: CustomOidcProviderConfig;
    omsRelayReturnUri?: never;
    authorizeParams?: Record<string, string>;
});
```

### `StartOidcRedirectAuthResult`

```ts theme={null}
export type StartOidcRedirectAuthResult = {
    authorizationUrl: string;
};
```

### `HandleOidcRedirectCallbackParams`

```ts theme={null}
export type HandleOidcRedirectCallbackParams = {
    callbackUrl: string;
    walletSelection?: WalletSelectionBehavior;
    sessionLifetimeSeconds?: number;
};
```

### `OidcRedirectAuthResult`

```ts theme={null}
export type OidcRedirectAuthResult = {
    type: 'completed';
    result: CompleteAuthResult;
} | {
    type: 'notOidcRedirectCallback' | 'noPendingAuth';
    result?: undefined;
};
```

### `CreateWalletParams`

```ts theme={null}
export type CreateWalletParams = {
    walletType?: WalletType;
    reference?: string;
};
```

### `GetIdTokenParams`

```ts theme={null}
export type GetIdTokenParams = {
    ttlSeconds?: number;
    customClaims?: Record<string, unknown>;
};
```

### `AccessPage`

```ts theme={null}
export type AccessPage = {
    limit?: number;
    cursor?: string;
};
```

### `ListAccessResponse`

```ts theme={null}
export type ListAccessResponse = {
    credentials: CredentialInfo[];
    page?: AccessPage;
};
```

### `ListAccessParams`

```ts theme={null}
export type ListAccessParams = {
    pageSize?: number;
};
```

### `ListAccessPagesParams`

```ts theme={null}
export type ListAccessPagesParams = {
    pageSize?: number;
};
```

### `ListAccessPageParams`

```ts theme={null}
export type ListAccessPageParams = {
    pageSize?: number;
    cursor?: string;
};
```

## Transactions and signing

### `OMSWalletClient.signMessage`

```ts theme={null}
signMessage(_params: SignMessageParams): Promise<string>;
```

### `OMSWalletClient.signTypedData`

```ts theme={null}
signTypedData(_params: SignTypedDataParams): Promise<string>;
```

### `OMSWalletClient.sendTransaction`

```ts theme={null}
sendTransaction(_params: SendTransactionParams): Promise<SendTransactionResponse>;
```

### `OMSWalletClient.callContract`

```ts theme={null}
callContract(_params: CallContractParams): Promise<SendTransactionResponse>;
```

### `OMSWalletClient.getTransactionStatus`

```ts theme={null}
getTransactionStatus(_txnId: string): Promise<TransactionStatusResponse>;
```

### `OMSWalletClient.isValidMessageSignature`

```ts theme={null}
isValidMessageSignature(_params: IsValidMessageSignatureParams): Promise<boolean>;
```

### `OMSWalletClient.isValidTypedDataSignature`

```ts theme={null}
isValidTypedDataSignature(_params: IsValidTypedDataSignatureParams): Promise<boolean>;
```

### `FeeOptionSelectors`

```ts theme={null}
export declare const FeeOptionSelectors: Readonly<{
    firstAvailable: FeeOptionSelector;
}>;
```

### `SignMessageParams`

```ts theme={null}
export type SignMessageParams = {
    network: Network;
    message: string;
};
```

### `SignTypedDataParams`

```ts theme={null}
export type SignTypedDataParams = {
    network: Network;
    typedData: unknown;
};
```

### `IsValidMessageSignatureParams`

```ts theme={null}
export type IsValidMessageSignatureParams = {
    network: Network;
    message: string;
    signature: string;
};
```

### `IsValidTypedDataSignatureParams`

```ts theme={null}
export type IsValidTypedDataSignatureParams = {
    network: Network;
    typedData: unknown;
    signature: string;
};
```

### `CallContractArg`

```ts theme={null}
export type CallContractArg = {
    type: string;
    value: unknown;
};
```

### `TransactionMode`

```ts theme={null}
export type TransactionMode = 'native' | 'relayer';
```

### `TransactionStatus`

```ts theme={null}
export type TransactionStatus = 'quoted' | 'pending' | 'executed' | 'failed' | 'unknown';
```

### `TransactionStatusResolution`

```ts theme={null}
export type TransactionStatusResolution = 'not-requested' | 'resolved' | 'timed-out';
```

### `TransactionStatusPollingOptions`

```ts theme={null}
export type TransactionStatusPollingOptions = {
    timeoutMs?: number;
    intervalMs?: number;
    fastIntervalMs?: number;
    fastPollCount?: number;
};
```

### `SendTransactionResponse`

```ts theme={null}
export type SendTransactionResponse = {
    txnId: string;
    status: TransactionStatus;
    txnHash?: string;
    statusResolution: TransactionStatusResolution;
};
```

### `TransactionStatusResponse`

```ts theme={null}
export type TransactionStatusResponse = {
    status: TransactionStatus;
    txnHash?: string;
};
```

### `FeeToken`

```ts theme={null}
export type FeeToken = {
    network: string;
    name: string;
    symbol: string;
    type: string;
    decimals?: number;
    logoUrl?: string;
    contractAddress?: string;
    tokenId?: string;
};
```

### `FeeOption`

```ts theme={null}
export type FeeOption = {
    token: FeeToken;
    value: string;
    displayValue: string;
};
```

### `FeeOptionSelection`

```ts theme={null}
export type FeeOptionSelection = {
    token: string;
};
```

### `FeeOptionWithBalance`

```ts theme={null}
export type FeeOptionWithBalance = {
    feeOption: FeeOption;
    selection: FeeOptionSelection;
    balance?: TokenBalance;
    available?: string;
    availableRaw?: string;
    decimals?: number;
};
```

### `FeeOptionSelector`

```ts theme={null}
export type FeeOptionSelector = (feeOptions: FeeOptionWithBalance[]) => FeeOptionSelection | undefined | Promise<FeeOptionSelection | undefined>;
```

### `SendTransactionParams`

```ts theme={null}
export type SendTransactionParams = {
    network: Network;
    to: string;
    value: string;
    data?: string;
    mode?: TransactionMode;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};
```

### `CallContractParams`

```ts theme={null}
export type CallContractParams = {
    network: Network;
    contractAddress: string;
    method: string;
    args?: CallContractArg[];
    mode?: TransactionMode;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};
```

## Indexer

### `OMSIndexerClient.getBalances`

```ts theme={null}
getBalances(_params: GetBalancesParams): Promise<BalancesResult>;
```

### `OMSIndexerClient.getTransactionHistory`

```ts theme={null}
getTransactionHistory(_params: GetTransactionHistoryParams): Promise<TransactionHistoryResult>;
```

### `IndexerNetworkType`

```ts theme={null}
export type IndexerNetworkType = 'MAINNETS' | 'TESTNETS' | 'ALL';
```

### `ContractVerificationStatus`

```ts theme={null}
export type ContractVerificationStatus = 'VERIFIED' | 'UNVERIFIED' | 'ALL';
```

### `MetadataOptions`

```ts theme={null}
export type MetadataOptions = {
    verifiedOnly?: boolean;
    unverifiedOnly?: boolean;
    includeContracts?: string[];
};
```

### `TokenBalancesPageRequest`

```ts theme={null}
export type TokenBalancesPageRequest = {
    page?: number;
    pageSize?: number;
};
```

### `TokenBalancesPage`

```ts theme={null}
export type TokenBalancesPage = {
    page: number;
    pageSize: number;
    more: boolean;
};
```

### `TokenContractInfo`

```ts theme={null}
export type TokenContractInfo = {
    chainId: number;
    address: string;
    source: string;
    name: string;
    type: string;
    symbol: string;
    decimals?: number;
    logoURI?: string;
    deployed: boolean;
    bytecodeHash: string;
    extensions: Record<string, unknown>;
    updatedAt: string;
    queuedAt?: string;
    status: string;
};
```

### `TokenMetadataAsset`

```ts theme={null}
export type TokenMetadataAsset = {
    id?: number;
    collectionId?: number;
    tokenId?: string;
    url?: string;
    metadataField?: string;
    name?: string;
    filesize?: number;
    mimeType?: string;
    width?: number;
    height?: number;
    updatedAt?: string;
};
```

### `TokenMetadata`

```ts theme={null}
export type TokenMetadata = {
    chainId?: number;
    contractAddress?: string;
    tokenId: string;
    source: string;
    name: string;
    description?: string;
    image?: string;
    video?: string;
    audio?: string;
    properties?: Record<string, unknown>;
    attributes: Record<string, unknown>[];
    imageData?: string;
    externalUrl?: string;
    backgroundColor?: string;
    animationUrl?: string;
    decimals?: number;
    updatedAt?: string;
    assets?: TokenMetadataAsset[];
    status: string;
    queuedAt?: string;
    lastFetched?: string;
};
```

### `NativeTokenBalance`

```ts theme={null}
export type NativeTokenBalance = {
    contractType: 'NATIVE';
    contractAddress?: undefined;
    accountAddress: string;
    tokenId?: undefined;
    name: string;
    symbol: string;
    balance: string;
    chainId: number;
    balanceUSD?: string;
    priceUSD?: string;
    priceUpdatedAt?: string;
};
```

### `ContractTokenBalance`

```ts theme={null}
export type ContractTokenBalance = {
    contractType: string;
    contractAddress: string;
    accountAddress: string;
    tokenId: string;
    balance: string;
    blockHash: string;
    blockNumber: number;
    chainId: number;
    balanceUSD?: string;
    priceUSD?: string;
    priceUpdatedAt?: string;
    uniqueCollectibles?: string;
    isSummary?: boolean;
    contractInfo?: TokenContractInfo;
    tokenMetadata?: TokenMetadata;
};
```

### `TokenBalance`

```ts theme={null}
export type TokenBalance = NativeTokenBalance | ContractTokenBalance;
```

### `BalancesResult`

```ts theme={null}
export type BalancesResult = {
    status: number;
    page?: TokenBalancesPage;
    nativeBalances: NativeTokenBalance[];
    balances: ContractTokenBalance[];
};
```

### `GetBalancesParams`

```ts theme={null}
export type GetBalancesParams = {
    walletAddress: string;
    networks?: Network[];
    networkType?: IndexerNetworkType;
    contractAddresses?: string[];
    includeMetadata?: boolean;
    omitPrices?: boolean;
    tokenIds?: string[];
    contractStatus?: ContractVerificationStatus;
    page?: TokenBalancesPageRequest;
};
```

### `TransactionTransfer`

```ts theme={null}
export type TransactionTransfer = {
    transferType: string;
    contractAddress: string;
    contractType: string;
    from: string;
    to: string;
    tokenIds?: string[];
    amounts: string[];
    logIndex: number;
    amountsUSD?: string[];
    pricesUSD?: string[];
    contractInfo?: TokenContractInfo;
    tokenMetadata?: Record<string, TokenMetadata>;
};
```

### `Transaction`

```ts theme={null}
export type Transaction = {
    txnHash: string;
    blockNumber: number;
    blockHash: string;
    chainId: number;
    metaTxnId?: string;
    transfers: TransactionTransfer[];
    timestamp: string;
};
```

### `TransactionHistoryResult`

```ts theme={null}
export type TransactionHistoryResult = {
    status: number;
    page?: TokenBalancesPage;
    transactions: Transaction[];
};
```

### `GetTransactionHistoryParams`

```ts theme={null}
export type GetTransactionHistoryParams = {
    walletAddress: string;
    networks?: Network[];
    networkType?: IndexerNetworkType;
    contractAddresses?: string[];
    transactionHashes?: string[];
    metaTransactionIds?: string[];
    fromBlock?: number;
    toBlock?: number;
    tokenId?: string;
    includeMetadata?: boolean;
    omitPrices?: boolean;
    metadataOptions?: MetadataOptions;
    page?: TokenBalancesPageRequest;
};
```

## Networks, types, and errors

### `Network`

An opaque SDK-owned registry value. It must come from `Networks`; object
literals are invalid.

```ts theme={null}
export interface Network {
    readonly id: number;
    readonly name: string;
    readonly nativeTokenSymbol: string;
    readonly explorerUrl: string;
    readonly displayName: string;
}
```

### `Networks`

```ts theme={null}
export declare const Networks: Readonly<{
    mainnet: Readonly<{
        readonly id: 1;
        readonly name: "mainnet";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://etherscan.io";
        readonly displayName: "Ethereum";
    }> & Network;
    sepolia: Readonly<{
        readonly id: 11155111;
        readonly name: "sepolia";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://sepolia.etherscan.io";
        readonly displayName: "Sepolia";
    }> & Network;
    polygon: Readonly<{
        readonly id: 137;
        readonly name: "polygon";
        readonly nativeTokenSymbol: "POL";
        readonly explorerUrl: "https://polygonscan.com";
        readonly displayName: "Polygon";
    }> & Network;
    amoy: Readonly<{
        readonly id: 80002;
        readonly name: "amoy";
        readonly nativeTokenSymbol: "POL";
        readonly explorerUrl: "https://amoy.polygonscan.com";
        readonly displayName: "Polygon Amoy";
    }> & Network;
    arbitrum: Readonly<{
        readonly id: 42161;
        readonly name: "arbitrum";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://arbiscan.io";
        readonly displayName: "Arbitrum";
    }> & Network;
    arbitrumSepolia: Readonly<{
        readonly id: 421614;
        readonly name: "arbitrum-sepolia";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://sepolia.arbiscan.io";
        readonly displayName: "Arbitrum Sepolia";
    }> & Network;
    optimism: Readonly<{
        readonly id: 10;
        readonly name: "optimism";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://optimistic.etherscan.io";
        readonly displayName: "Optimism";
    }> & Network;
    optimismSepolia: Readonly<{
        readonly id: 11155420;
        readonly name: "optimism-sepolia";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://sepolia-optimism.etherscan.io";
        readonly displayName: "Optimism Sepolia";
    }> & Network;
    base: Readonly<{
        readonly id: 8453;
        readonly name: "base";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://basescan.org";
        readonly displayName: "Base";
    }> & Network;
    baseSepolia: Readonly<{
        readonly id: 84532;
        readonly name: "base-sepolia";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://sepolia.basescan.org";
        readonly displayName: "Base Sepolia";
    }> & Network;
    bsc: Readonly<{
        readonly id: 56;
        readonly name: "bsc";
        readonly nativeTokenSymbol: "BNB";
        readonly explorerUrl: "https://bscscan.com";
        readonly displayName: "BSC";
    }> & Network;
    bscTestnet: Readonly<{
        readonly id: 97;
        readonly name: "bsc-testnet";
        readonly nativeTokenSymbol: "BNB";
        readonly explorerUrl: "https://testnet.bscscan.com";
        readonly displayName: "BSC Testnet";
    }> & Network;
    arbitrumNova: Readonly<{
        readonly id: 42170;
        readonly name: "arbitrum-nova";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://nova.arbiscan.io";
        readonly displayName: "Arbitrum Nova";
    }> & Network;
    avalanche: Readonly<{
        readonly id: 43114;
        readonly name: "avalanche";
        readonly nativeTokenSymbol: "AVAX";
        readonly explorerUrl: "https://subnets.avax.network/c-chain";
        readonly displayName: "Avalanche";
    }> & Network;
    avalancheTestnet: Readonly<{
        readonly id: 43113;
        readonly name: "avalanche-testnet";
        readonly nativeTokenSymbol: "AVAX";
        readonly explorerUrl: "https://subnets-test.avax.network/c-chain";
        readonly displayName: "Avalanche Testnet";
    }> & Network;
    katana: Readonly<{
        readonly id: 747474;
        readonly name: "katana";
        readonly nativeTokenSymbol: "ETH";
        readonly explorerUrl: "https://katanascan.com";
        readonly displayName: "Katana";
    }> & Network;
}>;
```

### `findNetworkById`

```ts theme={null}
export declare function findNetworkById(chainId: number): Network | undefined;
```

### `findNetworkByName`

```ts theme={null}
export declare function findNetworkByName(name: string): Network | undefined;
```

### `ParseUnitsRoundingMode`

```ts theme={null}
export type ParseUnitsRoundingMode = 'reject' | 'nearest';
```

### `ParseUnitsOptions`

```ts theme={null}
export type ParseUnitsOptions = {
    /**
     * `nearest` matches the native SDK helpers by rounding over-precision to the
     * nearest base unit. Use `reject` to fail on non-zero excess precision.
     */
    roundingMode?: ParseUnitsRoundingMode;
};
```

### `parseUnits`

```ts theme={null}
export declare function parseUnits(value: string, decimals?: number, options?: ParseUnitsOptions): string;
```

### `formatUnits`

```ts theme={null}
export declare function formatUnits(value: string | bigint, decimals?: number): string;
```

### `OMSWalletErrorCode`

```ts theme={null}
export type OMSWalletErrorCode = 'OMS_HTTP_ERROR' | 'OMS_INVALID_RESPONSE' | 'OMS_REQUEST_FAILED' | 'OMS_AUTH_COMMITMENT_CONSUMED' | 'OMS_SESSION_MISSING' | 'OMS_SESSION_EXPIRED' | 'OMS_WALLET_SELECTION_STALE' | 'OMS_WALLET_SELECTION_UNAVAILABLE' | 'OMS_WALLET_SELECTION_IN_FLIGHT' | 'OMS_TRANSACTION_EXECUTION_UNCONFIRMED' | 'OMS_TRANSACTION_STATUS_LOOKUP_FAILED' | 'OMS_VALIDATION_ERROR' | 'OMS_STORAGE_ERROR';
```

### `OMSWalletUpstreamError`

```ts theme={null}
export type OMSWalletUpstreamError = {
    service: 'waas' | 'indexer';
    name?: string;
    code?: string;
    message?: string;
    status?: number;
};
```

### `OMSWalletErrorDetails`

```ts theme={null}
export type OMSWalletErrorDetails = {
    operation?: string;
    status?: number;
    txnId?: string;
    retryable?: boolean;
    upstreamError?: OMSWalletUpstreamError;
};
```

### `OMSWalletError`

```ts theme={null}
export declare class OMSWalletError extends Error {
    readonly code: OMSWalletErrorCode;
    readonly operation?: string;
    readonly status?: number;
    readonly txnId?: string;
    readonly retryable?: boolean;
    readonly upstreamError?: OMSWalletUpstreamError;
    constructor(code: OMSWalletErrorCode, message: string, details?: Partial<OMSWalletErrorDetails>, options?: ErrorOptions);
}
```

### `isOMSWalletError`

```ts theme={null}
export declare function isOMSWalletError(error: unknown): error is OMSWalletError;
```