React Native API reference - Polygon Developer Docs

OMSWallet

`OMSWallet`

export declare class OMSWallet {
    readonly wallet: OMSWalletClient;
    readonly indexer: OMSIndexerClient;
    constructor(_config: OMSWalletParams);
}

`OMSWalletParams`

export type OMSWalletParams = {
    publishableKey: string;
};

Authentication and sessions

`OMSWalletClient.getWalletAddress`

getWalletAddress(): Promise<string | undefined>;

`OMSWalletClient.getSession`

getSession(): Promise<OMSWalletSessionState>;

`OMSWalletClient.onSessionExpired`

onSessionExpired(_listener: (event: OMSWalletSessionExpiredEvent) => void): EventSubscription;

`OMSWalletClient.startEmailAuth`

startEmailAuth(_params: StartEmailAuthParams): Promise<void>;

`OMSWalletClient.completeEmailAuth`

completeEmailAuth(_params: CompleteEmailAuthParams): Promise<CompleteAuthResult>;

`OMSWalletClient.signInWithOidcIdToken`

signInWithOidcIdToken(_params: SignInWithOidcIdTokenParams): Promise<CompleteAuthResult>;

`OMSWalletClient.startOidcRedirectAuth`

startOidcRedirectAuth(_params: StartOidcRedirectAuthParams): Promise<StartOidcRedirectAuthResult>;

`OMSWalletClient.handleOidcRedirectCallback`

handleOidcRedirectCallback(_params: HandleOidcRedirectCallbackParams): Promise<OidcRedirectAuthResult>;

`OMSWalletClient.listWallets`

listWallets(): Promise<WalletAccount[]>;

`OMSWalletClient.useWallet`

useWallet(_walletId: string): Promise<WalletActivationResult>;

`OMSWalletClient.createWallet`

createWallet(_params?: CreateWalletParams): Promise<WalletActivationResult>;

`OMSWalletClient.importWallet`

importWallet(_params: ImportWalletParams): Promise<WalletActivationResult>;

`OMSWalletClient.getWalletImportRecipientKey`

getWalletImportRecipientKey(_params: {
        cipherSuite: WalletImportCipherSuite;
    }): Promise<WalletImportRecipientKey>;

`OMSWalletClient.importEncryptedWallet`

importEncryptedWallet(_params: ImportEncryptedWalletParams): Promise<WalletActivationResult>;

`OMSWalletClient.signOut`

signOut(): Promise<void>;

`OMSWalletClient.getIdToken`

getIdToken(_params?: GetIdTokenParams): Promise<string>;

`OMSWalletClient.inspectRemoteCredential`

inspectRemoteCredential(_params: {
        credentialId: string;
    }): Promise<RemoteCredentialMetadata>;

`OMSWalletClient.authorizeRemoteAccess`

authorizeRemoteAccess(_params: AuthorizeRemoteAccessParams): Promise<AuthorizedRemoteAccess>;

`OMSWalletClient.listAccess`

listAccess(_params?: ListAccessParams): Promise<AccessGrant[]>;

`OMSWalletClient.listAccessPages`

listAccessPages(_params?: ListAccessParams): AsyncGenerator<AccessGrantPage, void, void>;

`OMSWalletClient.listAccessPage`

listAccessPage(_params?: ListAccessPageParams): Promise<AccessGrantPage>;

`OMSWalletClient.getRemoteAccessSession`

getRemoteAccessSession(_params: {
        sessionId: string;
    }): Promise<RemoteAccessSession>;

`OMSWalletClient.getRemoteAccessSessionUsage`

getRemoteAccessSessionUsage(_params: {
        sessionId: string;
        network: Network;
    }): Promise<SmartSessionGrantUsage[]>;

`OMSWalletClient.revokeAccess`

revokeAccess(_params: RevokeAccessParams): Promise<void>;

`OmsRelayOidcProviders`

export declare const OmsRelayOidcProviders: Readonly<{
    google: OmsRelayOidcProvider;
    apple: OmsRelayOidcProvider;
}>;

`WalletType`

export type WalletType = 'ethereum' | 'solana';

`WalletKeyOrigin`

export type WalletKeyOrigin = 'enclave' | 'imported';

`WalletSelectionBehavior`

export type WalletSelectionBehavior = 'automatic' | 'manual';

`OMSWalletEmailSessionAuth`

export type OMSWalletEmailSessionAuth = {
    type: 'email';
    email: string;
};

