import { T as Transport, P as PasskeyAssertor, R as RelyingPartyOriginInput, K as KvStorage } from '../interfaces-_8SljvDt.js'; export { O as OAuthOpener, a as PlatformImpls, W as WebAuthnAssertionResponse, b as WebAuthnRequestOptions, r as resolveRelyingPartyOrigin } from '../interfaces-_8SljvDt.js'; import { C as CachedAssertion } from '../passkey-cache-WnDFQ-v4.js'; import { B as BulkImportKeySpec, a as BulkImportFailure } from '../bulk-import-wallets-CoMBE0Rc.js'; export { b as BATCH_SCOPED_FAILURE_REASONS, c as BulkImportFailureScope, d as BulkImportResult, e as BulkImportedWallet, G as GetInternalPresenceTokensResult, M as MAX_BULK_IMPORT_KEYS_PER_REQUEST, f as MAX_REGISTER_CREATE_TOKENS_PER_CEREMONY, N as NON_RETRYABLE_FAILURE_REASONS, O as OTP_PRESENCE_SCOPES, P as PASSKEY_ONLY_PRESENCE_SCOPES, g as PRESENCE_OTP_MAX_ATTEMPTS, h as PresenceOtpCodeProvider, i as PresenceOtpCodeRequest, j as PresenceOtpSettledHandler, k as PresenceScope, R as RegisterCreateWalletChain, l as RegisterCreateWalletSpec, m as RegisterCreatedWallet, S as SCOPES_ADD_PASSKEY, n as SCOPES_CREATE_WALLET, o as SCOPES_EXPORT_KEY, p as SCOPES_IMPORT_KEY, q as SCOPES_LINK_LOGIN_METHOD, r as SCOPES_PROVISION_EPHEMERAL_SIGNER, s as SCOPES_REMOVE_KMS_WRAP, t as SCOPES_REMOVE_PASSKEY, u as SCOPES_REVOKE_EPHEMERAL_SIGNER, v as SCOPES_SIGN, w as SCOPES_UNLINK_LOGIN_METHOD, x as SCOPE_PROVISION_EPHEMERAL_SIGNER, y as SESSION_PRESENCE_SCOPES, z as ScopedPresenceToken, A as bulkImportWallets, C as createWalletsForRegistration, D as flattenPresenceTokenBatches, E as flattenPresenceTokens, F as getInternalPresenceTokens, H as registerPresenceOtpCodeProvider, I as scopeCountsForBulkImport, J as scopeCountsForRegisterCreate, K as validateBulkImportKeys, L as validateRegisterCreateWallets } from '../bulk-import-wallets-CoMBE0Rc.js'; import { EthereumSignMessageParams, EthereumSignMessageResult, EthereumSignTransactionParams, EthereumSignTransactionResult, EthereumSignTypedDataParams, EthereumSignTypedDataResult, EthereumSignHashParams, EthereumSignHashResult, EthereumSign7702AuthorizationParams, EthereumSign7702AuthorizationResult, EthereumSendTransactionParams, EthereumSendTransactionResult, EthereumSendBatchAtomicParams, EthereumSendBatchAtomicResult, EthereumSendTransactionsParams, EthereumSendTransactionsResult, EthereumGetBalanceParams, EthereumGetBalanceResult, EthereumGetTokenAccountsByOwnerParams, EthereumGetTokenAccountsByOwnerResult, BitcoinSignMessageParams, BitcoinSignMessageResult, BitcoinSignTransactionParams, BitcoinSignTransactionResult, BitcoinSendTransactionParams, BitcoinSendTransactionResult, BitcoinGetBalanceParams, BitcoinGetBalanceResult, BitcoinGetUtxosParams, BitcoinGetUtxosResult, SolanaSignMessageParams, SolanaSignMessageResult, SolanaSignTransactionParams, SolanaSignTransactionResult, SolanaSendTransactionParams, SolanaSendTransactionResult, SolanaGetBalanceParams, SolanaGetBalanceResult, SolanaGetTokenAccountsByOwnerParams, SolanaGetTokenAccountsByOwnerResult, TronSignMessageParams, TronSignMessageResult, TronSignTransactionParams, TronSignTransactionResult, TronSendTransactionParams, TronSendTransactionResult, TronGetBalanceParams, TronGetBalanceResult, PrepareCommerceFundingParams, CommercePaymentMethod, CommerceFundingSession, PrepareFundingParams, FundingSession, SendEmailOtpResponse, LinkEmailBeginResponse, LinkEmailVerifyResponse, ChangeEmailStepResponse, ChangeEmailVerifyResponse, SendSmsOtpResponse, WalletImportSource, PublicWallet, ProvisionEphemeralSignerParams, ProvisionEphemeralSignerResult, PrepareSigningParams, PrepareSigningResult, ListEphemeralSignersResult, RevokeEphemeralSignerParams, GetSessionTokensOptions, BitcoinAddressType, CustodyStateResult, LinkPhoneBeginResponse, LinkPhoneVerifyResponse } from '../types/index.js'; import '../post-message-ufv3D_fs.js'; type AssertPasskeyInParentResult = CachedAssertion; declare const assertPasskeyInParent: ({ transport, passkey, publishableKey, validateCredentialInAllowList, }: { transport: Transport; passkey: PasskeyAssertor; publishableKey: string; validateCredentialInAllowList?: boolean; }) => Promise; interface GetPresenceTokenResult { presenceToken: string; expiresAt: number; } declare const getPresenceToken: ({ transport, passkey, publishableKey, relyingPartyOrigin, expiresInSecs, }: { transport: Transport; passkey: PasskeyAssertor; publishableKey: string; relyingPartyOrigin: RelyingPartyOriginInput; expiresInSecs?: number; }) => Promise; declare const getHeadlessEthereumMethods: ({ transport, passkey, publishableKey, relyingPartyOrigin, }: { transport: Transport; passkey: PasskeyAssertor; publishableKey: string; relyingPartyOrigin: RelyingPartyOriginInput; }) => { signEthereumMessageHeadless: (params: EthereumSignMessageParams) => Promise; signEthereumTransactionHeadless: (params: EthereumSignTransactionParams) => Promise; signEthereumTypedDataHeadless: (params: EthereumSignTypedDataParams) => Promise; signEthereumHashHeadless: (params: EthereumSignHashParams) => Promise; signEthereum7702AuthorizationHeadless: (params: EthereumSign7702AuthorizationParams) => Promise; sendEthereumTransactionHeadless: (params: EthereumSendTransactionParams) => Promise; sendEthereumBatchAtomicHeadless: (params: EthereumSendBatchAtomicParams) => Promise; sendEthereumTransactionsHeadless: (params: EthereumSendTransactionsParams) => Promise; getEthereumBalance: (params: EthereumGetBalanceParams) => Promise; getEthereumTokenAccountsByOwner: (params: EthereumGetTokenAccountsByOwnerParams) => Promise; getEthereumConfirmTransaction: (params: { transaction: string | object; walletAddress: string; rpcUrl: string; network?: string; }) => Promise; }; declare const getHeadlessBitcoinMethods: ({ transport, passkey, publishableKey, relyingPartyOrigin, }: { transport: Transport; passkey: PasskeyAssertor; publishableKey: string; relyingPartyOrigin: RelyingPartyOriginInput; }) => { signBitcoinMessageHeadless: (params: BitcoinSignMessageParams) => Promise; signBitcoinTransactionHeadless: (params: BitcoinSignTransactionParams) => Promise; sendBitcoinTransactionHeadless: (params: BitcoinSendTransactionParams) => Promise; getBitcoinBalance: (params: BitcoinGetBalanceParams) => Promise; getBitcoinUtxos: (params: BitcoinGetUtxosParams) => Promise; }; declare const getHeadlessSolanaMethods: ({ transport, passkey, publishableKey, relyingPartyOrigin, }: { transport: Transport; passkey: PasskeyAssertor; publishableKey: string; relyingPartyOrigin: RelyingPartyOriginInput; }) => { signSolanaMessageHeadless: (params: SolanaSignMessageParams) => Promise; signSolanaTransactionHeadless: (params: SolanaSignTransactionParams) => Promise; sendSolanaTransactionHeadless: (params: SolanaSendTransactionParams) => Promise; getSolanaBalance: (params: SolanaGetBalanceParams) => Promise; getSolanaTokenAccountsByOwner: (params: SolanaGetTokenAccountsByOwnerParams) => Promise; }; declare const getHeadlessTronMethods: ({ transport, passkey, publishableKey, relyingPartyOrigin, }: { transport: Transport; passkey: PasskeyAssertor; publishableKey: string; relyingPartyOrigin: RelyingPartyOriginInput; }) => { signTronMessageHeadless: (params: TronSignMessageParams) => Promise; signTronTransactionHeadless: (params: TronSignTransactionParams) => Promise; sendTronTransactionHeadless: (params: TronSendTransactionParams) => Promise; getTronBalance: (params: TronGetBalanceParams) => Promise; }; /** * Prepare funding data without opening UI. The host owns presentation. */ declare const getHeadlessFundingMethods: ({ transport, publishableKey, }: { transport: Transport; publishableKey: string; }) => { getCommerceFundingMethods: (params: PrepareCommerceFundingParams) => Promise; prepareCommerceFunding: (params: PrepareCommerceFundingParams) => Promise; prepareFunding: (params: PrepareFundingParams) => Promise; }; interface SendCodeParams { email: string; disableSignup?: boolean; } interface LoginWithCodeParams { code: string; } interface SendEmailLinkCodeParams { email: string; } interface LinkEmailWithCodeParams { email: string; code: string; } interface SendEmailChangeCodeParams { /** The new address. */ email: string; } interface EmailChangeCodeParams { code: string; } interface SendSmsCodeParams { /** International with a leading + (E.164). */ phone: string; } interface LoginWithMoonPayCustomerTokenParams { customerToken: string; } interface LoginWithMoonPayCustomerTokenResult { userCreated: boolean; } declare const MOONPAY_CONSUMER_SESSION_ERROR_CODES: { readonly TOKEN_REQUIRED: "moonpay_consumer_token_required"; readonly APP_KEY_MISMATCH: "moonpay_consumer_app_key_mismatch"; readonly SESSION_INVALID: "moonpay_consumer_session_invalid"; readonly AUTH_DISABLED: "moonpay_consumer_auth_disabled"; readonly EMAIL_CONFLICT: "moonpay_consumer_email_conflict"; readonly AUTH_UNAVAILABLE: "moonpay_consumer_auth_unavailable"; readonly AUTH_NOT_CONFIGURED: "moonpay_consumer_auth_not_configured"; readonly SESSION_FAILED: "moonpay_consumer_session_failed"; }; type MoonPayConsumerSessionErrorCode = (typeof MOONPAY_CONSUMER_SESSION_ERROR_CODES)[keyof typeof MOONPAY_CONSUMER_SESSION_ERROR_CODES]; interface MoonPayConsumerSessionError extends Error { error_type: "authentication"; error_code: MoonPayConsumerSessionErrorCode; status_code?: number; } declare const createMoonPayConsumerSessionError: (errorCode: MoonPayConsumerSessionErrorCode, statusCode?: number) => MoonPayConsumerSessionError; interface VerifyOAuthParams { provider: "google" | "apple"; code?: string; token?: string; state?: string; } declare const getHeadlessAuthenticationMethods: ({ transport, publishableKey, setIsAuthenticated, setUser, }: { transport: Transport; publishableKey: string; setIsAuthenticated?: (isAuth: boolean) => void; setUser?: (user: unknown | null) => void; }) => { /** * Send a one-time passcode to the user's email address. Returns the * server's response — most importantly `expires_at` (unix seconds), * which the UI uses to render a countdown that cannot drift from the * authoritative server-side TTL. */ sendCode: (params: SendCodeParams) => Promise; /** * Verify the OTP and complete the login. The iframe-app handles * session persistence; on success the SDK flips isAuthenticated and * fetches the real user object to populate provider state. */ loginWithCode: (params: LoginWithCodeParams) => Promise; /** * Send a one-time passcode to an address the signed-in account wants to * attach. Requires a live session; the proof is bound to that user, so it * cannot be redeemed as a login. * * Deliberately does not touch `authState.email`: that field tracks a pending * *login*, and a link running alongside one must not overwrite it. Pass the * address back to `linkEmailWithCode` instead. */ sendEmailLinkCode: (params: SendEmailLinkCodeParams) => Promise; /** * Redeem the code and attach the address. No session is minted or replaced, * so `isAuthenticated` is untouched; the user object is re-fetched because * its `emails` list has changed. * * Resolves with `is_new_link: false` when the address was already this * account's. Rejects with `email_already_in_use` when it belongs to someone * else; the platform never merges or re-points accounts. */ linkEmailWithCode: (params: LinkEmailWithCodeParams) => Promise; /** * Start changing the signed-in account's email to `email`. The platform * mails a code to the account's current address, listing every app that * uses this account, since the change applies to all of them. */ sendEmailChangeCode: (params: SendEmailChangeCodeParams) => Promise; /** * Redeem the code sent to the current address. On success the platform * mails a second code to the new address. */ confirmEmailChangeCurrentCode: (params: EmailChangeCodeParams) => Promise; /** * Redeem the code sent to the new address and switch the account to it. * The current session stays signed in; other sessions are signed out by * the platform. Rejects with `email_already_in_use` or * `email_change_blocked` without changing anything. */ confirmEmailChangeNewCode: (params: EmailChangeCodeParams) => Promise; /** * Text a one-time passcode to the user's phone. Returns the server's * response with `expires_at` (unix seconds), like `sendCode`, and the * `challenge_id` that `loginWithSmsCode` redeems. Only works when the app * config's `sms_otp.enabled` is true. */ sendSmsCode: (params: SendSmsCodeParams) => Promise; /** * Verify the SMS code and complete the login. Same session handling as * `loginWithCode`. A rejection with `error_type` * `phone_login_restart_required` means the code is spent: call * `sendSmsCode` again. */ loginWithSmsCode: (params: LoginWithCodeParams) => Promise; /** * Exchange an authenticated MoonPay Consumer token for a MoonX session. * The iframe owns the resulting session. The Consumer token is used only * for this exchange. The promise resolves after the session is stored and * authentication state is true. The user profile loads separately, so * `user` can remain null for a short time or until a later retry. */ loginWithMoonPayCustomerToken: (params: LoginWithMoonPayCustomerTokenParams) => Promise; /** * Commit an OAuth code/token for a session. The deep-link / popup * round-trip lives in the platform-specific OAuth hook; this method * is the tail-end commit step the hook calls. */ verifyOAuth: (params: VerifyOAuthParams) => Promise; /** * Commit the provider's token for a link (attachOAuth): the same * VERIFY_OAUTH, under the current session, but not a login. The user * stays the same account, so this only refreshes it so the new sign-in * shows in linked_accounts. */ verifyOAuthLink: (params: VerifyOAuthParams) => Promise; }; interface PasskeyStatusResult { has_passkey: boolean; has_backup_eligible_passkey?: boolean; passkeys: Array<{ id: string; credential_id: string; created_at: string; last_used_at: string | null; aaguid?: string; transports?: string[]; backup_eligible?: boolean; backup_state?: boolean; registered_browser?: string; registered_os?: string; }>; } interface SendPhoneLinkCodeParams { /** International with a leading + (E.164). */ phone: string; } interface LinkPhoneWithCodeParams { /** The `challenge_id` from `sendPhoneLinkCode`. */ challengeId: string; code: string; } declare const getHeadlessGeneralMethods: ({ transport, passkey, storage, publishableKey, relyingPartyOrigin, setIsAuthenticated, setUser, }: { transport: Transport; passkey: PasskeyAssertor; storage: KvStorage; publishableKey: string; relyingPartyOrigin: RelyingPartyOriginInput; setIsAuthenticated?: (isAuth: boolean) => void; setUser?: (user: unknown | null) => void; }) => { importKey: (walletType: "solana" | "ethereum" | "tron" | "bitcoin", importSource: string | WalletImportSource, options?: { addressType?: "p2tr" | "p2wpkh" | "p2pkh"; }) => Promise<{ wallet: PublicWallet; }>; bulkImport: (keys: BulkImportKeySpec[]) => Promise<{ wallets: PublicWallet[]; failures: BulkImportFailure[]; }>; provisionEphemeralSigner: (params: ProvisionEphemeralSignerParams) => Promise; prepareSigning: (params: PrepareSigningParams) => Promise; listEphemeralSigners: () => Promise; revokeEphemeralSigner: (params: RevokeEphemeralSignerParams) => Promise; getWallets: (walletType: "solana" | "ethereum" | "tron" | "bitcoin") => Promise<{ wallets: unknown[]; walletType: string; }>; getSessionTokens: (options?: GetSessionTokensOptions) => Promise<{ accessToken: string; identityToken: string; expiresAt: number; } | null>; logout: () => Promise<{ success: boolean; message: string; }>; getCurrentSession: () => Promise; getUser: () => Promise; createWallet: (walletType: "solana" | "ethereum" | "tron" | "bitcoin", options?: { createAdditional?: boolean; walletIndex?: number; addressType?: BitcoinAddressType; purpose?: "card"; }) => Promise<{ wallet: PublicWallet; }>; findOrCreateWallet: (walletType: "solana" | "ethereum" | "tron" | "bitcoin", options?: { addressType?: BitcoinAddressType; }) => Promise<{ wallet: PublicWallet; }>; getPasskeyStatus: () => Promise; getCustodyState: (options?: { waitForClaim?: boolean; }) => Promise; removePasskey: (credentialIdB64url: string) => Promise; beginOAuthLink: (provider: "google" | "apple", loginRedirectUrl: string) => Promise<{ redirect_url: string; }>; detachOAuth: (idpUserId: string) => Promise<{ provider: string; }>; /** * Text a one-time passcode to a number the signed-in account wants to * attach. Same step-up rule as beginOAuthLink (login_method_add). Leaves * the pending login state alone. Pass the returned `challenge_id` to * `linkPhoneWithCode`. Only works when the app config's `phone_link.enabled` * is true. */ sendPhoneLinkCode: (params: SendPhoneLinkCodeParams) => Promise; /** * Redeem the code and attach the number. No session is minted or replaced. * * An account holds one phone number. Rejects with `phone already linked` * when the number belongs to another account or this account already holds * a different one; remove that one with `detachPhone` first. A rejection * with `error_type` `phone_link_restart_required` means the code is spent: * call `sendPhoneLinkCode` again. */ linkPhoneWithCode: (params: LinkPhoneWithCodeParams) => Promise; detachPhone: () => Promise<{ provider: string; }>; disableAccountRecovery: () => Promise; }; interface EphemeralSignerWalletLookupInput { /** Lowercase-hex 32-byte Ed25519 agent public key (no 0x prefix). */ apiPubHex: string; /** Lowercase-hex 32-byte Ed25519 agent private key (no 0x prefix). */ apiPrivHex: string; /** * Wallet UUID (from `user.wallets[i].id`) the agent should sign on * behalf of. Must be one of the wallets the agent was provisioned * for. The SDK resolves this internally to the wallet's MPC `key_id` * + stored `derivation_path` — integrators never see those values. */ walletId: string; /** * Wallets backend base URL (no trailing slash). Optional — defaults to * {@link DEFAULT_API_BASE_URL}, the standard MoonX deployment. Override * only for local/dev or a non-default environment. */ baseUrl?: string; /** * MoonX secret key (`moon_sk_*`). The wallets backend's server-side * ephemeral-signer routes (/me/wallets, /sign) are secret-key-only * (RequireSecretKey), so every call needs an `Authorization: Bearer * ` header. Server-only; never expose to the browser. */ secretKey: string; /** Optional fetch override — e.g. for Next.js route handlers or test stubs. */ fetchImpl?: typeof fetch; } interface EphemeralSignerSignInput extends EphemeralSignerWalletLookupInput { /** Lowercase-hex digest or message bytes to sign. No 0x prefix. */ rawSigningPayloadHex: string; /** Defaults to now. SES rejects timestamps further than ±5 min from its clock. */ issuedAt?: Date; } interface EphemeralSignerSignResult { scheme: "ecdsa_secp256k1" | "bip340_secp256k1" | "eddsa_ed25519"; signature: { /** ECDSA only. Lowercase-hex 32-byte r. */ r?: string; /** ECDSA only. Lowercase-hex 32-byte s. */ s?: string; /** ECDSA only. 0..3. */ recovery_id?: number; /** Ed25519 or BIP340. Lowercase-hex 64-byte signature. */ signature?: string; }; } interface EphemeralSignerWalletBinding { walletId: string; keyId: string; publicAddress: string; derivationPath: string; chain?: string; algorithm?: string; addressType?: "p2tr" | "p2wpkh" | "p2pkh"; /** Tweaked output key for P2TR; ordinary secp256k1 public key otherwise. */ publicKey?: string; /** Untweaked BIP86 child key used as tapInternalKey for P2TR. */ internalPublicKey?: string; } /** * Default MoonX API base URL for the ephemeral-signer routes. Matches the * node-sdk's default deployment. Callers override `baseUrl` only for local * development or a non-standard environment. */ declare const DEFAULT_API_BASE_URL = "https://api.moonx-dev.com"; declare class EphemeralSignerSignError extends Error { readonly status?: number | undefined; readonly body?: string | undefined; constructor(message: string, status?: number | undefined, body?: string | undefined); } /** * Wire error string the wallets service returns (with HTTP 410) when * the signing enclave no longer holds the agent's key material. The * enclave keeps provisioned keys in memory only, so an enclave restart * or upgrade invalidates every agent provisioned before it. */ declare const SIGNER_NOT_PROVISIONED = "signer_not_provisioned"; /** * True when a sign attempt failed because the signing enclave lost the * agent's key material (HTTP 410 signer_not_provisioned). This state is * permanent for the key pair: retrying can never succeed, and the * wallet owner must provision a fresh signer (new apiPub) through the * browser provisioning flow. Discard the dead key and route the user * to re-provision when this returns true. The same condition surfaces * on the list endpoint as `status: "needs_reauth"`. */ declare function isSignerNotProvisioned(err: unknown): boolean; /** * Resolve walletId → {keyId, derivationPath} for the given agent. Hits * /v0/wallets/ephemeral-signers/me/wallets on first call per process per * apiPub, caches the response. Throws if walletId isn't in the agent's * authorized set. */ declare function resolveEphemeralSignerWallet(input: EphemeralSignerWalletLookupInput): Promise; declare function signWithEphemeralSigner(input: EphemeralSignerSignInput): Promise; declare const SESSION_RESUME_SESSION_ID_PATTERN: RegExp; declare const SESSION_RESUME_CHALLENGE_PATTERN: RegExp; /** The exact message the backend verifies. */ declare const sessionResumeMessage: (sessionId: string, challenge: string) => string; interface SessionResumeKeyPair { /** 32-byte scalar, base64url. Secret: keep it in secure storage only. */ privateKey: string; /** 65-byte uncompressed point, base64url (87 characters). */ publicKey: string; } /** Generates a resume key pair from the platform's secure random source. */ declare const createSessionResumeKeyPair: () => SessionResumeKeyPair; /** Recomputes the public key, or null when privateKey is not a valid scalar. */ declare const sessionResumePublicKeyOf: (privateKey: string) => string | null; /** * Signs a resume challenge. Signs only the fixed resume message format, * never caller-chosen bytes. Null when the inputs do not have that format. */ declare const signSessionResume: (privateKey: string, sessionId: string, challenge: string) => string | null; export { type AssertPasskeyInParentResult, BulkImportFailure, BulkImportKeySpec, DEFAULT_API_BASE_URL, type EmailChangeCodeParams, EphemeralSignerSignError, type EphemeralSignerSignInput, type EphemeralSignerSignResult, type EphemeralSignerWalletBinding, type EphemeralSignerWalletLookupInput, type GetPresenceTokenResult, KvStorage, type LinkEmailWithCodeParams, type LinkPhoneWithCodeParams, type LoginWithCodeParams, type LoginWithMoonPayCustomerTokenParams, type LoginWithMoonPayCustomerTokenResult, MOONPAY_CONSUMER_SESSION_ERROR_CODES, type MoonPayConsumerSessionError, type MoonPayConsumerSessionErrorCode, PasskeyAssertor, type PasskeyStatusResult, RelyingPartyOriginInput, SESSION_RESUME_CHALLENGE_PATTERN, SESSION_RESUME_SESSION_ID_PATTERN, SIGNER_NOT_PROVISIONED, type SendCodeParams, type SendEmailChangeCodeParams, type SendEmailLinkCodeParams, type SendPhoneLinkCodeParams, type SendSmsCodeParams, type SessionResumeKeyPair, Transport, type VerifyOAuthParams, assertPasskeyInParent, createMoonPayConsumerSessionError, createSessionResumeKeyPair, getHeadlessAuthenticationMethods, getHeadlessBitcoinMethods, getHeadlessEthereumMethods, getHeadlessFundingMethods, getHeadlessGeneralMethods, getHeadlessSolanaMethods, getHeadlessTronMethods, getPresenceToken, isSignerNotProvisioned, resolveEphemeralSignerWallet, sessionResumeMessage, sessionResumePublicKeyOf, signSessionResume, signWithEphemeralSigner };