TypeScript API reference - Polygon Developer Docs

OMSWallet

`OMSWallet`

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

`OMSWalletParams`

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

Authentication and sessions

`WalletClient.activeWallet`

The active wallet, or undefined when signed out or while a manual wallet selection is pending. Same shape as listWallets() entries. The same frozen object is returned until it changes.

readonly activeWallet: WalletAccount | undefined;

`WalletClient.session`

Expiry and auth metadata for the active session; defined exactly when activeWallet is. The same frozen object is returned until it changes.

readonly session: OMSWalletSession | undefined;

`WalletClient.onSessionChange`

Calls listener after every change of activeWallet or session, in order and shortly after the change (never during the call that made it). Subscribe first, then read activeWallet and session, so no change is missed. A listener added while signed out first receives the last expired change, if a session expired since the last sign-in or sign-out (for example while the page was closed). Returns a function that unsubscribes.

onSessionChange(listener: OMSWalletSessionChangeListener): () => void;

`WalletClient.startEmailAuth`

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

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

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

`WalletClient.startOidcRedirectAuth`

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

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

`WalletClient.signInWithOidcRedirect`

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

`WalletClient.signOut`

signOut(): Promise<void>;

`WalletClient.listWallets`

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

`WalletClient.useWallet`

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

`WalletClient.claimWallet`

Claims a preallocated wallet for the signed-in user and makes it the active wallet. Requires an active session; during a pending manual selection use PendingWalletSelection.claimAndSelectWallet.

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

`WalletClient.createWallet`

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

`WalletClient.importWallet`

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

`WalletClient.getWalletImportRecipientKey`

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

`WalletClient.importEncryptedWallet`

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

`WalletClient.getIdToken`

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

`WalletClient.listAccess`

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

`WalletClient.listAccessPage`

Returns one access page. Pass the previous page’s page.cursor to continue.

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

`WalletClient.listAccessPages`

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

`WalletClient.inspectRemoteCredential`

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

`WalletClient.authorizeRemoteAccess`

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

`WalletClient.getRemoteAccessSession`

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

`WalletClient.getRemoteAccessSessionUsage`

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

`WalletClient.revokeAccess`