`OMSWalletOidcSessionAuthFlow`

export type OMSWalletOidcSessionAuthFlow = 'redirect' | 'id-token';

`OMSWalletOidcSessionAuth`

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

`OMSWalletSessionAuth`

export type OMSWalletSessionAuth = OMSWalletEmailSessionAuth | OMSWalletOidcSessionAuth;

`OMSWalletSessionState`

export type OMSWalletSessionState = {
    walletAddress: string | undefined;
    expiresAt: string | undefined;
    auth: OMSWalletSessionAuth | undefined;
};

`OMSWalletSessionExpiredEvent`

export type OMSWalletSessionExpiredEvent = {
    session: OMSWalletSessionState;
    expiredAt: string;
};

`WalletAccount`

export type WalletAccount = {
    id: string;
    type: WalletType;
    address: string;
    reference?: string;
    keyOrigin: WalletKeyOrigin;
};

`WalletActivationResult`

export type WalletActivationResult = {
    walletAddress: string;
    wallet: WalletAccount;
};

`WalletCredential`

export type WalletCredential = {
    credentialId: string;
    expiresAt: string;
    isCaller: boolean;
};

`PendingWalletSelection`

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

`CompleteAuthResult`

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

`StartEmailAuthParams`

export type StartEmailAuthParams = {
    email: string;
    sessionLifetimeSeconds?: number;
};

`CompleteEmailAuthParams`

export type CompleteEmailAuthParams = {
    code: string;
    walletSelection?: WalletSelectionBehavior;
    walletType?: WalletType;
};

`SignInWithOidcIdTokenParams`

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

`OidcAuthMode`

export type OidcAuthMode = 'auth-code' | 'auth-code-pkce';

`OmsRelayOidcProvider`

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

export type OmsRelayOidcProvider = {
    readonly provider: 'google' | 'apple';
};

`CustomOidcProviderConfig`

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

`OidcProviderConfig`

export type OidcProviderConfig = OmsRelayOidcProvider | CustomOidcProviderConfig;

