TypeScript API reference - Polygon Developer Docs

OMSWallet

`OMSWallet`

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

`OMSWalletParams`

export interface OMSWalletParams {
    publishableKey: string;
    storage?: StorageManager;
    redirectAuthStorage?: StorageManager;
    credentialSigner?: CredentialSigner;
}

Authentication and sessions

`OMSWalletClient.walletAddress`

readonly walletAddress: Address | undefined;

`OMSWalletClient.session`

readonly session: OMSWalletSessionState;

`OMSWalletClient.onSessionExpired`

onSessionExpired(listener: OMSWalletSessionExpiredListener): () => void;

`OMSWalletClient.startEmailAuth`

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

`OMSWalletClient.completeEmailAuth`

completeEmailAuth(params: Omit<CompleteEmailAuthParams, "walletSelection"> & {
    walletSelection: "manual";
}): Promise<PendingWalletSelection>;
completeEmailAuth(params: Omit<CompleteEmailAuthParams, "walletSelection"> & {
    walletSelection?: "automatic";
}): Promise<CompleteEmailAuthResult>;
completeEmailAuth(params: CompleteEmailAuthParams): Promise<CompleteEmailAuthResult | PendingWalletSelection>;

`OMSWalletClient.signInWithOidcIdToken`

signInWithOidcIdToken(params: Omit<SignInWithOidcIdTokenParams, "walletSelection"> & {
    walletSelection: "manual";
}): Promise<PendingWalletSelection>;
signInWithOidcIdToken(params: Omit<SignInWithOidcIdTokenParams, "walletSelection"> & {
    walletSelection?: "automatic";
}): Promise<CompleteOidcIdTokenAuthResult>;
signInWithOidcIdToken(params: SignInWithOidcIdTokenParams): Promise<CompleteOidcIdTokenAuthResult | PendingWalletSelection>;

`OMSWalletClient.startOidcRedirectAuth`

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

`OMSWalletClient.completeOidcRedirectAuth`

completeOidcRedirectAuth(): Promise<CompleteOidcRedirectAuthResult | PendingWalletSelection | void>;
completeOidcRedirectAuth(params: Omit<CompleteOidcRedirectAuthParams, "walletSelection"> & {
    walletSelection: "manual";
}): Promise<PendingWalletSelection | void>;
completeOidcRedirectAuth(params: Omit<CompleteOidcRedirectAuthParams, "walletSelection"> & {
    walletSelection?: "automatic";
}): Promise<CompleteOidcRedirectAuthResult | void>;
completeOidcRedirectAuth(params: CompleteOidcRedirectAuthParams): Promise<CompleteOidcRedirectAuthResult | PendingWalletSelection | void>;

`OMSWalletClient.signInWithOidcRedirect`

signInWithOidcRedirect(params: SignInWithOidcRedirectParams): Promise<void>;

`OMSWalletClient.signOut`

signOut(): Promise<void>;

`OMSWalletClient.listWallets`

listWallets(): Promise<Array<WalletAccount>>;

`OMSWalletClient.useWallet`

useWallet(params: {
    walletId: string;
}): Promise<WalletActivationResult>;

`OMSWalletClient.createWallet`

createWallet(params?: {
    type?: WalletType;
    reference?: string;
}): Promise<WalletActivationResult>;

`OMSWalletClient.getIdToken`

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

`OMSWalletClient.listAccess`

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

`OMSWalletClient.listAccessPages`

listAccessPages(params?: ListAccessParams): AsyncIterable<AccessGrantPage>;

`OMSWalletClient.revokeAccess`

revokeAccess(params: {
    targetCredentialId: string;
}): Promise<void>;

`StartEmailAuthParams`

export interface StartEmailAuthParams {
    email: string;
    sessionLifetimeSeconds?: number;
}

`CompleteEmailAuthParams`

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

`CompleteEmailAuthResult`

export interface CompleteEmailAuthResult {
    readonly walletAddress: Address;
    readonly wallet: WalletAccount;
    readonly wallets: ReadonlyArray<WalletAccount>;
    readonly credential: Readonly<WalletCredential>;
}

`SignInWithOidcIdTokenParams`

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

`CompleteOidcIdTokenAuthResult`

export interface CompleteOidcIdTokenAuthResult {
    readonly walletAddress: Address;
    readonly wallet: WalletAccount;
    readonly wallets: ReadonlyArray<WalletAccount>;
    readonly credential: Readonly<WalletCredential>;
}