revokeAccess(params: RevokeAccessParams): 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 wallet: WalletAccount;
    readonly wallets: ReadonlyArray<WalletAccount>;
    readonly claimableWallets: 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 wallet: WalletAccount;
    readonly wallets: ReadonlyArray<WalletAccount>;
    readonly claimableWallets: 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 wallet: WalletAccount;
    readonly wallets: ReadonlyArray<WalletAccount>;
    readonly claimableWallets: 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`

OIDC redirect auth modes accepted by CustomOidcProviderConfig.authMode.

export declare const AuthMode: Readonly<{
    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";
    readonly Solana: "solana";
    readonly Tron: "tron";
}>;
export type WalletType = (typeof WalletType)[keyof typeof WalletType];

`WalletKeyOrigin`

export declare const WalletKeyOrigin: Readonly<{
    readonly Enclave: "enclave";
    readonly Imported: "imported";
}>;
export type WalletKeyOrigin = (typeof WalletKeyOrigin)[keyof typeof WalletKeyOrigin];

`WalletImportCipherSuite`

export declare const WalletImportCipherSuite: Readonly<{
    readonly X25519Sha256Aes256Gcm: "x25519-sha256-aes256gcm";
    readonly X25519Sha256ChaCha20Poly1305: "x25519-sha256-chacha20poly1305";
    readonly P256Sha256Aes256Gcm: "p256-sha256-aes256gcm";
    readonly P256Sha256ChaCha20Poly1305: "p256-sha256-chacha20poly1305";
}>;
export type WalletImportCipherSuite = (typeof WalletImportCipherSuite)[keyof typeof WalletImportCipherSuite];

`WalletSelectionBehavior`

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

`WalletAccount`

export type WalletAccount = EthereumWalletAccount | SolanaWalletAccount | TronWalletAccount;

`EthereumWalletAccount`

export interface EthereumWalletAccount {
    readonly id: string;
    readonly type: "ethereum";
    readonly address: Address;
    readonly reference?: string;
    readonly keyOrigin: WalletKeyOrigin;
}

`SolanaWalletAccount`

export interface SolanaWalletAccount {
    readonly id: string;
    readonly type: "solana";
    readonly address: string;
    readonly reference?: string;
    readonly keyOrigin: WalletKeyOrigin;
}

`TronWalletAccount`

export interface TronWalletAccount {
    readonly id: string;
    readonly type: "tron";
    readonly address: string;
    readonly reference?: string;
    readonly keyOrigin: WalletKeyOrigin;
}

`WalletActivationResult`

export interface WalletActivationResult {
    readonly wallet: WalletAccount;
}

`ImportWalletParams`

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

`WalletImportRecipientKey`

export interface WalletImportRecipientKey {
    readonly keyId: string;
    readonly cipherSuite: WalletImportCipherSuite;
    readonly publicKey: string;
}

`EncryptedWalletImportKeyMaterial`

export interface EncryptedWalletImportKeyMaterial {
    readonly keyId: string;
    readonly cipherSuite: WalletImportCipherSuite;
    readonly encapsulatedKey: string;
    readonly ciphertext: string;
}

`ImportEncryptedWalletParams`

export interface ImportEncryptedWalletParams {
    walletType: WalletType;
    keyMaterial: EncryptedWalletImportKeyMaterial;
    reference?: string;
}

`PendingWalletSelection`

export interface PendingWalletSelection {
    readonly walletType: WalletType;
    readonly wallets: ReadonlyArray<WalletAccount>;
    readonly claimableWallets: ReadonlyArray<WalletAccount>;
    readonly credential: Readonly<WalletCredential>;
    selectWallet(params: {
        walletId: string;
    }): Promise<WalletActivationResult>;
    createAndSelectWallet(params?: {
        reference?: string;
    }): Promise<WalletActivationResult>;
    claimAndSelectWallet(params: {
        walletId: 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;

`OMSWalletSession`

export interface OMSWalletSession {
    readonly expiresAt: string;
    readonly auth: OMSWalletSessionAuth;
}

`OMSWalletSessionChangeEvent`

The state right after a session change: what activeWallet and session returned then.

export type OMSWalletSessionChangeEvent = {
    readonly reason: "signedIn" | "walletChanged" | "expiryUpdated";
    readonly activeWallet: WalletAccount;
    readonly session: OMSWalletSession;
} | {
    readonly reason: "signedOut";
    readonly activeWallet: undefined;
    readonly session: undefined;
} | {
    readonly reason: "expired";
    readonly activeWallet: undefined;
    readonly session: undefined;
    readonly expiredSession: OMSWalletExpiredSession;
};

`OMSWalletSessionChangeReason`

Why activeWallet or session changed.

signedIn: a sign-in made a wallet active, in this client or in another tab.
walletChanged: another wallet of the same sign-in became active, here or in another tab.
expiryUpdated: session.expiresAt moved. Safe to ignore unless you show the expiry.
signedOut: there is no session any more and it did not expire: signOut(), a sign-in started while signed in, or another tab taking over. Not necessarily the user’s choice.
expired: the session expired, or the wallet API no longer accepts it.

export type OMSWalletSessionChangeReason = "signedIn" | "walletChanged" | "expiryUpdated" | "signedOut" | "expired";

`OMSWalletSessionChangeListener`

export type OMSWalletSessionChangeListener = (event: OMSWalletSessionChangeEvent) => void | Promise<void>;

`OMSWalletExpiredSession`

A session that expired, as reported by an expired session change.

export interface OMSWalletExpiredSession {
    readonly wallet: WalletAccount | undefined;
    readonly session: OMSWalletSession;
    readonly expiredAt: string;
}

`DEFAULT_SESSION_LIFETIME_SECONDS`

Session lifetime requested when sessionLifetimeSeconds is omitted (180 days, the maximum).

export declare const DEFAULT_SESSION_LIFETIME_SECONDS = 15552000;

`MAX_SESSION_LIFETIME_SECONDS`

Largest accepted sessionLifetimeSeconds (180 days).

export declare const MAX_SESSION_LIFETIME_SECONDS = 15552000;

`GetIdTokenParams`

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

`WalletCredential`

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

`AccessGrant`

export type AccessGrant = DirectAccessGrant | RemoteAccessGrant;

`DirectAccessGrant`

export interface DirectAccessGrant extends WalletCredential {
    type: "direct";
}

`RemoteAccessGrant`

export interface RemoteAccessGrant extends WalletCredential {
    type: "remote";
    sessionId: string;
    metadata: RemoteCredentialMetadata;
    grants: ReadonlyArray<SmartSessionGrant>;
}

`RemoteCredentialMetadata`

export interface RemoteCredentialMetadata {
    appUrl: string;
    appName: string;
    appLogoUrl: string;
    custom: Readonly<Record<string, string>>;
}

`SmartSessionGrant`

export type SmartSessionGrant = {
    kind: "nativeTransfer";
    to: Address;
    limit: bigint;
} | {
    kind: "erc20Transfer";
    token: Address;
    to?: Address;
    limit: bigint;
    cumulative?: boolean;
};

`ListAccessParams`

export interface ListAccessParams {
    pageSize?: number;
    type?: AccessGrant["type"];
}

`ListAccessPageParams`

export interface ListAccessPageParams extends ListAccessParams {
    cursor?: string;
}

`AccessGrantPage`

export interface AccessGrantPage {
    grants: AccessGrant[];
    page?: {
        limit?: number;
        cursor?: string;
    };
}

`AuthorizeRemoteAccessParams`

export interface AuthorizeRemoteAccessParams {
    credentialId: string;
    network: Network;
    grants: ReadonlyArray<SmartSessionGrant>;
    expiresAt: string;
    sessionId?: string;
}

`AuthorizedRemoteAccess`

export interface AuthorizedRemoteAccess {
    walletId: string;
    sessionId: string;
    expiresAt: string;
}

`RemoteAccessSession`

export interface RemoteAccessSession {
    sessionId: string;
    walletId: string;
    signerAddress: Address;
    grants: ReadonlyArray<SmartSessionGrant>;
    chainId: number;
    expiresAt: string;
}

`SmartSessionGrantUsage`

export interface SmartSessionGrantUsage {
    grant: SmartSessionGrant;
    used?: bigint;
}

`RevokeAccessParams`

export interface RevokeAccessParams {
    credentialId: string;
    sessionId?: string;
}

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

Remote applications

`RemoteAccessClient`

Signs remote-application requests for owner-authorized smart sessions.

export declare class RemoteAccessClient {
    constructor(params: RemoteAccessClientParams);
    registerCredential(params: RegisterRemoteCredentialParams): Promise<RegisteredRemoteCredential>;
    prepareTransaction(params: PrepareRemoteTransactionParams): Promise<PreparedRemoteTransaction>;
    executeTransaction(params: ExecuteRemoteTransactionParams): Promise<ExecutedRemoteTransaction>;
    getTransactionStatus(params: {
        txnId: string;
    }): Promise<TransactionStatusResponse>;
    revokeCredential(params: RevokeRemoteCredentialParams): Promise<void>;
    listSessions(params?: ListRemoteAccessSessionsParams): Promise<RemoteAccessSession[]>;
    listSessionPages(params?: ListRemoteAccessSessionsParams): AsyncIterable<RemoteAccessSessionPage>;
    getSession(params: {
        sessionId: string;
    }): Promise<RemoteAccessSession>;
    getSessionUsage(params: {
        sessionId: string;
        network: Network;
    }): Promise<SmartSessionGrantUsage[]>;
}

`RemoteAccessClientParams`

export interface RemoteAccessClientParams {
    publishableKey: string;
    credentialSigner: CredentialSigner;
}

`RegisterRemoteCredentialParams`

export interface RegisterRemoteCredentialParams {
    lifetimeSeconds: number;
    metadata: RemoteCredentialMetadata;
}

`RegisteredRemoteCredential`

export interface RegisteredRemoteCredential {
    credentialId: string;
}

`RevokeRemoteCredentialParams`

export interface RevokeRemoteCredentialParams {
    credentialId: string;
}

`ListRemoteAccessSessionsParams`

export interface ListRemoteAccessSessionsParams {
    pageSize?: number;
}

`RemoteAccessSessionPage`

export interface RemoteAccessSessionPage {
    sessions: RemoteAccessSession[];
}

`PrepareRemoteTransactionParams`

export interface PrepareRemoteTransactionParams {
    walletId: string;
    sessionId: string;
    network: Network;
    to: Address;
    value?: bigint;
    data?: Hex;
}

`PreparedRemoteTransaction`

export interface PreparedRemoteTransaction {
    txnId: string;
    status: TransactionStatus;
    feeOptions: ReadonlyArray<FeeOption>;
    sponsored: boolean;
    expiresAt: string;
}

`ExecuteRemoteTransactionParams`

export interface ExecuteRemoteTransactionParams {
    txnId: string;
    feeOption?: FeeOptionSelection;
}

`ExecutedRemoteTransaction`

export interface ExecutedRemoteTransaction {
    status: TransactionStatus;
}

Transactions and signing

`WalletClient.signMessage`

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

`WalletClient.signSolanaMessage`

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

`WalletClient.signTypedData`

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

`WalletClient.isValidMessageSignature`

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

`WalletClient.isValidSolanaMessageSignature`

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

`WalletClient.isValidTypedDataSignature`

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

`WalletClient.signTronMessage`

signTronMessage(params: SignTronMessageParams): Promise<string>;

`WalletClient.signTronTypedData`

signTronTypedData(params: SignTronTypedDataParams): Promise<string>;

`WalletClient.isValidTronMessageSignature`

isValidTronMessageSignature(params: IsValidTronMessageSignatureParams): Promise<boolean>;

`WalletClient.isValidTronTypedDataSignature`

isValidTronTypedDataSignature(params: IsValidTronTypedDataSignatureParams): Promise<boolean>;

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

`WalletClient.sendSolanaTransfer`

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

`WalletClient.sendTronTransaction`

sendTronTransaction(params: SendTronTransactionParams): Promise<SendTransactionResponse>;

`WalletClient.callTronContract`

callTronContract(params: CallTronContractParams): Promise<SendTransactionResponse>;

`WalletClient.callContract`

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

`WalletClient.getTransactionStatus`

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

`SignMessageParams`

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

`SignSolanaMessageParams`

export interface SignSolanaMessageParams {
    message: string;
}

`SignTypedDataParams`

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

`IsValidMessageSignatureParams`

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

`IsValidSolanaMessageSignatureParams`

export interface IsValidSolanaMessageSignatureParams {
    walletAddress?: string;
    message: string;
    signature: string;
}

`IsValidTypedDataSignatureParams`

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

`SignTronMessageParams`

export interface SignTronMessageParams {
    message: string;
}

`SignTronTypedDataParams`

export interface SignTronTypedDataParams {
    typedData: unknown;
}

`IsValidTronMessageSignatureParams`

export interface IsValidTronMessageSignatureParams {
    walletAddress?: string;
    message: string;
    signature: string;
}

`IsValidTronTypedDataSignatureParams`

export interface IsValidTronTypedDataSignatureParams {
    walletAddress?: 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;

`SendSolanaTransferParams`

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

`SendTronTransactionParams`

A Tron transaction. Tron wallets are EOAs and always execute in native mode. Omitting data sends a plain TRX transfer. Passing data (including '0x') makes the transaction a contract call; '0x' calls the contract’s payable fallback.

export type SendTronTransactionParams = {
    network: TronNetwork;
    to: string;
    value?: bigint;
    data?: Hex;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};

`CallTronContractParams`

A Tron contract call, ABI-encoded by the wallet service. Address-typed arguments accept Base58Check (T…) addresses.

export type CallTronContractParams = {
    network: TronNetwork;
    contractAddress: string;
    method: string;
    args?: Array<AbiArg>;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};

`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: FeeToken;
    value: string;
    displayValue: string;
}