`StartOidcRedirectAuthParams`

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`

export type StartOidcRedirectAuthResult = {
    authorizationUrl: string;
};

`HandleOidcRedirectCallbackParams`

export type HandleOidcRedirectCallbackParams = {
    callbackUrl: string;
    walletSelection?: WalletSelectionBehavior;
    sessionLifetimeSeconds?: number;
};

`OidcRedirectAuthResult`

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

`CreateWalletParams`

export type CreateWalletParams = {
    walletType?: WalletType;
    reference?: string;
};

`WalletImportCipherSuite`

export type WalletImportCipherSuite = 'x25519-sha256-aes256gcm' | 'x25519-sha256-chacha20poly1305' | 'p256-sha256-aes256gcm' | 'p256-sha256-chacha20poly1305';

`ImportWalletParams`

export type ImportWalletParams = {
    type: 'ethereum';
    privateKey: string | Uint8Array;
    reference?: string;
} | {
    type: 'solana';
    privateKey: string | Uint8Array;
    reference?: string;
};

`WalletImportRecipientKey`

export type WalletImportRecipientKey = {
    keyId: string;
    cipherSuite: WalletImportCipherSuite;
    publicKey: string;
};

`EncryptedWalletImportKeyMaterial`

export type EncryptedWalletImportKeyMaterial = {
    keyId: string;
    cipherSuite: WalletImportCipherSuite;
    encapsulatedKey: string;
    ciphertext: string;
};

`ImportEncryptedWalletParams`

export type ImportEncryptedWalletParams = {
    type: WalletType;
    keyMaterial: EncryptedWalletImportKeyMaterial;
    reference?: string;
};

`GetIdTokenParams`

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

`AccessPage`

export type AccessPage = {
    limit?: number;
    cursor?: string;
};

`RemoteCredentialMetadata`

export type RemoteCredentialMetadata = {
    appUrl: string;
    appName: string;
    appLogoUrl: string;
    custom: Record<string, string>;
};

`SmartSessionGrant`

export type SmartSessionGrant = {
    kind: 'nativeTransfer';
    to: string;
    limit: string;
} | {
    kind: 'erc20Transfer';
    token: string;
    to?: string;
    limit: string;
    cumulative?: boolean;
};

`DirectAccessGrant`

export type DirectAccessGrant = WalletCredential & {
    type: 'direct';
};

`RemoteAccessGrant`

export type RemoteAccessGrant = WalletCredential & {
    type: 'remote';
    sessionId: string;
    metadata: RemoteCredentialMetadata;
    grants: SmartSessionGrant[];
};

`AccessGrant`

export type AccessGrant = DirectAccessGrant | RemoteAccessGrant;

`AccessGrantType`

export type AccessGrantType = AccessGrant['type'];

`AccessGrantPage`

export type AccessGrantPage = {
    grants: AccessGrant[];
    page?: AccessPage;
};

`AuthorizeRemoteAccessParams`

export type AuthorizeRemoteAccessParams = {
    credentialId: string;
    network: Network;
    grants: SmartSessionGrant[];
    expiresAt: string;
    sessionId?: string;
};

`AuthorizedRemoteAccess`

export type AuthorizedRemoteAccess = {
    walletId: string;
    sessionId: string;
    expiresAt: string;
};

`RemoteAccessSession`

export type RemoteAccessSession = {
    sessionId: string;
    walletId: string;
    signerAddress: string;
    grants: SmartSessionGrant[];
    chainId: number;
    expiresAt: string;
};

`SmartSessionGrantUsage`

export type SmartSessionGrantUsage = {
    grant: SmartSessionGrant;
    used?: string;
};

`RevokeAccessParams`

export type RevokeAccessParams = {
    credentialId: string;
    sessionId?: string;
};

`ListAccessParams`

export type ListAccessParams = {
    pageSize?: number;
    type?: AccessGrantType;
};

`ListAccessPageParams`

export type ListAccessPageParams = {
    pageSize?: number;
    cursor?: string;
    type?: AccessGrantType;
};

Transactions and signing

`OMSWalletClient.signMessage`

signMessage(_params: SignMessageParams): Promise<string>;

`OMSWalletClient.signSolanaMessage`

signSolanaMessage(_params: SignSolanaMessageParams): Promise<string>;

`OMSWalletClient.signTypedData`

signTypedData(_params: SignTypedDataParams): Promise<string>;

`OMSWalletClient.sendTransaction`

sendTransaction(_params: SendTransactionParams): Promise<SendTransactionResponse>;

`OMSWalletClient.sendSolanaTransfer`

sendSolanaTransfer(_params: SendSolanaTransferParams): Promise<SendTransactionResponse>;

`OMSWalletClient.callContract`

callContract(_params: CallContractParams): Promise<SendTransactionResponse>;

`OMSWalletClient.getTransactionStatus`

getTransactionStatus(_txnId: string): Promise<TransactionStatusResponse>;

`OMSWalletClient.isValidMessageSignature`

isValidMessageSignature(_params: IsValidMessageSignatureParams): Promise<boolean>;

`OMSWalletClient.isValidSolanaMessageSignature`

isValidSolanaMessageSignature(_params: IsValidSolanaMessageSignatureParams): Promise<boolean>;

`OMSWalletClient.isValidTypedDataSignature`

isValidTypedDataSignature(_params: IsValidTypedDataSignatureParams): Promise<boolean>;

`FeeOptionSelectors`

export declare const FeeOptionSelectors: Readonly<{
    firstAvailable: FeeOptionSelector;
}>;

`SignMessageParams`

export type SignMessageParams = {
    network: Network;
    message: string;
};

`SignSolanaMessageParams`

export type SignSolanaMessageParams = {
    message: string;
};

`SignTypedDataParams`

export type SignTypedDataParams = {
    network: Network;
    typedData: unknown;
};

`IsValidMessageSignatureParams`

export type IsValidMessageSignatureParams = {
    network: Network;
    message: string;
    signature: string;
};

`IsValidSolanaMessageSignatureParams`

export type IsValidSolanaMessageSignatureParams = {
    message: string;
    signature: string;
};

`IsValidTypedDataSignatureParams`

export type IsValidTypedDataSignatureParams = {
    network: Network;
    typedData: unknown;
    signature: string;
};

`CallContractArg`

export type CallContractArg = {
    type: string;
    value: unknown;
};

`TransactionMode`

export type TransactionMode = 'native' | 'relayer';

`TransactionStatus`

export type TransactionStatus = 'quoted' | 'pending' | 'executed' | 'failed' | 'unknown';

`TransactionStatusResolution`

export type TransactionStatusResolution = 'not-requested' | 'resolved' | 'timed-out';

`TransactionStatusPollingOptions`

export type TransactionStatusPollingOptions = {
    timeoutMs?: number;
    intervalMs?: number;
    fastIntervalMs?: number;
    fastPollCount?: number;
};

`SendTransactionResponse`

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

`TransactionStatusResponse`

export type TransactionStatusResponse = {
    status: TransactionStatus;
    txnHash?: string;
};

`FeeToken`

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

`FeeOption`

export type FeeOption = {
    token: FeeToken;
    value: string;
    displayValue: string;
};

`FeeOptionSelection`

export type FeeOptionSelection = {
    token: string;
    index?: number;
};

`FeeOptionWithBalance`

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

`FeeOptionSelector`

export type FeeOptionSelector = (feeOptions: FeeOptionWithBalance[]) => FeeOptionSelection | undefined | Promise<FeeOptionSelection | undefined>;

`SendTransactionParams`

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

`SendSolanaTransferParams`

export type SendSolanaTransferParams = {
    network: SolanaNetwork;
    asset: string;
    to: string;
    amount: string;
    mode?: TransactionMode;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};

`CallContractParams`

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

Indexer

`OMSIndexerClient.getBalances`

getBalances(_params: GetBalancesParams): Promise<BalancesResult>;

`OMSIndexerClient.getTransactionHistory`

getTransactionHistory(_params: GetTransactionHistoryParams): Promise<TransactionHistoryResult>;

`OMSIndexerClient.getSolanaBalances`

getSolanaBalances(_params: GetSolanaBalancesParams): Promise<SolanaBalancesResult>;

`IndexerNetworkType`

export type IndexerNetworkType = 'MAINNETS' | 'TESTNETS' | 'ALL';

`ContractVerificationStatus`

export type ContractVerificationStatus = 'VERIFIED' | 'UNVERIFIED' | 'ALL';

`MetadataOptions`

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

`TokenBalancesPageRequest`

export type TokenBalancesPageRequest = {
    page?: number;
    pageSize?: number;
};

`TokenBalancesPage`

export type TokenBalancesPage = {
    page: number;
    pageSize: number;
    more: boolean;
};

`TokenContractInfo`

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`

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`

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`

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`

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`

