@oasisprotocol/privana-sdk 0.5.0 → 0.5.2

package/dist/pending-lock-BdkuMjmY.d.cts

@@ -0,0 +1,600 @@
+import { WalletClient } from 'viem';
+
+var networks = {
+	testnet: {
+		chainId: 23295,
+		name: "Sapphire Testnet",
+		accountingContract: "0xad3C76e4E621C0cfF7540479Ee9B0A945723A642",
+		apiUrl: "https://api.testnet.privana.finance"
+	},
+	mainnet: {
+		chainId: 23294,
+		name: "Sapphire Mainnet",
+		accountingContract: "0x0000000000000000000000000000000000000000",
+		apiUrl: ""
+	}
+};
+var config = {
+	networks: networks
+};
+
+type Address = `0x${string}`;
+type Bytes32 = `0x${string}`;
+type HexString = `0x${string}`;
+type IntegerLike = string | number;
+type HostedAuthResponseMode = 'web_message' | 'redirect';
+type Network = keyof typeof config.networks;
+interface NetworkConfig {
+    chainId: number;
+    name: string;
+    accountingContract: Address;
+    apiUrl: string;
+    /** Versioned MoonPay REST API base URL (default: 'https://api.moonpay.com/v3'). */
+    moonpayApiUrl?: string;
+    /**
+     * MoonPay publishable API key ('pk_test_…' / 'pk_live_…' — MoonPay infers the
+     * environment from the prefix). Enables the credit-card deposit flow: the SDK
+     * mounts its own MoonPayProvider around the credit-card subtree, so consumers
+     * don't wrap the app in one (and don't pay MoonPay's CDN script cost at app start).
+     */
+    moonpayApiKey?: string;
+}
+declare const NETWORK_CONFIG: {
+    readonly testnet: {
+        readonly accountingContract: Address;
+        readonly chainId: number;
+        readonly name: string;
+        readonly apiUrl: string;
+    };
+    readonly mainnet: {
+        readonly accountingContract: Address;
+        readonly chainId: number;
+        readonly name: string;
+        readonly apiUrl: string;
+    };
+};
+declare function getChainId(network: Network): number;
+declare function getAccountingContract(network: Network): Address;
+declare function getApiUrl(network: Network): string;
+declare function normalizeHex(value: string): HexString;
+declare function normalizeAddress(value: string): Address;
+
+interface TokenConfig {
+    id: Bytes32;
+    symbol: string;
+    decimals: number;
+    contract: Address;
+    name: string;
+    chainId: number;
+    /**
+     * MoonPay-specific currency identifier for the credit-card on-ramp (e.g. 'usdc'
+     * or 'usdc_base'). Populated SDK-side from a stopgap map until the token API
+     * returns it; `undefined` when the token isn't supported by MoonPay.
+     */
+    moonpayCurrencyCode?: string;
+}
+
+interface DepositAddressRequest {
+    chain_type?: string;
+    version?: number;
+}
+interface DepositCheckRequest {
+    chain_type?: string;
+    chain_id: number;
+    tx_hash: HexString;
+    amount: IntegerLike;
+    log_index?: number;
+    version?: number;
+}
+interface PendingDepositsRequest {
+    chain_id: number;
+    version?: number;
+    token_address?: Address;
+    lookback_blocks?: number;
+}
+interface LockFundsRequest {
+    service_address: Address;
+    token_id: Bytes32;
+    amount: IntegerLike;
+    expiry: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface ModifyLockRequest {
+    lock_id: number;
+    amount: IntegerLike;
+    new_expiry: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface UnlockFundsRequest {
+    user_address: Address;
+    lock_id: number;
+}
+interface UnlockAllExpiredRequest {
+    user_address: Address;
+}
+interface TransferFundsRequest {
+    to_address: Address;
+    token_id: Bytes32;
+    amount: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface TransferLockedFundsRequest {
+    user_address: Address;
+    lock_id: number;
+    to_address: Address;
+    amount: IntegerLike;
+    service_address: Address;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface WithdrawalRequest {
+    token_id: Bytes32;
+    amount: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface WithdrawFromLockRequest {
+    to_address: Address;
+    lock_id: number;
+    amount: IntegerLike;
+    nonce: IntegerLike;
+    signature: HexString;
+}
+interface BatchBalancesRequest {
+    token_ids: Bytes32[];
+}
+interface HistoryRequest {
+    offset?: number;
+    limit?: number;
+}
+interface SiweLoginRequest {
+    siwe_message: string;
+    signature: HexString;
+}
+interface HostedAuthAuthorizeUrlRequest {
+    client_id: string;
+    redirect_uri: string;
+    code_challenge: string;
+    state: string;
+    chain_id: number;
+    response_mode?: HostedAuthResponseMode;
+    code_challenge_method?: 'S256';
+}
+interface HostedAuthTokenExchangeRequest {
+    grant_type?: 'authorization_code';
+    code: string;
+    code_verifier: string;
+    client_id: string;
+    redirect_uri: string;
+}
+interface JwtRefreshRequest {
+    refresh_token: string;
+}
+interface JwtLogoutRequest {
+    refresh_token?: string;
+    revoke_all?: boolean;
+}
+
+interface MinDepositAmounts {
+    native: string;
+    erc20: string;
+}
+interface DepositAddressResponse {
+    deposit_address: Address;
+    chain_type: string;
+    version: number;
+    min_deposit: Record<string, MinDepositAmounts>;
+}
+interface DepositCheckResponse {
+    status: 'credited' | 'pending' | 'error';
+    deposit_id?: string | null;
+    amount?: string | null;
+    token_address?: Address | null;
+    detail?: string | null;
+}
+type PendingDepositStatus = 'discovered' | 'processing';
+interface PendingDeposit {
+    chain_id: number;
+    tx_hash: HexString;
+    log_index: number;
+    /** Base units. */
+    amount: string;
+    token_address: Address;
+    token_id: Bytes32;
+    block_number: number;
+    version: number;
+    status: PendingDepositStatus;
+    /** Set only when status is 'processing'. */
+    deposit_id: string | null;
+}
+interface PendingDepositsResponse {
+    pending: PendingDeposit[];
+    scanned_from_block: number;
+    scanned_to_block: number;
+}
+interface TransactionSubmissionResponse {
+    submission_id: string;
+    status: string;
+    detail?: string;
+}
+interface BalanceResponse {
+    user_address: Address;
+    token_id: Bytes32;
+    balance: string;
+    token_symbol: string;
+    chain_id: string;
+}
+interface TokenBalance {
+    token_id: Bytes32;
+    balance: string;
+    token_symbol: string;
+    chain_id: string;
+}
+interface BatchBalancesResponse {
+    user_address: Address;
+    balances: TokenBalance[];
+}
+type HistoryKind = 'deposit' | 'withdraw' | 'createLock' | 'transferFromLockOut' | 'transferFromLockIn' | 'transferBalanceOut' | 'transferBalanceIn' | 'modifyLock' | 'unlockLock' | 'unknown';
+interface HistoryEntry {
+    kind: HistoryKind;
+    timestamp: number;
+    token_id?: Bytes32 | null;
+    amount?: string | null;
+    counterparty?: Address | null;
+    deposit_id?: Bytes32 | null;
+    chain_id?: number | null;
+}
+interface HistoryResponse {
+    history: HistoryEntry[];
+    total: number;
+}
+interface TokenInfoResponse {
+    token_id: Bytes32;
+    token_type: number;
+    token_type_name: string;
+    data: string;
+    chain_id: number;
+    chain_name: string;
+    token_address: Address;
+    symbol: string;
+    name: string;
+    decimals: number;
+}
+interface TokenListResponse {
+    tokens: TokenInfoResponse[];
+}
+interface LockInfo {
+    lock_id: number;
+    user_address: Address;
+    service_address: Address;
+    token_id: Bytes32;
+    amount: string;
+    expiry: number;
+    is_expired: boolean;
+}
+interface LockedFundsResponse {
+    user_address: Address;
+    service_address?: Address;
+    locks: LockInfo[];
+    total_locked: string;
+}
+interface ExpiredLocksResponse {
+    user_address: Address;
+    expired_locks: LockInfo[];
+}
+interface TotalLockedBalanceResponse {
+    user_address: Address;
+    token_id: Bytes32;
+    total_locked: string;
+}
+interface WithdrawalInfo {
+    index: number;
+    user_address: Address;
+    to_address: Address;
+    amount: string;
+    block_number: number;
+    token_id: Bytes32;
+    resolved: boolean;
+    tx_identifier: string;
+}
+interface PendingWithdrawalsResponse {
+    user_address: Address;
+    pending_withdrawals: WithdrawalInfo[];
+}
+type WithdrawalInfoResponse = WithdrawalInfo;
+interface TransferNonceResponse {
+    user_address: Address;
+    nonce: string;
+}
+interface WithdrawalNonceResponse {
+    user_address: Address;
+    nonce: string;
+}
+interface LockNonceResponse {
+    user_address: Address;
+    nonce: string;
+}
+interface ModifyLockNonceResponse {
+    user_address: Address;
+    nonce: string;
+}
+interface TransferLockedNonceResponse {
+    service_address: Address;
+    nonce: string;
+}
+interface SiweDomainResponse {
+    domain: string;
+}
+interface SiweNonceResponse {
+    address: Address;
+    nonce: string;
+    expires_in: number;
+}
+interface SiweLoginResponse {
+    siwe_token: HexString;
+    jwt_access_token: string;
+    jwt_refresh_token: string;
+    address: Address;
+    jwt_expires_in: number;
+    jwt_refresh_expires_in: number;
+}
+interface HostedAuthTokenExchangeResponse {
+    access_token: string;
+    id_token: string;
+    refresh_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_expires_in: number;
+    address: Address;
+}
+interface JwtRefreshResponse {
+    token: string;
+    refresh_token: string;
+    expires_in: number;
+    refresh_expires_in: number;
+}
+interface JwtLogoutResponse {
+    message: string;
+    revoked_tokens: number;
+}
+
+type OnRampStatus = 'pending' | 'completed' | 'failed' | 'cancelled';
+/** Request body / response of POST /api/onramp/sign-url */
+interface SignOnRampUrlRequest {
+    url: string;
+}
+interface SignOnRampUrlResponse {
+    signature: string;
+}
+/** Request body / response of POST /api/onramp/intent. */
+interface CreateOnRampIntentRequest {
+    wallet_address?: Address;
+    token_id: Bytes32;
+    chain_id: number;
+    moonpay_currency_code: string;
+    base_currency_code?: string;
+    base_currency_amount?: string;
+}
+type CreateOnRampIntentResponse = OnRampRecord;
+/** Request body / response of POST /api/onramp/{id}. */
+interface UpdateOnRampRequest {
+    wallet_address?: Address;
+    token_id?: Bytes32;
+    chain_id?: number;
+    moonpay_transaction_id?: string;
+    base_currency_code?: string;
+    base_currency_amount?: string;
+    quote_currency_amount?: string;
+    on_chain_tx_hash?: HexString;
+    deposit_tx_hash?: HexString;
+}
+type UpdateOnRampResponse = OnRampRecord;
+interface OnRampRecord {
+    transaction_id: string;
+    external_transaction_id?: string;
+    moonpay_transaction_id?: string;
+    status: OnRampStatus;
+    wallet_address?: Address;
+    token_id?: Bytes32;
+    chain_id?: number;
+    moonpay_currency_code?: string;
+    base_currency_code?: string;
+    base_currency_amount?: string;
+    quote_currency_amount?: string;
+    on_chain_tx_hash?: HexString;
+    deposit_tx_hash?: HexString;
+    deposit_triggered_at?: number;
+    credited_at?: number;
+    created_at: number;
+    updated_at: number;
+}
+/** Response body of GET /api/onramp/pending */
+interface PendingOnRampsResponse {
+    pending: OnRampRecord[];
+}
+
+interface HttpClientConfig {
+    baseUrl: string;
+    timeout?: number;
+    headers?: Record<string, string>;
+}
+declare class HttpClient {
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly headers;
+    constructor(config: HttpClientConfig);
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    getBaseUrl(): string;
+    setHeader(name: string, value: string): void;
+    removeHeader(name: string): void;
+    getHeader(name: string): string | undefined;
+    private request;
+}
+
+type PrivanaClientConfig = HttpClientConfig;
+declare class PrivanaClient {
+    private readonly http;
+    constructor(config: PrivanaClientConfig);
+    getBaseUrl(): string;
+    getDepositAddress(request?: DepositAddressRequest): Promise<DepositAddressResponse>;
+    checkDeposit(request: DepositCheckRequest): Promise<DepositCheckResponse>;
+    getDepositStatus(depositId: string): Promise<DepositCheckResponse>;
+    getPendingDeposits(request: PendingDepositsRequest): Promise<PendingDepositsResponse>;
+    getBalance(tokenId: Bytes32 | string): Promise<BalanceResponse>;
+    getBatchBalances(request: BatchBalancesRequest): Promise<BatchBalancesResponse>;
+    getHistory(request?: HistoryRequest): Promise<HistoryResponse>;
+    listTokens(): Promise<TokenListResponse>;
+    getTokenInfo(tokenId: Bytes32 | string): Promise<TokenInfoResponse>;
+    lockFunds(request: LockFundsRequest): Promise<TransactionSubmissionResponse>;
+    modifyLock(request: ModifyLockRequest): Promise<TransactionSubmissionResponse>;
+    unlockFunds(request: UnlockFundsRequest): Promise<TransactionSubmissionResponse>;
+    unlockAllExpired(request: UnlockAllExpiredRequest): Promise<TransactionSubmissionResponse>;
+    getLockedFunds(serviceAddress?: Address | string): Promise<LockedFundsResponse>;
+    getTotalLockedBalance(tokenId: Bytes32 | string): Promise<TotalLockedBalanceResponse>;
+    getExpiredLocks(): Promise<ExpiredLocksResponse>;
+    transferFunds(request: TransferFundsRequest): Promise<TransactionSubmissionResponse>;
+    getTransferNonce(userAddress: Address | string): Promise<TransferNonceResponse>;
+    getLockNonce(userAddress: Address | string): Promise<LockNonceResponse>;
+    getModifyLockNonce(userAddress: Address | string): Promise<ModifyLockNonceResponse>;
+    transferLockedFunds(request: TransferLockedFundsRequest): Promise<TransactionSubmissionResponse>;
+    withdrawFromLock(request: WithdrawFromLockRequest): Promise<TransactionSubmissionResponse>;
+    requestWithdrawal(request: WithdrawalRequest): Promise<TransactionSubmissionResponse>;
+    getWithdrawalNonce(userAddress: Address | string): Promise<WithdrawalNonceResponse>;
+    getTransferLockedNonce(serviceAddress: Address | string): Promise<TransferLockedNonceResponse>;
+    getPendingWithdrawals(userAddress: Address | string): Promise<PendingWithdrawalsResponse>;
+    getWithdrawalInfo(index: number): Promise<WithdrawalInfoResponse>;
+    getSiweDomain(): Promise<SiweDomainResponse>;
+    getSiweNonce(userAddress: Address | string): Promise<SiweNonceResponse>;
+    loginWithSiwe(request: SiweLoginRequest): Promise<SiweLoginResponse>;
+    getHostedAuthAuthorizeUrl(request: HostedAuthAuthorizeUrlRequest): string;
+    exchangeHostedAuthCode(request: HostedAuthTokenExchangeRequest): Promise<HostedAuthTokenExchangeResponse>;
+    refreshJwtSession(request: JwtRefreshRequest): Promise<JwtRefreshResponse>;
+    logoutJwtSession(request?: JwtLogoutRequest): Promise<JwtLogoutResponse>;
+    signOnRampUrl(request: SignOnRampUrlRequest): Promise<SignOnRampUrlResponse>;
+    createOnRampIntent(request: CreateOnRampIntentRequest): Promise<CreateOnRampIntentResponse>;
+    updateOnRamp(transactionId: string, request: UpdateOnRampRequest): Promise<UpdateOnRampResponse>;
+    getPendingOnRamps(): Promise<PendingOnRampsResponse>;
+    setPrivateReadToken(token: string): void;
+    getPrivateReadToken(): string | undefined;
+    clearPrivateReadToken(): void;
+    setBearerToken(token: string): void;
+    clearBearerToken(): void;
+}
+
+/**
+ * Deposit-and-lock without backend involvement: the user pre-signs a regular
+ * `Lock` (EIP-712) for the exact expected amount before the deposit, the SDK
+ * persists the payload, and submits it to POST /funds/lock once the deposit is
+ * credited. Every failure fails closed — if the credited amount is short or the
+ * nonce went stale, the lock reverts, the funds stay in the user's available
+ * balance, and the UI re-prompts a fresh signature at the actual amount.
+ * Services must only act on lock confirmation, never on deposit.
+ */
+interface PostDepositLockConfig {
+    /** Service the funds get locked to. Defaults to the provider's `serviceAddress`. */
+    serviceAddress?: Address;
+    /**
+     * Lock lifetime in seconds from signing (default 259200, 3 days). The `Lock` expiry is
+     * an absolute timestamp baked into the signature, so it runs from signing
+     * time, not from credit time — budget for the expected delivery delay.
+     */
+    lockDuration?: number;
+    /**
+     * Cap on the locked amount in base units (the allowance the service
+     * requested). The signed amount is `min(computed amount, maxAmount)`.
+     */
+    maxAmount?: bigint;
+}
+/** `PostDepositLockConfig` for on-ramps, where fees make delivery inexact. */
+interface OnRampPostDepositLockConfig extends PostDepositLockConfig {
+    /**
+     * Fraction shaved off the quoted amount before signing (default 0.02), so
+     * settlement-rate drift on slow payment rails can't push the delivered
+     * amount below the signed amount. The difference stays in the user's
+     * available balance. Card purchases target the quote amount; the buffer
+     * mainly matters for bank rails that settle at a later rate.
+     */
+    buffer?: number;
+}
+declare const DEFAULT_LOCK_DURATION_SECONDS = 259200;
+declare const DEFAULT_ONRAMP_LOCK_BUFFER = 0.02;
+/**
+ * `floor(amount × (1 − buffer))` in base units. Always rounds down so the
+ * signed amount never exceeds what the buffer is meant to guarantee.
+ */
+declare function applyLockBuffer(amount: bigint, buffer?: number): bigint;
+/**
+ * `min(amount, maxAmount)` — the allowance cap the service requested. The
+ * signed lock must never exceed it, no matter what the flow computed.
+ */
+declare function clampLockAmount(amount: bigint, maxAmount?: bigint): bigint;
+interface CreateSignedLockRequestParams {
+    client: PrivanaClient;
+    walletClient: WalletClient;
+    userAddress: Address;
+    networkConfig: NetworkConfig;
+    serviceAddress: Address;
+    tokenId: Bytes32;
+    /** Exact amount to lock, in base units. */
+    amount: bigint;
+    lockDuration?: number;
+}
+/**
+ * Fetch the user's lock nonce and sign a ready-to-submit `Lock` payload.
+ * Validity is bounded by the single-use nonce — any other lock operation by
+ * the user invalidates it, which fails closed (revert → re-prompt).
+ */
+declare function createSignedLockRequest({ client, walletClient, userAddress, networkConfig, serviceAddress, tokenId, amount, lockDuration, }: CreateSignedLockRequestParams): Promise<LockFundsRequest>;
+/** False once the signed lock's expiry is too close to be worth submitting. */
+declare function isSignedLockUsable(payload: LockFundsRequest): boolean;
+type PostDepositLockFailureReason = 
+/** The signed lock's expiry passed before the deposit was credited. */
+'expired'
+/** The credited amount is below the signed amount; submitting would revert. */
+ | 'credited-below-signed'
+/** The API rejected the submission (stale nonce, revert, transport error). */
+ | 'submission-failed'
+/** No persisted signed lock for this deposit (storage cleared, other device). */
+ | 'not-found';
+/**
+ * The deposit itself was credited; only the post-credit lock failed. UIs
+ * should re-prompt a fresh `Lock` signature at the actual credited amount.
+ */
+declare class PostDepositLockError extends Error {
+    readonly reason: PostDepositLockFailureReason;
+    readonly signedAmount?: bigint | undefined;
+    readonly creditedAmount?: bigint | undefined;
+    constructor(message: string, reason: PostDepositLockFailureReason, signedAmount?: bigint | undefined, creditedAmount?: bigint | undefined, options?: {
+        cause?: unknown;
+    });
+}
+interface SubmitPendingLockParams {
+    client: PrivanaClient;
+    payload: LockFundsRequest;
+    /** Credited amount in base units, when known — skips a guaranteed revert. */
+    creditedAmount?: bigint;
+}
+/**
+ * Submit a pre-signed lock after the deposit credited. Throws
+ * `PostDepositLockError` on every failure path so callers can route to the
+ * re-prompt flow.
+ */
+declare function submitPendingLock({ client, payload, creditedAmount, }: SubmitPendingLockParams): Promise<TransactionSubmissionResponse>;
+/**
+ * Persist a signed lock so submission survives a page reload between deposit
+ * and credit. `correlationId` ties it to the deposit (tx hash) or on-ramp
+ * intent (transaction id).
+ */
+declare function savePendingLock(userAddress: string, correlationId: string, payload: LockFundsRequest): void;
+/**
+ * Returns the stored payload even when its expiry passed — expiry belongs to
+ * `submitPendingLock`, which reports it as a precise `'expired'` failure.
+ */
+declare function loadPendingLock(userAddress: string, correlationId: string): LockFundsRequest | undefined;
+declare function clearPendingLock(userAddress: string, correlationId: string): void;
+
+export { type OnRampRecord as $, type Address as A, type Bytes32 as B, type CreateOnRampIntentRequest as C, type DepositAddressResponse as D, type ExpiredLocksResponse as E, type HttpClientConfig as F, type JwtLogoutRequest as G, type HostedAuthTokenExchangeResponse as H, type IntegerLike as I, type JwtRefreshResponse as J, type JwtLogoutResponse as K, type LockInfo as L, type JwtRefreshRequest as M, type NetworkConfig as N, type LockFundsRequest as O, PrivanaClient as P, type LockNonceResponse as Q, type LockedFundsResponse as R, type SiweLoginResponse as S, type TokenConfig as T, type MinDepositAmounts as U, type ModifyLockNonceResponse as V, type WithdrawalInfo as W, type ModifyLockRequest as X, NETWORK_CONFIG as Y, type Network as Z, type OnRampPostDepositLockConfig as _, type TokenBalance as a, type OnRampStatus as a0, type PendingDepositStatus as a1, type PendingDepositsRequest as a2, type PendingOnRampsResponse as a3, type PendingWithdrawalsResponse as a4, type PostDepositLockFailureReason as a5, type PrivanaClientConfig as a6, type SignOnRampUrlRequest as a7, type SignOnRampUrlResponse as a8, type SiweDomainResponse as a9, normalizeAddress as aA, normalizeHex as aB, savePendingLock as aC, submitPendingLock as aD, type SiweLoginRequest as aa, type SiweNonceResponse as ab, type SubmitPendingLockParams as ac, type TokenListResponse as ad, type TotalLockedBalanceResponse as ae, type TransferFundsRequest as af, type TransferLockedFundsRequest as ag, type TransferLockedNonceResponse as ah, type TransferNonceResponse as ai, type UnlockAllExpiredRequest as aj, type UnlockFundsRequest as ak, type UpdateOnRampRequest as al, type UpdateOnRampResponse as am, type WithdrawFromLockRequest as an, type WithdrawalInfoResponse as ao, type WithdrawalNonceResponse as ap, type WithdrawalRequest as aq, applyLockBuffer as ar, clampLockAmount as as, clearPendingLock as at, createSignedLockRequest as au, getAccountingContract as av, getApiUrl as aw, getChainId as ax, isSignedLockUsable as ay, loadPendingLock as az, type PostDepositLockConfig as b, type DepositCheckResponse as c, type TransactionSubmissionResponse as d, PostDepositLockError as e, type PendingDeposit as f, type PendingDepositsResponse as g, type HistoryEntry as h, type TokenInfoResponse as i, type BalanceResponse as j, type BatchBalancesRequest as k, type BatchBalancesResponse as l, type CreateOnRampIntentResponse as m, type CreateSignedLockRequestParams as n, DEFAULT_LOCK_DURATION_SECONDS as o, DEFAULT_ONRAMP_LOCK_BUFFER as p, type DepositAddressRequest as q, type DepositCheckRequest as r, type HexString as s, type HistoryKind as t, type HistoryRequest as u, type HistoryResponse as v, type HostedAuthAuthorizeUrlRequest as w, type HostedAuthResponseMode as x, type HostedAuthTokenExchangeRequest as y, HttpClient as z };