`FeeToken`

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

`FeeOptionSelection`

export interface FeeOptionSelection {
    token: string;
    index?: number;
}

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

`feeOptionSelection`

export declare function feeOptionSelection(feeOption: FeeOption, index?: number): FeeOptionSelection;

Indexer

`IndexerClient`

export interface IndexerClient {
    getBalances(params: GetBalancesParams): Promise<BalancesResult>;
    getSolanaBalances(params: GetSolanaBalancesParams): Promise<SolanaBalancesResult>;
    getTronBalances(params: GetTronBalancesParams): Promise<TronBalancesResult>;
    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[];
}

`GetSolanaBalancesParams`

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

`SolanaBalancesResult`

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

`SolanaBalance`

export type SolanaBalance = SolanaNativeBalance | SolanaFungibleTokenBalance;

`SolanaNativeBalance`

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

`SolanaNetworkError`

export interface SolanaNetworkError {
    network: SolanaNetwork;
    reason: string;
}

`SolanaVerificationStatus`

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

`SolanaVerificationSource`

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

`GetTronBalancesParams`

export interface GetTronBalancesParams {
    walletAddress: string;
    networks?: TronNetwork[];
    includeMetadata?: boolean;
    omitNativeBalances?: boolean;
    contractAddresses?: string[];
    excludedContractAddresses?: string[];
}

