React Native API reference - Polygon Developer Docs

OMSWallet

`OMSWallet`

export declare class OMSWallet {
    readonly wallet: OMSWalletClient;
    readonly indexer: OMSIndexerClient;
    /**
     * Creates the native client synchronously and restores a saved session when
     * the device can read it. Throws `OMSWalletError` when the client cannot be
     * created, for example for an invalid publishable key. A new instance
     * replaces the previous one.
     */
    constructor(config: OMSWalletParams);
}

`OMSWalletParams`

export type OMSWalletParams = {
    publishableKey: string;
};

Authentication and sessions

`OMSWalletClient.activeWallet`

The active wallet, or undefined when signed out or while a manual wallet selection is pending. Read synchronously from the native SDK, so it is current right after a sign-in or wallet change returns. Returns the same frozen object until the active wallet or session changes.

get activeWallet(): WalletAccount | undefined;

`OMSWalletClient.session`

The active session; defined exactly when activeWallet is. Returns the same frozen object until the active wallet or session changes.

get session(): OMSWalletSession | undefined;

`OMSWalletClient.onSessionChange`

Calls listener after every change of activeWallet or session, and returns a function that removes the listener. A listener added while signed out first receives the last expired change, until a sign-in starts or the user signs out.

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

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

Claims a preallocated wallet for the signed-in user and makes it the active wallet. During a pending manual selection, use PendingWalletSelection.claimAndSelectWallet.

claimWallet(walletId: string): Promise<WalletActivationResult>;

`OMSWalletClient.createWallet`

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

`OMSWalletClient.importWallet`

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

`OMSWalletClient.getWalletImportRecipientKey`

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

`OMSWalletClient.importEncryptedWallet`

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

`OMSWalletClient.signOut`

signOut(): Promise<void>;

`OMSWalletClient.getIdToken`

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

`OMSWalletClient.inspectRemoteCredential`

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

`OMSWalletClient.authorizeRemoteAccess`

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

`OMSWalletClient.listAccess`

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

`OMSWalletClient.listAccessPages`

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

`OMSWalletClient.listAccessPage`

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

`OMSWalletClient.getRemoteAccessSession`

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

`OMSWalletClient.getRemoteAccessSessionUsage`

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

`OMSWalletClient.revokeAccess`

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

`OmsRelayOidcProviders`

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

`WalletType`

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

`WalletKeyOrigin`

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

`WalletSelectionBehavior`

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

`OMSWalletEmailSessionAuth`

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

`OMSWalletOidcSessionAuthFlow`

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

`OMSWalletOidcSessionAuth`

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

`OMSWalletSessionAuth`

export type OMSWalletSessionAuth = OMSWalletEmailSessionAuth | OMSWalletOidcSessionAuth;

`OMSWalletSession`

Expiry and auth metadata for the active session.

export type OMSWalletSession = {
    /**
     * The current session expiry. The wallet API extends it with use, up to the
     * lifetime requested at sign-in, and the SDK refreshes it.
     */
    expiresAt: string;
    auth: OMSWalletSessionAuth;
};

`OMSWalletExpiredSession`

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

export type OMSWalletExpiredSession = {
    /**
     * The wallet that was active when the session expired. `undefined` when the
     * credential expired while a manual wallet selection was still pending.
     */
    wallet: WalletAccount | undefined;
    session: OMSWalletSession;
    /** When the session ended. */
    expiredAt: string;
};

`OMSWalletSessionChangeReason`

Why the active wallet or session changed.

signedIn: a wallet became active, by a sign-in or by restoring a saved session once the device was unlocked.
walletChanged: another wallet of the same sign-in became active.
expiryUpdated: session.expiresAt moved. Safe to ignore unless you show the expiry.
signedOut: there is no session any more and it did not expire.
expired: the session expired, or the wallet API no longer accepts it.

/**
 * Why the active wallet or session changed.
 *
 * - `signedIn`: a wallet became active, by a sign-in or by restoring a saved
 *   session once the device was unlocked.
 * - `walletChanged`: another wallet of the same sign-in became active.
 * - `expiryUpdated`: `session.expiresAt` moved. Safe to ignore unless you show
 *   the expiry.
 * - `signedOut`: there is no session any more and it did not expire.
 * - `expired`: the session expired, or the wallet API no longer accepts it.
 */