`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 interface StartOidcRedirectAuthResult {
    authorizationUrl: string;
}

`CompleteOidcRedirectAuthParams`

export interface CompleteOidcRedirectAuthParams {
    callbackUrl?: string;
    cleanUrl?: boolean;
    replaceUrl?: (url: string) => void;
    walletSelection?: WalletSelectionBehavior;
    sessionLifetimeSeconds?: number;
}

`CompleteOidcRedirectAuthResult`

export interface CompleteOidcRedirectAuthResult {
    readonly walletAddress: Address;
    readonly wallet: WalletAccount;
    readonly wallets: ReadonlyArray<WalletAccount>;
    readonly credential: Readonly<WalletCredential>;
}

`SignInWithOidcRedirectParams`

export type SignInWithOidcRedirectParams = {
    walletType?: WalletType;
    walletSelection?: WalletSelectionBehavior;
    sessionLifetimeSeconds?: number;
    loginHint?: string;
} & {
    currentUrl?: string;
    assignUrl?: (url: string) => void;
} & ({
    provider: OmsRelayOidcProvider;
    omsRelayReturnUri?: string;
    authorizeParams?: never;
} | {
    provider: CustomOidcProviderConfig;
    omsRelayReturnUri?: never;
    authorizeParams?: Record<string, string>;
});

`OmsRelayOidcProviders`

Fixed OMS relay providers. Their OAuth configuration is not caller-editable.

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

`OmsRelayOidcProvider`

An opaque SDK-owned OMS relay provider value. Obtain values from OmsRelayOidcProviders; object literals are invalid.

export interface OmsRelayOidcProvider<Provider extends "google" | "apple" = "google" | "apple"> {
    readonly provider: Provider;
}

`CustomOidcProviderConfig`

A caller-owned OIDC provider configuration.

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

`AuthMode`

export declare const AuthMode: Readonly<{
    readonly OTP: "otp";
    readonly IDToken: "id-token";
    readonly AuthCode: "auth-code";
    readonly AuthCodePKCE: "auth-code-pkce";
}>;
export type AuthMode = (typeof AuthMode)[keyof typeof AuthMode];

`OidcAuthMode`

export type OidcAuthMode = typeof AuthMode.AuthCode | typeof AuthMode.AuthCodePKCE;

`WalletType`

export declare const WalletType: Readonly<{
    readonly Ethereum: "ethereum";
}>;
export type WalletType = (typeof WalletType)[keyof typeof WalletType];

`WalletSelectionBehavior`

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

`WalletAccount`

export interface WalletAccount {
    readonly id: string;
    readonly type: WalletType;
    readonly address: Address;
    readonly reference?: string;
}

`WalletActivationResult`

export interface WalletActivationResult {
    readonly walletAddress: Address;
    readonly wallet: WalletAccount;
}

`PendingWalletSelection`

export interface PendingWalletSelection {
    readonly walletType: WalletType;
    readonly wallets: ReadonlyArray<WalletAccount>;
    readonly credential: Readonly<WalletCredential>;
    selectWallet(params: {
        walletId: string;
    }): Promise<WalletActivationResult>;
    createAndSelectWallet(params?: {
        reference?: string;
    }): Promise<WalletActivationResult>;
}

`OMSWalletEmailSessionAuth`

export interface OMSWalletEmailSessionAuth {
    readonly type: "email";
    readonly email: string;
}

`OMSWalletOidcSessionAuthFlow`

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

`OMSWalletOidcSessionAuth`

export interface OMSWalletOidcSessionAuth {
    readonly type: "oidc";
    readonly flow: OMSWalletOidcSessionAuthFlow;
    readonly issuer: string;
    readonly provider: string | undefined;
    readonly providerLabel: string | undefined;
    readonly email: string | undefined;
}

`OMSWalletSessionAuth`

export type OMSWalletSessionAuth = OMSWalletEmailSessionAuth | OMSWalletOidcSessionAuth;

`OMSWalletSessionState`

export interface OMSWalletSessionState {
    readonly walletAddress: Address | undefined;
    readonly expiresAt: string | undefined;
    readonly auth: OMSWalletSessionAuth | undefined;
}

`OMSWalletSessionExpiredEvent`

export interface OMSWalletSessionExpiredEvent {
    readonly session: OMSWalletSessionState;
    readonly expiredAt: string;
}

`OMSWalletSessionExpiredListener`

export type OMSWalletSessionExpiredListener = (event: OMSWalletSessionExpiredEvent) => void | Promise<void>;

`GetIdTokenParams`

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

`WalletCredential`

export interface WalletCredential {
    credentialId: string;
    expiresAt: string;
    isCaller: boolean;
}

`AccessGrant`

export type AccessGrant = WalletCredential;

`ListAccessParams`

export interface ListAccessParams {
    pageSize?: number;
}

`AccessGrantPage`

export interface AccessGrantPage {
    grants: AccessGrant[];
}

`StorageManager`

export interface StorageManager {
    get(key: string): string | null;
    set(key: string, value: string): void;
    delete(key: string): void;
}

`LocalStorageManager`

Browser implementation backed by localStorage. For Node.js or custom runtimes, supply your own StorageManager to OMSWallet.

export declare class LocalStorageManager implements StorageManager {
    static isAvailable(): boolean;
    get(key: string): string | null;
    set(key: string, value: string): void;
    delete(key: string): void;
}

`SessionStorageManager`

export declare class SessionStorageManager implements StorageManager {
    static isAvailable(): boolean;
    get(key: string): string | null;
    set(key: string, value: string): void;
    delete(key: string): void;
}

`MemoryStorageManager`

export declare class MemoryStorageManager implements StorageManager {
    get(key: string): string | null;
    set(key: string, value: string): void;
    delete(key: string): void;
}

`createDefaultStorage`

export declare function createDefaultStorage(): StorageManager;

`CredentialSigningAlgorithm`

export type CredentialSigningAlgorithm = "ecdsa-p256-sha256" | "ecdsa-p256k-eip191";

`CredentialSigner`

export interface CredentialSigner {
    readonly signingAlgorithm: CredentialSigningAlgorithm;
    credentialId(): Promise<string>;
    nextNonce(): Promise<string>;
    sign(preimage: string): Promise<string>;
    hasCredential?(): Promise<boolean>;
    clear?(): Promise<void>;
}

`WebCryptoP256CredentialSigner`

export declare class WebCryptoP256CredentialSigner implements CredentialSigner {
    readonly signingAlgorithm: "ecdsa-p256-sha256";
    constructor(id?: string);
    credentialId(): Promise<string>;
    nextNonce(): Promise<string>;
    sign(preimage: string): Promise<string>;
    hasCredential(): Promise<boolean>;
    clear(): Promise<void>;
}

`EthereumPrivateKeyCredentialSigner`

export declare class EthereumPrivateKeyCredentialSigner implements CredentialSigner {
    readonly signingAlgorithm: "ecdsa-p256k-eip191";
    constructor(privateKey: Uint8Array);
    credentialId(): Promise<string>;
    nextNonce(): Promise<string>;
    sign(preimage: string): Promise<string>;
}

Transactions and signing

`OMSWalletClient.signMessage`

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

`OMSWalletClient.signTypedData`

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

`OMSWalletClient.isValidMessageSignature`

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

`OMSWalletClient.isValidTypedDataSignature`

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

`OMSWalletClient.sendTransaction`

sendTransaction(params: SendNativeTransactionParams): Promise<SendTransactionResponse>;
sendTransaction(params: SendDataTransactionParams): Promise<SendTransactionResponse>;
sendTransaction<const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi> | undefined = ContractFunctionName<abi>>(params: SendContractTransactionParams<abi, functionName>): Promise<SendTransactionResponse>;
sendTransaction(params: SendTransactionParams): Promise<SendTransactionResponse>;

`OMSWalletClient.callContract`

callContract(params: {
    network: Network;
    contractAddress: Address;
    method: string;
    args?: Array<AbiArg>;
    mode?: TransactionMode;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
}): Promise<SendTransactionResponse>;

`OMSWalletClient.getTransactionStatus`

getTransactionStatus(params: {
    txnId: string;
}): Promise<TransactionStatusResponse>;

`SignMessageParams`

export interface SignMessageParams {
    network: Network;
    message: string;
}

`SignTypedDataParams`

export interface SignTypedDataParams {
    network: Network;
    typedData: unknown;
}

`IsValidMessageSignatureParams`

export interface IsValidMessageSignatureParams {
    network?: Network;
    walletAddress?: Address;
    walletId?: string;
    message: string;
    signature: string;
}

`IsValidTypedDataSignatureParams`

export interface IsValidTypedDataSignatureParams {
    network?: Network;
    walletAddress?: Address;
    walletId?: string;
    typedData: unknown;
    signature: string;
}

`AbiArg`

export interface AbiArg {
    type: string;
    value: unknown;
}

`SendTransactionBase`

export type SendTransactionBase = {
    network: Network;
    to: Address;
    value?: bigint;
    mode?: TransactionMode;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};

`SendNativeTransactionParams`

export type SendNativeTransactionParams = SendTransactionBase & {
    value: bigint;
    data?: never;
    abi?: never;
};

`SendDataTransactionParams`

export type SendDataTransactionParams = SendTransactionBase & {
    data: Hex;
    abi?: never;
};

`SendContractTransactionParams`

export type SendContractTransactionParams<abi extends Abi | readonly unknown[] = Abi, functionName extends ContractFunctionName<abi> | undefined = ContractFunctionName<abi>> = SendTransactionBase & EncodeFunctionDataParameters<abi, functionName> & {
    data?: never;
};

`SendTransactionParams`

export type SendTransactionParams = SendNativeTransactionParams | SendDataTransactionParams | SendContractTransactionParams;

`SendTransactionResponse`

export type SendTransactionResponse = {
    txnId: string;
    status: TransactionStatus;
    txnHash?: string;
    statusResolution: "not-requested" | "resolved" | "timed-out";
};

`TransactionMode`

export declare const TransactionMode: Readonly<{
    readonly Native: "native";
    readonly Relayer: "relayer";
}>;
export type TransactionMode = (typeof TransactionMode)[keyof typeof TransactionMode];

`TransactionStatus`

export declare const TransactionStatus: Readonly<{
    readonly Quoted: "quoted";
    readonly Pending: "pending";
    readonly Executed: "executed";
    readonly Failed: "failed";
    readonly Unknown: "unknown";
}>;
export type TransactionStatus = (typeof TransactionStatus)[keyof typeof TransactionStatus];

`TransactionStatusResponse`

export interface TransactionStatusResponse {
    status: TransactionStatus;
    txnHash?: string;
}

`TransactionStatusPollingOptions`

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

`FeeOption`

export interface FeeOption {
    token: {
        network: string;
        name: string;
        symbol: string;
        type: string;
        decimals?: number;
        logoURL?: string;
        contractAddress?: string;
        tokenID?: string;
    };
    value: string;
    displayValue: string;
}

`FeeOptionSelection`

export interface FeeOptionSelection {
    token: string;
}

`FeeOptionWithBalance`

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

`FeeOptionSelector`

export interface FeeOptionSelector {
    (feeOptions: FeeOptionWithBalance[]): FeeOptionSelection | undefined | Promise<FeeOptionSelection | undefined>;
}
export declare namespace FeeOptionSelector {
    const firstAvailable: FeeOptionSelector;
}

Indexer

`OMSWalletIndexerClient`

export interface OMSWalletIndexerClient {
    getBalances(params: GetBalancesParams): Promise<BalancesResult>;
    getTransactionHistory(params: GetTransactionHistoryParams): Promise<TransactionHistoryResult>;
}

`GetBalancesParams`

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

`BalancesResult`

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

`GetTransactionHistoryParams`

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

`TransactionHistoryResult`

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

`IndexerNetworkType`

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

`ContractVerificationStatus`

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

`MetadataOptions`

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

`SortBy`

export interface SortBy {
    column: string;
    order: "DESC" | "ASC";
}

`TokenBalancesPageRequest`

export interface TokenBalancesPageRequest {
    page?: number;
    column?: string;
    before?: unknown;
    after?: unknown;
    sort?: SortBy[];
    pageSize?: number;
}

`TokenBalancesPage`

export interface TokenBalancesPage {
    page: number;
    column?: string;
    before?: unknown;
    after?: unknown;
    sort?: SortBy[];
    pageSize: number;
    more: boolean;
}

`TokenBalance`

export type TokenBalance = NativeTokenBalance | ContractTokenBalance;

`NativeTokenBalance`

export interface NativeTokenBalance {
    accountAddress: string;
    balance: string;
    chainId: number;
    balanceUSD?: string;
    priceUSD?: string;
    priceUpdatedAt?: string;
    contractType: "NATIVE";
    name: string;
    symbol: string;
    contractAddress?: undefined;
    tokenId?: undefined;
}

`ContractTokenBalance`

export interface ContractTokenBalance {
    contractType: string;
    accountAddress: string;
    balance: string;
    chainId: number;
    balanceUSD?: string;
    priceUSD?: string;
    priceUpdatedAt?: string;
    contractAddress: string;
    tokenId: string;
    blockHash: string;
    blockNumber: number;
    uniqueCollectibles?: string;
    isSummary?: boolean;
    contractInfo?: TokenContractInfo;
    tokenMetadata?: TokenMetadata;
}

`TokenContractInfo`

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

`TokenMetadata`

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

`TokenMetadataAsset`

export interface TokenMetadataAsset {
    id?: number;
    collectionId?: number;
    tokenId?: string;
    url?: string;
    metadataField?: string;
    name?: string;
    filesize?: number;
    mimeType?: string;
    width?: number;
    height?: number;
    updatedAt?: string;
}

`Transaction`

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

`TransactionTransfer`

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

Networks, types, and errors

`Network`

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;

`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 interface OMSWalletUpstreamError {
    service: "waas" | "indexer";
    name?: string;
    code?: number | string;
    message?: string;
    status?: number;
}