`TronBalancesResult`

export interface TronBalancesResult {
    status: number;
    balances: TronBalance[];
    errors: TronNetworkError[];
}

`TronBalance`

export type TronBalance = TronNativeBalance | TronFungibleTokenBalance;

`TronNativeBalance`

export interface TronNativeBalance {
    network: TronNetwork;
    accountAddress: string;
    name: string;
    symbol: string;
    decimals: number;
    balance: string;
    formattedBalance: string;
    imageUrl?: string;
    metadataUri?: string;
    verificationStatus: TronVerificationStatus;
    verificationSource: string;
    priceUSD?: string;
    balanceUSD?: string;
    assetType: "native";
    tokenStandard?: undefined;
    contractAddress?: undefined;
}

`TronFungibleTokenBalance`

export interface TronFungibleTokenBalance {
    network: TronNetwork;
    accountAddress: string;
    name: string;
    symbol: string;
    decimals: number;
    balance: string;
    formattedBalance: string;
    imageUrl?: string;
    metadataUri?: string;
    verificationStatus: TronVerificationStatus;
    verificationSource: string;
    priceUSD?: string;
    balanceUSD?: string;
    assetType: "fungible-token";
    tokenStandard: "trc20";
    contractAddress: string;
}

`TronNetworkError`

export interface TronNetworkError {
    network: TronNetwork;
    reason: string;
}