export type OMSWalletSessionChangeReason = 'signedIn' | 'walletChanged' | 'expiryUpdated' | 'signedOut' | 'expired';

`OMSWalletSessionChangeEvent`

The state right after a session change.

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

`OMSWalletSessionChangeListener`

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

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

`WalletAccount`

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

`WalletActivationResult`

export type WalletActivationResult = {
    wallet: WalletAccount;
};

`WalletCredential`

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

`PendingWalletSelection`

export type PendingWalletSelection = {
    walletType: WalletType;
    wallets: WalletAccount[];
    /** Preallocated wallets of `walletType` that the signed-in user can claim. */
    claimableWallets: WalletAccount[];
    credential: WalletCredential;
    selectWallet(walletId: string): Promise<WalletActivationResult>;
    createAndSelectWallet(reference?: string): Promise<WalletActivationResult>;
    /** Claims one of `claimableWallets` and activates it. */
    claimAndSelectWallet(walletId: string): Promise<WalletActivationResult>;
};

`CompleteAuthResult`

export type CompleteAuthResult = {
    type: 'walletSelected';
    wallet: WalletAccount;
    wallets: WalletAccount[];
    /**
     * Preallocated wallets the signed-in user can still claim, of every
     * wallet type. Excludes a wallet claimed during this sign-in.
     */
    claimableWallets: WalletAccount[];
    credential: WalletCredential;
    pendingSelection?: undefined;
} | {
    type: 'walletSelection';
    wallet: undefined;
    wallets: WalletAccount[];
    /** Preallocated wallets of the requested type that the user can claim. */
    claimableWallets: WalletAccount[];
    credential: WalletCredential;
    pendingSelection: PendingWalletSelection;
};

`StartEmailAuthParams`

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

`CompleteEmailAuthParams`

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

`SignInWithOidcIdTokenParams`

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

`OidcAuthMode`

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

`OmsRelayOidcProvider`

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

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

`CustomOidcProviderConfig`

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

`OidcProviderConfig`

export type OidcProviderConfig = OmsRelayOidcProvider | CustomOidcProviderConfig;

`StartOidcRedirectAuthParams`

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

`StartOidcRedirectAuthResult`

export type StartOidcRedirectAuthResult = {
    authorizationUrl: string;
};

`HandleOidcRedirectCallbackParams`

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

`OidcRedirectAuthResult`

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

`CreateWalletParams`

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

`WalletImportCipherSuite`

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

`ImportWalletParams`

export type ImportWalletParams = {
    type: 'ethereum';
    privateKey: string | Uint8Array;
    reference?: string;
} | {
    type: 'solana';
    privateKey: string | Uint8Array;
    reference?: string;
} | {
    type: 'tron';
    /** A secp256k1 private key: 32 raw bytes or 64 hex characters. */
    privateKey: string | Uint8Array;
    reference?: string;
};

`WalletImportRecipientKey`

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

`EncryptedWalletImportKeyMaterial`

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

`ImportEncryptedWalletParams`

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

`GetIdTokenParams`

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

`AccessPage`

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

`RemoteCredentialMetadata`

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

`SmartSessionGrant`

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

`DirectAccessGrant`

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

`RemoteAccessGrant`

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

`AccessGrant`

export type AccessGrant = DirectAccessGrant | RemoteAccessGrant;

`AccessGrantType`

export type AccessGrantType = AccessGrant['type'];

`AccessGrantPage`

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

`AuthorizeRemoteAccessParams`

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

`AuthorizedRemoteAccess`

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

`RemoteAccessSession`

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

`SmartSessionGrantUsage`

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

`RevokeAccessParams`

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

`ListAccessParams`

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

`ListAccessPageParams`

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

Transactions and signing

`OMSWalletClient.signMessage`

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

`OMSWalletClient.signSolanaMessage`

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

`OMSWalletClient.signTypedData`

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

`OMSWalletClient.signTronMessage`

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

`OMSWalletClient.signTronTypedData`

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

`OMSWalletClient.sendTransaction`

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

`OMSWalletClient.sendSolanaTransfer`

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

`OMSWalletClient.sendTronTransaction`

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

`OMSWalletClient.callContract`

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

`OMSWalletClient.callTronContract`

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

`OMSWalletClient.getTransactionStatus`

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

`OMSWalletClient.isValidMessageSignature`

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

`OMSWalletClient.isValidSolanaMessageSignature`

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