export type TokenBalance = NativeTokenBalance | ContractTokenBalance;

`BalancesResult`

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

`GetBalancesParams`

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

`SolanaVerificationStatus`

export type SolanaVerificationStatus = 'verified' | 'unverified' | 'unknown';

`SolanaVerificationSource`

export type SolanaVerificationSource = 'jupiter' | 'solflare-utl' | 'none';

`SolanaNativeBalance`

export type SolanaNativeBalance = {
    network: SolanaNetwork;
    accountAddress: string;
    name: string;
    symbol: string;
    decimals: number;
    balance: string;
    formattedBalance: string;
    imageUrl?: string;
    metadataUri?: string;
    verificationStatus: SolanaVerificationStatus;
    verificationSource: SolanaVerificationSource;
    priceUSD?: string;
    balanceUSD?: string;
} & {
    assetType: 'native';
    tokenProgram?: undefined;
    mintAddress?: undefined;
};

`SolanaFungibleTokenBalance`

export type SolanaFungibleTokenBalance = {
    network: SolanaNetwork;
    accountAddress: string;
    name: string;
    symbol: string;
    decimals: number;
    balance: string;
    formattedBalance: string;
    imageUrl?: string;
    metadataUri?: string;
    verificationStatus: SolanaVerificationStatus;
    verificationSource: SolanaVerificationSource;
    priceUSD?: string;
    balanceUSD?: string;
} & {
    assetType: 'fungible-token';
    tokenProgram: 'spl-token' | 'token-2022';
    mintAddress: string;
};

`SolanaBalance`

export type SolanaBalance = SolanaNativeBalance | SolanaFungibleTokenBalance;

`SolanaNetworkError`

export type SolanaNetworkError = {
    network: SolanaNetwork;
    reason: string;
};

`GetSolanaBalancesParams`

export type GetSolanaBalancesParams = {
    walletAddress: string;
    networks?: SolanaNetwork[];
    includeMetadata?: boolean;
    omitNativeBalances?: boolean;
    mintAddresses?: string[];
    excludedMintAddresses?: string[];
};

`SolanaBalancesResult`

export type SolanaBalancesResult = {
    status: number;
    balances: SolanaBalance[];
    errors: SolanaNetworkError[];
};