`TronVerificationStatus`

export type TronVerificationStatus = "verified" | "unverified" | "unknown";

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

`SolanaNetwork`

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

`SolanaNetworks`

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

`TronNetwork`

export type TronNetwork = (typeof TronNetworks)[keyof typeof TronNetworks];

`TronNetworks`

export declare const TronNetworks: Readonly<{
    readonly mainnet: "tron:mainnet";
    readonly nile: "tron:nile";
}>;

`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_WALLET_ADDRESS_ALREADY_IMPORTED" | "OMS_ATTESTATION_VERIFICATION_FAILED" | "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?: string;
    message?: string;
    cause?: string;
    status?: number;
}

`OMSWalletOperation`

Operation identifiers reported in OMSWalletError.operation.

export type OMSWalletOperation = WalletOperation | IndexerOperation | RemoteAccessOperation;

`WalletOperation`

export declare const WalletOperation: {
    readonly pendingWalletSelectionSelectWallet: "wallet.pendingWalletSelection.selectWallet";
    readonly pendingWalletSelectionCreateAndSelectWallet: "wallet.pendingWalletSelection.createAndSelectWallet";
    readonly pendingWalletSelectionClaimAndSelectWallet: "wallet.pendingWalletSelection.claimAndSelectWallet";
    readonly startEmailAuth: "wallet.startEmailAuth";
    readonly completeEmailAuth: "wallet.completeEmailAuth";
    readonly signInWithOidcIdToken: "wallet.signInWithOidcIdToken";
    readonly startOidcRedirectAuth: "wallet.startOidcRedirectAuth";
    readonly completeOidcRedirectAuth: "wallet.completeOidcRedirectAuth";
    readonly signInWithOidcRedirect: "wallet.signInWithOidcRedirect";
    readonly signOut: "wallet.signOut";
    readonly listWallets: "wallet.listWallets";
    readonly useWallet: "wallet.useWallet";
    readonly claimWallet: "wallet.claimWallet";
    readonly createWallet: "wallet.createWallet";
    readonly importWallet: "wallet.importWallet";
    readonly getWalletImportRecipientKey: "wallet.getWalletImportRecipientKey";
    readonly importEncryptedWallet: "wallet.importEncryptedWallet";
    readonly getIdToken: "wallet.getIdToken";
    readonly signMessage: "wallet.signMessage";
    readonly signSolanaMessage: "wallet.signSolanaMessage";
    readonly signTypedData: "wallet.signTypedData";
    readonly isValidMessageSignature: "wallet.isValidMessageSignature";
    readonly isValidSolanaMessageSignature: "wallet.isValidSolanaMessageSignature";
    readonly isValidTypedDataSignature: "wallet.isValidTypedDataSignature";
    readonly signTronMessage: "wallet.signTronMessage";
    readonly signTronTypedData: "wallet.signTronTypedData";
    readonly isValidTronMessageSignature: "wallet.isValidTronMessageSignature";
    readonly isValidTronTypedDataSignature: "wallet.isValidTronTypedDataSignature";
    readonly sendTransaction: "wallet.sendTransaction";
    readonly sendSolanaTransfer: "wallet.sendSolanaTransfer";
    readonly sendTronTransaction: "wallet.sendTronTransaction";
    readonly callTronContract: "wallet.callTronContract";
    readonly callContract: "wallet.callContract";
    readonly execute: "wallet.execute";
    readonly getTransactionStatus: "wallet.getTransactionStatus";
    readonly inspectRemoteCredential: "wallet.inspectRemoteCredential";
    readonly authorizeRemoteAccess: "wallet.authorizeRemoteAccess";
    readonly listAccess: "wallet.listAccess";
    readonly listAccessPage: "wallet.listAccessPage";
    readonly listAccessPages: "wallet.listAccessPages";
    readonly getRemoteAccessSession: "wallet.getRemoteAccessSession";
    readonly getRemoteAccessSessionUsage: "wallet.getRemoteAccessSessionUsage";
    readonly revokeAccess: "wallet.revokeAccess";
    readonly transactionStatus: "wallet.transactionStatus";
};
export type WalletOperation = (typeof WalletOperation)[keyof typeof WalletOperation];

`IndexerOperation`

export declare const IndexerOperation: {
    readonly getBalances: "indexer.getBalances";
    readonly getSolanaBalances: "indexer.getSolanaBalances";
    readonly getTronBalances: "indexer.getTronBalances";
    readonly getTransactionHistory: "indexer.getTransactionHistory";
};
export type IndexerOperation = (typeof IndexerOperation)[keyof typeof IndexerOperation];

`RemoteAccessOperation`

export declare const RemoteAccessOperation: {
    readonly registerCredential: "remoteAccess.registerCredential";
    readonly prepareTransaction: "remoteAccess.prepareTransaction";
    readonly executeTransaction: "remoteAccess.executeTransaction";
    readonly getTransactionStatus: "remoteAccess.getTransactionStatus";
    readonly revokeCredential: "remoteAccess.revokeCredential";
    readonly listSessions: "remoteAccess.listSessions";
    readonly listSessionPages: "remoteAccess.listSessionPages";
    readonly getSession: "remoteAccess.getSession";
    readonly getSessionUsage: "remoteAccess.getSessionUsage";
};
export type RemoteAccessOperation = (typeof RemoteAccessOperation)[keyof typeof RemoteAccessOperation];

`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" | "OMS_WALLET_ADDRESS_ALREADY_IMPORTED";
        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" | "OMS_WALLET_ADDRESS_ALREADY_IMPORTED";
    });
}

`OMSWalletResponseError`

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

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