`OMSWalletClient.isValidTypedDataSignature`

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

`OMSWalletClient.isValidTronMessageSignature`

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

`OMSWalletClient.isValidTronTypedDataSignature`

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

`FeeOptionSelectors`

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

`SignMessageParams`

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

`SignSolanaMessageParams`

export type SignSolanaMessageParams = {
    message: string;
};

`SignTypedDataParams`

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

`SignTronMessageParams`

export type SignTronMessageParams = {
    message: string;
};

`SignTronTypedDataParams`

export type SignTronTypedDataParams = {
    /** TIP-712 typed data. Address values may be Base58Check (`T…`). */
    typedData: unknown;
};

`IsValidMessageSignatureParams`

export type IsValidMessageSignatureParams = {
    network: Network;
    /** Address to verify against. Omit to use the active Ethereum wallet's address. */
    walletAddress?: string;
    message: string;
    signature: string;
};

`IsValidSolanaMessageSignatureParams`

export type IsValidSolanaMessageSignatureParams = {
    /** Address to verify against. Omit to use the active Solana wallet's address. */
    walletAddress?: string;
    message: string;
    signature: string;
};

`IsValidTypedDataSignatureParams`

export type IsValidTypedDataSignatureParams = {
    network: Network;
    /** Address to verify against. Omit to use the active Ethereum wallet's address. */
    walletAddress?: string;
    typedData: unknown;
    signature: string;
};

`IsValidTronMessageSignatureParams`

export type IsValidTronMessageSignatureParams = {
    /** Base58Check address (`T…`). Omit to use the active Tron wallet's address. */
    walletAddress?: string;
    message: string;
    signature: string;
};

`IsValidTronTypedDataSignatureParams`

export type IsValidTronTypedDataSignatureParams = {
    /** Base58Check address (`T…`). Omit to use the active Tron wallet's address. */
    walletAddress?: string;
    typedData: unknown;
    signature: string;
};

`CallContractArg`

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

`TransactionMode`

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

`TransactionStatus`

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

`TransactionStatusResolution`

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

`TransactionStatusPollingOptions`

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

`SendTransactionResponse`

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

`TransactionStatusResponse`

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

`FeeToken`

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

`FeeOption`

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

`FeeOptionSelection`

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

`FeeOptionWithBalance`

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

`FeeOptionSelector`

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

`SendTransactionParams`

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

`SendSolanaTransferParams`

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

`SendTronTransactionParams`

A Tron transaction. Tron wallets always execute in native mode. Omitting data sends a plain TRX transfer. Passing data (including '0x') makes the transaction a contract call.

export type SendTronTransactionParams = {
    network: TronNetwork;
    /** Base58Check recipient address (`T…`). */
    to: string;
    /** Amount in sun (1 TRX = 1,000,000 sun). Defaults to `'0'`. */
    value?: string;
    data?: string;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};

`CallContractParams`

export type CallContractParams = {
    network: Network;
    contractAddress: string;
    /** Function name only, e.g. `'transfer'`. */
    method: string;
    args?: CallContractArg[];
    mode?: TransactionMode;
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};

`CallTronContractParams`

A Tron contract call, ABI-encoded by the wallet service.

export type CallTronContractParams = {
    network: TronNetwork;
    /** Base58Check contract address (`T…`). */
    contractAddress: string;
    /** Function name only, e.g. `'transfer'`. */
    method: string;
    args?: CallContractArg[];
    selectFeeOption?: FeeOptionSelector;
    waitForStatus?: boolean;
    statusPolling?: TransactionStatusPollingOptions;
};

Indexer

`OMSIndexerClient.getBalances`

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

`OMSIndexerClient.getTransactionHistory`

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

`OMSIndexerClient.getSolanaBalances`

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

`OMSIndexerClient.getTronBalances`

getTronBalances(params: GetTronBalancesParams): Promise<TronBalancesResult>;

`IndexerNetworkType`

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

`ContractVerificationStatus`

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

`MetadataOptions`

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

`SortBy`

export type SortBy = {
    column: string;
    order: 'DESC' | 'ASC';
};

`TokenBalancesPageRequest`

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

`TokenBalancesPage`

export type TokenBalancesPage = {
    page: number;
    /** Cursor fields to pass back in the next page request. */
    column?: string;
    before?: unknown;
    after?: unknown;
    sort?: SortBy[];
    pageSize: number;
    more: boolean;
};