`OMSWalletError`

export declare abstract class OMSWalletError extends Error {
    readonly code: OMSWalletErrorCode;
    readonly operation?: string;
    readonly status?: number;
    readonly txnId?: string;
    readonly retryable?: boolean;
    readonly upstreamError?: OMSWalletUpstreamError;
    protected constructor(params: {
        code: OMSWalletErrorCode;
        message: string;
        operation?: string;
        status?: number;
        txnId?: string;
        retryable?: boolean;
        upstreamError?: OMSWalletUpstreamError;
        cause?: unknown;
    });
}

`OMSWalletRequestError`

export declare class OMSWalletRequestError extends OMSWalletError {
    constructor(params: Omit<{
        code: "OMS_HTTP_ERROR" | "OMS_REQUEST_FAILED" | "OMS_AUTH_COMMITMENT_CONSUMED";
        message: string;
        operation?: string;
        status?: number;
        txnId?: string;
        retryable?: boolean;
        upstreamError?: OMSWalletUpstreamError;
        cause?: unknown;
    }, "code"> & {
        code?: "OMS_HTTP_ERROR" | "OMS_REQUEST_FAILED" | "OMS_AUTH_COMMITMENT_CONSUMED";
    });
}

`OMSWalletResponseError`

export declare class OMSWalletResponseError extends OMSWalletError {
    constructor(params: Omit<{
        code: "OMS_INVALID_RESPONSE";
        message: string;
        operation?: string;
        status?: number;
        txnId?: string;
        retryable?: boolean;
        upstreamError?: OMSWalletUpstreamError;
        cause?: unknown;
    }, "code"> & {
        code?: "OMS_INVALID_RESPONSE";
    });
}

