React Native API reference

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.signOut`

signOut(): Promise<void>;

`OMSWalletClient.getIdToken`

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

`OMSWalletClient.listAccess`

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

`OMSWalletClient.listAccessPages`

listAccessPages(_params?: ListAccessPagesParams): AsyncGenerator<ListAccessResponse, void, void>;

`OMSWalletClient.listAccessPage`

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

`OMSWalletClient.revokeAccess`

revokeAccess(_targetCredentialId: string): Promise<void>;

`OmsRelayOidcProviders`

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

`WalletType`

export type WalletType = 'ethereum';

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

`WalletActivationResult`

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

`CredentialInfo`

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

`PendingWalletSelection`

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

`CompleteAuthResult`

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`

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

`GetIdTokenParams`

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

`AccessPage`

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

`ListAccessResponse`

export type ListAccessResponse = {
    credentials: CredentialInfo[];
    page?: AccessPage;
};

`ListAccessParams`

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

`ListAccessPagesParams`

export type ListAccessPagesParams = {
    pageSize?: number;
};

`ListAccessPageParams`

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

Transactions and signing

`OMSWalletClient.signMessage`

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

`OMSWalletClient.signTypedData`

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

`OMSWalletClient.sendTransaction`

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

`OMSWalletClient.callContract`

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

`OMSWalletClient.getTransactionStatus`

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

`OMSWalletClient.isValidMessageSignature`

isValidMessageSignature(_params: IsValidMessageSignatureParams): 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;
};

`SignTypedDataParams`

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

`IsValidMessageSignatureParams`

export type IsValidMessageSignatureParams = {
    network: Network;
    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;
};

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

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

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

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

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

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

Uh oh!

FilesExpand file tree

API.md

Latest commit

History

API.md

File metadata and controls

React Native API reference

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

OMSWalletClient.getIdToken

OMSWalletClient.listAccess

OMSWalletClient.listAccessPages

OMSWalletClient.listAccessPage

OMSWalletClient.revokeAccess

OmsRelayOidcProviders

WalletType

WalletSelectionBehavior

OMSWalletEmailSessionAuth

OMSWalletOidcSessionAuthFlow

OMSWalletOidcSessionAuth

OMSWalletSessionAuth

OMSWalletSessionState

OMSWalletSessionExpiredEvent

WalletAccount

WalletActivationResult

CredentialInfo

PendingWalletSelection

CompleteAuthResult

StartEmailAuthParams

CompleteEmailAuthParams

SignInWithOidcIdTokenParams

OidcAuthMode

OmsRelayOidcProvider

CustomOidcProviderConfig

OidcProviderConfig

StartOidcRedirectAuthParams

StartOidcRedirectAuthResult

HandleOidcRedirectCallbackParams

OidcRedirectAuthResult

CreateWalletParams

GetIdTokenParams

AccessPage

ListAccessResponse

ListAccessParams

ListAccessPagesParams

ListAccessPageParams

Transactions and signing

OMSWalletClient.signMessage

OMSWalletClient.signTypedData

OMSWalletClient.sendTransaction

OMSWalletClient.callContract

OMSWalletClient.getTransactionStatus

OMSWalletClient.isValidMessageSignature

OMSWalletClient.isValidTypedDataSignature

FeeOptionSelectors

SignMessageParams

SignTypedDataParams

IsValidMessageSignatureParams

IsValidTypedDataSignatureParams

CallContractArg

TransactionMode

TransactionStatus

TransactionStatusResolution

TransactionStatusPollingOptions

SendTransactionResponse

`OMSWallet`

`OMSWalletParams`

`OMSWalletClient.getWalletAddress`

`OMSWalletClient.getSession`

`OMSWalletClient.onSessionExpired`

`OMSWalletClient.startEmailAuth`

`OMSWalletClient.completeEmailAuth`

`OMSWalletClient.signInWithOidcIdToken`

`OMSWalletClient.startOidcRedirectAuth`

`OMSWalletClient.handleOidcRedirectCallback`

`OMSWalletClient.listWallets`

`OMSWalletClient.useWallet`

`OMSWalletClient.createWallet`

`OMSWalletClient.signOut`

`OMSWalletClient.getIdToken`

`OMSWalletClient.listAccess`

`OMSWalletClient.listAccessPages`

`OMSWalletClient.listAccessPage`

`OMSWalletClient.revokeAccess`

`OmsRelayOidcProviders`

`WalletType`

`WalletSelectionBehavior`

`OMSWalletEmailSessionAuth`

`OMSWalletOidcSessionAuthFlow`

`OMSWalletOidcSessionAuth`

`OMSWalletSessionAuth`

`OMSWalletSessionState`

`OMSWalletSessionExpiredEvent`

`WalletAccount`

`WalletActivationResult`

`CredentialInfo`

`PendingWalletSelection`

`CompleteAuthResult`

`StartEmailAuthParams`

`CompleteEmailAuthParams`

`SignInWithOidcIdTokenParams`

`OidcAuthMode`

`OmsRelayOidcProvider`

`CustomOidcProviderConfig`

`OidcProviderConfig`

`StartOidcRedirectAuthParams`

`StartOidcRedirectAuthResult`

`HandleOidcRedirectCallbackParams`

`OidcRedirectAuthResult`

`CreateWalletParams`

`GetIdTokenParams`

`AccessPage`

`ListAccessResponse`

`ListAccessParams`

`ListAccessPagesParams`

`ListAccessPageParams`

`OMSWalletClient.signMessage`

`OMSWalletClient.signTypedData`

`OMSWalletClient.sendTransaction`

`OMSWalletClient.callContract`

`OMSWalletClient.getTransactionStatus`

`OMSWalletClient.isValidMessageSignature`

`OMSWalletClient.isValidTypedDataSignature`

`FeeOptionSelectors`

`SignMessageParams`

`SignTypedDataParams`

`IsValidMessageSignatureParams`

`IsValidTypedDataSignatureParams`

`CallContractArg`

`TransactionMode`

`TransactionStatus`

`TransactionStatusResolution`

`TransactionStatusPollingOptions`

`SendTransactionResponse`

`TransactionStatusResponse`

`FeeToken`

`FeeOption`

`FeeOptionSelection`

`FeeOptionWithBalance`

`FeeOptionSelector`

`SendTransactionParams`

`CallContractParams`

`OMSIndexerClient.getBalances`

`OMSIndexerClient.getTransactionHistory`

`IndexerNetworkType`