`TokenContractInfo`

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

`TokenMetadataAsset`

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

`TokenMetadata`

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

`NativeTokenBalance`

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

`ContractTokenBalance`

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

`TokenBalance`

export type TokenBalance = NativeTokenBalance | ContractTokenBalance;

`BalancesResult`

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

`GetBalancesParams`

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

`SolanaVerificationStatus`

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

`SolanaVerificationSource`

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

`SolanaNativeBalance`

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

`SolanaFungibleTokenBalance`

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

`SolanaBalance`

export type SolanaBalance = SolanaNativeBalance | SolanaFungibleTokenBalance;

`SolanaNetworkError`

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

`GetSolanaBalancesParams`

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

`SolanaBalancesResult`

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

`TronVerificationStatus`

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

`TronNativeBalance`

export type TronNativeBalance = {
    network: TronNetwork;
    accountAddress: string;
    name: string;
    symbol: string;
    decimals: number;
    /** Raw balance in the token's base units (sun for TRX). */
    balance: string;
    formattedBalance: string;
    imageUrl?: string;
    metadataUri?: string;
    verificationStatus: TronVerificationStatus;
    verificationSource: string;
    priceUSD?: string;
    balanceUSD?: string;
} & {
    assetType: 'native';
    tokenStandard?: undefined;
    contractAddress?: undefined;
};

`TronFungibleTokenBalance`

export type TronFungibleTokenBalance = {
    network: TronNetwork;
    accountAddress: string;
    name: string;
    symbol: string;
    decimals: number;
    /** Raw balance in the token's base units (sun for TRX). */
    balance: string;
    formattedBalance: string;
    imageUrl?: string;
    metadataUri?: string;
    verificationStatus: TronVerificationStatus;
    verificationSource: string;
    priceUSD?: string;
    balanceUSD?: string;
} & {
    assetType: 'fungible-token';
    tokenStandard: 'trc20';
    contractAddress: string;
};

`TronBalance`

export type TronBalance = TronNativeBalance | TronFungibleTokenBalance;

`TronNetworkError`

export type TronNetworkError = {
    network: TronNetwork;
    reason: string;
};

`GetTronBalancesParams`

export type GetTronBalancesParams = {
    /** Base58Check wallet address (`T…`). */
    walletAddress: string;
    /** Defaults to Tron mainnet and Nile. */
    networks?: TronNetwork[];
    includeMetadata?: boolean;
    omitNativeBalances?: boolean;
    /** Only return these TRC-20 contracts (`T…`). */
    contractAddresses?: string[];
    /** Exclude these TRC-20 contracts (`T…`). */
    excludedContractAddresses?: string[];
};

`TronBalancesResult`

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

`TransactionTransfer`

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

`Transaction`

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

`TransactionHistoryResult`

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

`GetTransactionHistoryParams`

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

Networks, types, and errors

`Network`

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

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

`Networks`

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

`SolanaNetwork`

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

`SolanaNetworks`

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

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

`ParseUnitsRoundingMode`

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

`ParseUnitsOptions`

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

`parseUnits`

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

`formatUnits`

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

`OMSWalletErrorCode`

export type OMSWalletErrorCode = 'OMS_HTTP_ERROR' | 'OMS_INVALID_RESPONSE' | 'OMS_REQUEST_FAILED' | 'OMS_AUTH_COMMITMENT_CONSUMED' | 'OMS_SESSION_MISSING' | 'OMS_SESSION_EXPIRED' | 'OMS_WALLET_SELECTION_STALE' | 'OMS_WALLET_SELECTION_UNAVAILABLE' | 'OMS_WALLET_SELECTION_IN_FLIGHT' | 'OMS_TRANSACTION_EXECUTION_UNCONFIRMED' | 'OMS_TRANSACTION_STATUS_LOOKUP_FAILED' | 'OMS_VALIDATION_ERROR' | 'OMS_STORAGE_ERROR' | 'OMS_ATTESTATION_VERIFICATION_FAILED' | 'OMS_WALLET_ADDRESS_ALREADY_IMPORTED';

`OMSWalletUpstreamError`

export type OMSWalletUpstreamError = {
    service: 'waas' | 'indexer';
    name?: string;
    code?: string;
    message?: string;
    status?: number;
    /** The service's reason for this error, when it gives one. */
    cause?: string;
};

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