`OMSWalletSessionError`

export declare class OMSWalletSessionError extends OMSWalletError {
    constructor(params: Omit<{
        code: "OMS_SESSION_MISSING" | "OMS_SESSION_EXPIRED";
        message: string;
        operation?: string;
        status?: number;
        txnId?: string;
        retryable?: boolean;
        upstreamError?: OMSWalletUpstreamError;
        cause?: unknown;
    }, "code"> & {
        code?: "OMS_SESSION_MISSING" | "OMS_SESSION_EXPIRED";
    });
}

`OMSWalletTransactionError`

export declare class OMSWalletTransactionError extends OMSWalletError {
    constructor(params: Omit<{
        code: "OMS_TRANSACTION_EXECUTION_UNCONFIRMED" | "OMS_TRANSACTION_STATUS_LOOKUP_FAILED";
        message: string;
        operation?: string;
        status?: number;
        txnId?: string;
        retryable?: boolean;
        upstreamError?: OMSWalletUpstreamError;
        cause?: unknown;
    }, "code"> & {
        code?: "OMS_TRANSACTION_EXECUTION_UNCONFIRMED" | "OMS_TRANSACTION_STATUS_LOOKUP_FAILED";
    });
}

`OMSWalletSelectionError`

export declare class OMSWalletSelectionError extends OMSWalletError {
    constructor(params: {
        code: "OMS_WALLET_SELECTION_STALE" | "OMS_WALLET_SELECTION_UNAVAILABLE" | "OMS_WALLET_SELECTION_IN_FLIGHT";
        message: string;
        operation?: string;
        status?: number;
        txnId?: string;
        retryable?: boolean;
        upstreamError?: OMSWalletUpstreamError;
        cause?: unknown;
    });
}