`TransactionTransfer`

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`

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

`TransactionHistoryResult`

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

`GetTransactionHistoryParams`

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.

export interface Network {
    readonly id: number;
    readonly name: string;
    readonly nativeTokenSymbol: string;
    readonly explorerUrl: string;
    readonly displayName: string;
}

`Networks`

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;
}>;

`SolanaNetwork`

export type SolanaNetwork = (typeof SolanaNetworks)[keyof typeof SolanaNetworks];

`SolanaNetworks`

export declare const SolanaNetworks: Readonly<{
    readonly devnet: "solana:devnet";
    readonly mainnet: "solana:mainnet";
}>;

`findNetworkById`

export declare function findNetworkById(chainId: number): Network | undefined;

`findNetworkByName`

export declare function findNetworkByName(name: string): Network | undefined;

`ParseUnitsRoundingMode`

export type ParseUnitsRoundingMode = 'reject' | 'nearest';

`ParseUnitsOptions`

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`

export declare function parseUnits(value: string, decimals?: number, options?: ParseUnitsOptions): string;

`formatUnits`

export declare function formatUnits(value: string | bigint, decimals?: number): string;

`OMSWalletErrorCode`

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' | 'OMS_ATTESTATION_VERIFICATION_FAILED';

`OMSWalletUpstreamError`

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

`OMSWalletErrorDetails`

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

`OMSWalletError`

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`

export declare function isOMSWalletError(error: unknown): error is OMSWalletError;

​OMSWallet

​OMSWallet

​OMSWalletParams

​Authentication and sessions

​OMSWalletClient.getWalletAddress

​OMSWalletClient.getSession

​OMSWalletClient.onSessionExpired

​OMSWalletClient.startEmailAuth

​OMSWalletClient.completeEmailAuth

​OMSWalletClient.signInWithOidcIdToken

​OMSWalletClient.startOidcRedirectAuth

​OMSWalletClient.handleOidcRedirectCallback

​OMSWalletClient.listWallets

​OMSWalletClient.useWallet

​OMSWalletClient.createWallet

​OMSWalletClient.importWallet

​OMSWalletClient.getWalletImportRecipientKey

​OMSWalletClient.importEncryptedWallet

​OMSWalletClient.signOut

​OMSWalletClient.getIdToken

​OMSWalletClient.inspectRemoteCredential

​OMSWalletClient.authorizeRemoteAccess

​OMSWalletClient.listAccess

​OMSWalletClient.listAccessPages

​OMSWalletClient.listAccessPage

​OMSWalletClient.getRemoteAccessSession

​OMSWalletClient.getRemoteAccessSessionUsage

​OMSWalletClient.revokeAccess

​OmsRelayOidcProviders

​WalletType

​WalletKeyOrigin

​WalletSelectionBehavior

​OMSWalletEmailSessionAuth

​OMSWalletOidcSessionAuthFlow

​OMSWalletOidcSessionAuth

​OMSWalletSessionAuth

​OMSWalletSessionState

​OMSWalletSessionExpiredEvent

​WalletAccount

​WalletActivationResult

​WalletCredential

​PendingWalletSelection

​CompleteAuthResult

​StartEmailAuthParams

​CompleteEmailAuthParams

​SignInWithOidcIdTokenParams

​OidcAuthMode

​OmsRelayOidcProvider

​CustomOidcProviderConfig

​OidcProviderConfig

​StartOidcRedirectAuthParams

​StartOidcRedirectAuthResult

​HandleOidcRedirectCallbackParams

​OidcRedirectAuthResult

​CreateWalletParams

​WalletImportCipherSuite

​ImportWalletParams

​WalletImportRecipientKey

​EncryptedWalletImportKeyMaterial

​ImportEncryptedWalletParams

​GetIdTokenParams

​AccessPage

​RemoteCredentialMetadata

​SmartSessionGrant

​DirectAccessGrant

​RemoteAccessGrant

​AccessGrant

​AccessGrantType

​AccessGrantPage

​AuthorizeRemoteAccessParams

​AuthorizedRemoteAccess

​RemoteAccessSession

​SmartSessionGrantUsage

​RevokeAccessParams

​ListAccessParams

​ListAccessPageParams

​Transactions and signing

​OMSWalletClient.signMessage

​OMSWalletClient.signSolanaMessage

​OMSWalletClient.signTypedData