`OMSWalletValidationError`

export declare class OMSWalletValidationError extends OMSWalletError {
    constructor(params: Omit<{
        code: "OMS_VALIDATION_ERROR";
        message: string;
        operation?: string;
        status?: number;
        txnId?: string;
        retryable?: boolean;
        upstreamError?: OMSWalletUpstreamError;
        cause?: unknown;
    }, "code"> & {
        code?: "OMS_VALIDATION_ERROR";
    });
}

`OMSWalletStorageError`

export declare class OMSWalletStorageError extends OMSWalletError {
    constructor(params: Omit<{
        code: "OMS_STORAGE_ERROR";
        message: string;
        operation?: string;
        status?: number;
        txnId?: string;
        retryable?: boolean;
        upstreamError?: OMSWalletUpstreamError;
        cause?: unknown;
    }, "code"> & {
        code?: "OMS_STORAGE_ERROR";
    });
}

`isOMSWalletError`

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

TypeScript networks

Use the TypeScript SDK with wagmi

⌘I

​OMSWallet

​OMSWallet

​OMSWalletParams

​Authentication and sessions

​OMSWalletClient.walletAddress

​OMSWalletClient.session

​OMSWalletClient.onSessionExpired

​OMSWalletClient.startEmailAuth

​OMSWalletClient.completeEmailAuth

​OMSWalletClient.signInWithOidcIdToken

​OMSWalletClient.startOidcRedirectAuth

​OMSWalletClient.completeOidcRedirectAuth

​OMSWalletClient.signInWithOidcRedirect

​OMSWalletClient.signOut

​OMSWalletClient.listWallets

​OMSWalletClient.useWallet

​OMSWalletClient.createWallet

​OMSWalletClient.getIdToken

​OMSWalletClient.listAccess

​OMSWalletClient.listAccessPages

​OMSWalletClient.revokeAccess

​StartEmailAuthParams

​CompleteEmailAuthParams

​CompleteEmailAuthResult

​SignInWithOidcIdTokenParams

​CompleteOidcIdTokenAuthResult

​StartOidcRedirectAuthParams

​StartOidcRedirectAuthResult

​CompleteOidcRedirectAuthParams

​CompleteOidcRedirectAuthResult

​SignInWithOidcRedirectParams

​OmsRelayOidcProviders

​OmsRelayOidcProvider

​CustomOidcProviderConfig

​AuthMode

​OidcAuthMode

​WalletType

​WalletSelectionBehavior

​WalletAccount

​WalletActivationResult

​PendingWalletSelection

​OMSWalletEmailSessionAuth

​OMSWalletOidcSessionAuthFlow

​OMSWalletOidcSessionAuth

​OMSWalletSessionAuth

​OMSWalletSessionState

​OMSWalletSessionExpiredEvent

​OMSWalletSessionExpiredListener

​GetIdTokenParams

​WalletCredential

​AccessGrant

​ListAccessParams

​AccessGrantPage

​StorageManager

​LocalStorageManager

​SessionStorageManager

​MemoryStorageManager

​createDefaultStorage

​CredentialSigningAlgorithm

​CredentialSigner

​WebCryptoP256CredentialSigner

​EthereumPrivateKeyCredentialSigner

​Transactions and signing

​OMSWalletClient.signMessage

​OMSWalletClient.signTypedData

​OMSWalletClient.isValidMessageSignature

​OMSWalletClient.isValidTypedDataSignature

​OMSWalletClient.sendTransaction

​OMSWalletClient.callContract

​OMSWalletClient.getTransactionStatus

​SignMessageParams

​SignTypedDataParams

​IsValidMessageSignatureParams

​IsValidTypedDataSignatureParams

​AbiArg

​SendTransactionBase

​SendNativeTransactionParams

​SendDataTransactionParams

​SendContractTransactionParams

​SendTransactionParams