@getpara/user-management-client 0.1.0

package/dist/esm/consts.js

@@ -0,0 +1,4 @@
+export const SESSION_COOKIE_HEADER_NAME = 'x-capsule-sid';
+export const VERSION_HEADER_NAME = 'x-capsule-version';
+export const PARTNER_ID_HEADER_NAME = 'x-partner-id';
+export const API_KEY_HEADER_NAME = 'X-External-API-Key';

package/dist/esm/error.js

@@ -0,0 +1,16 @@
+export function ParaApiError(message, code, status, responseURL) {
+    Error.call(this);
+    if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+    }
+    else {
+        this.stack = new Error().stack;
+    }
+    this.message = message;
+    this.name = 'ParaApiError';
+    code && (this.code = code);
+    status && (this.status = status);
+    responseURL && (this.responseURL = responseURL);
+}
+const prototype = ParaApiError.prototype;
+Object.defineProperty(prototype, 'isParaApiError', { value: true });

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './types/index.js';
+export * from './utils.js';
+import Client from './client.js';
+export default Client;

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/dist/esm/types/auth.js

@@ -0,0 +1,42 @@
+export var EncryptorType;
+(function (EncryptorType) {
+    EncryptorType["USER"] = "USER";
+    EncryptorType["RECOVERY"] = "RECOVERY";
+    EncryptorType["BIOMETRICS"] = "BIOMETRICS";
+    EncryptorType["PASSWORD"] = "PASSWORD";
+})(EncryptorType || (EncryptorType = {}));
+export var KeyShareType;
+(function (KeyShareType) {
+    KeyShareType["USER"] = "USER";
+    KeyShareType["RECOVERY"] = "RECOVERY";
+})(KeyShareType || (KeyShareType = {}));
+export var PasswordStatus;
+(function (PasswordStatus) {
+    PasswordStatus["PENDING"] = "PENDING";
+    PasswordStatus["COMPLETE"] = "COMPLETE";
+})(PasswordStatus || (PasswordStatus = {}));
+export var PublicKeyStatus;
+(function (PublicKeyStatus) {
+    PublicKeyStatus["PENDING"] = "PENDING";
+    PublicKeyStatus["COMPLETE"] = "COMPLETE";
+})(PublicKeyStatus || (PublicKeyStatus = {}));
+export var PublicKeyType;
+(function (PublicKeyType) {
+    PublicKeyType["MOBILE"] = "MOBILE";
+    PublicKeyType["WEB"] = "WEB";
+})(PublicKeyType || (PublicKeyType = {}));
+export var OAuthMethod;
+(function (OAuthMethod) {
+    OAuthMethod["GOOGLE"] = "GOOGLE";
+    OAuthMethod["TWITTER"] = "TWITTER";
+    OAuthMethod["APPLE"] = "APPLE";
+    OAuthMethod["DISCORD"] = "DISCORD";
+    OAuthMethod["FACEBOOK"] = "FACEBOOK";
+    OAuthMethod["FARCASTER"] = "FARCASTER";
+    OAuthMethod["TELEGRAM"] = "TELEGRAM";
+})(OAuthMethod || (OAuthMethod = {}));
+export var AuthMethod;
+(function (AuthMethod) {
+    AuthMethod["PASSWORD"] = "PASSWORD";
+    AuthMethod["PASSKEY"] = "PASSKEY";
+})(AuthMethod || (AuthMethod = {}));

package/dist/esm/types/email.js

@@ -0,0 +1,5 @@
+export var EmailTheme;
+(function (EmailTheme) {
+    EmailTheme["LIGHT"] = "light";
+    EmailTheme["DARK"] = "dark";
+})(EmailTheme || (EmailTheme = {}));

package/dist/esm/types/index.js

@@ -0,0 +1,5 @@
+export * from './auth.js';
+export * from './email.js';
+export * from './onRamp.js';
+export * from './partner.js';
+export * from './wallet.js';

package/dist/esm/types/onRamp.js

@@ -0,0 +1,30 @@
+export var OnRampProvider;
+(function (OnRampProvider) {
+    OnRampProvider["RAMP"] = "RAMP";
+    OnRampProvider["STRIPE"] = "STRIPE";
+    OnRampProvider["MOONPAY"] = "MOONPAY";
+})(OnRampProvider || (OnRampProvider = {}));
+export var OnRampAsset;
+(function (OnRampAsset) {
+    OnRampAsset["ETHEREUM"] = "ETHEREUM";
+    OnRampAsset["USDC"] = "USDC";
+    OnRampAsset["TETHER"] = "TETHER";
+    OnRampAsset["POLYGON"] = "POLYGON";
+    OnRampAsset["SOLANA"] = "SOLANA";
+    OnRampAsset["ATOM"] = "ATOM";
+    OnRampAsset["CELO"] = "CELO";
+    OnRampAsset["CUSD"] = "CUSD";
+    OnRampAsset["CEUR"] = "CEUR";
+    OnRampAsset["CREAL"] = "CREAL";
+})(OnRampAsset || (OnRampAsset = {}));
+export var OnRampPurchaseStatus;
+(function (OnRampPurchaseStatus) {
+    OnRampPurchaseStatus["INITIATED"] = "INITIATED";
+    OnRampPurchaseStatus["FINISHED"] = "FINISHED";
+    OnRampPurchaseStatus["CANCELLED"] = "CANCELLED";
+})(OnRampPurchaseStatus || (OnRampPurchaseStatus = {}));
+export var OnRampPurchaseType;
+(function (OnRampPurchaseType) {
+    OnRampPurchaseType["BUY"] = "BUY";
+    OnRampPurchaseType["SELL"] = "SELL";
+})(OnRampPurchaseType || (OnRampPurchaseType = {}));

package/dist/esm/types/partner.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/wallet.js

@@ -0,0 +1,41 @@
+import { OAuthMethod } from './auth.js';
+export var WalletScheme;
+(function (WalletScheme) {
+    WalletScheme["DKLS"] = "DKLS";
+    WalletScheme["CGGMP"] = "CGGMP";
+    WalletScheme["ED25519"] = "ED25519";
+})(WalletScheme || (WalletScheme = {}));
+export var WalletType;
+(function (WalletType) {
+    WalletType["EVM"] = "EVM";
+    WalletType["SOLANA"] = "SOLANA";
+    WalletType["COSMOS"] = "COSMOS";
+})(WalletType || (WalletType = {}));
+export var Chain;
+(function (Chain) {
+    Chain["ETH"] = "ETH";
+    Chain["CELO"] = "CELO";
+    Chain["MATIC"] = "MATIC";
+})(Chain || (Chain = {}));
+export var Network;
+(function (Network) {
+    Network["ETHEREUM"] = "ETHEREUM";
+    Network["SEPOLIA"] = "SEPOLIA";
+    Network["ARBITRUM"] = "ARBITRUM";
+    Network["BASE"] = "BASE";
+    Network["OPTIMISM"] = "OPTIMISM";
+    Network["POLYGON"] = "POLYGON";
+    Network["SOLANA"] = "SOLANA";
+    Network["COSMOS"] = "COSMOS";
+    Network["CELO"] = "CELO";
+    Network["NOBLE"] = "NOBLE";
+})(Network || (Network = {}));
+export const PREGEN_IDENTIFIER_TYPES = [
+    'EMAIL',
+    'PHONE',
+    'CUSTOM_ID',
+    OAuthMethod.DISCORD,
+    OAuthMethod.TWITTER,
+    OAuthMethod.TELEGRAM,
+];
+export const NON_ED25519 = [WalletScheme.DKLS, WalletScheme.CGGMP];

package/dist/esm/utils.js

@@ -0,0 +1,96 @@
+export function isWalletId(params) {
+    return !!params.walletId && !params.externalWalletAddress;
+}
+export function isExternalWalletAddress(params) {
+    return !!params.externalWalletAddress && !params.walletId;
+}
+export function extractWalletRef(params) {
+    if (isWalletId(params)) {
+        return ['walletId', params.walletId];
+    }
+    else if (isExternalWalletAddress(params)) {
+        return ['externalWalletAddress', params.externalWalletAddress];
+    }
+    throw new Error('invalid wallet params');
+}
+function isValid(s) {
+    return !!s && s !== 'null' && s !== 'undefined' && s !== '';
+}
+export function isEmail(params) {
+    return (isValid(params.email) &&
+        !isValid(params.phone) &&
+        !isValid(params.countryCode) &&
+        !isValid(params.farcasterUsername) &&
+        !isValid(params.telegramUserId));
+}
+export function isPhone(params) {
+    return (isValid(params.phone) &&
+        isValid(params.countryCode) &&
+        !isValid(params.email) &&
+        !isValid(params.farcasterUsername) &&
+        !isValid(params.telegramUserId));
+}
+export function isFarcaster(params) {
+    return (isValid(params.farcasterUsername) &&
+        !isValid(params.email) &&
+        !isValid(params.phone) &&
+        !isValid(params.countryCode) &&
+        !isValid(params.telegramUserId));
+}
+export function isTelegram(params) {
+    return (isValid(params.telegramUserId) &&
+        !isValid(params.email) &&
+        !isValid(params.phone) &&
+        !isValid(params.countryCode) &&
+        !isValid(params.farcasterUsername));
+}
+export function isUserId(params) {
+    return (isValid(params.userId) &&
+        !isValid(params.email) &&
+        !isValid(params.phone) &&
+        !isValid(params.countryCode) &&
+        !isValid(params.farcasterUsername) &&
+        !isValid(params.telegramUserId));
+}
+export function extractAuthInfo(obj, { allowUserId } = {}) {
+    switch (true) {
+        case isEmail(obj):
+            return { auth: { email: obj.email }, authType: 'email', identifier: obj.email, publicKeyIdentifier: obj.email };
+        case isPhone(obj):
+            return {
+                auth: { phone: obj.phone, countryCode: obj.countryCode },
+                authType: 'phone',
+                identifier: `${obj.countryCode}${obj.phone}`,
+                publicKeyIdentifier: `${obj.countryCode}${obj.phone}`,
+            };
+        case isFarcaster(obj):
+            return {
+                auth: { farcasterUsername: obj.farcasterUsername },
+                authType: 'farcaster',
+                identifier: obj.farcasterUsername,
+                publicKeyIdentifier: `${obj.farcasterUsername}-farcaster`,
+            };
+        case isTelegram(obj):
+            return {
+                auth: { telegramUserId: obj.telegramUserId },
+                authType: 'telegram',
+                identifier: obj.telegramUserId,
+                publicKeyIdentifier: `${obj.telegramUserId}-telegram`,
+            };
+        case isUserId(obj) && allowUserId:
+            return { auth: { userId: obj.userId }, authType: 'userId', identifier: obj.userId, publicKeyIdentifier: obj.userId };
+        default:
+            throw new Error('invalid auth object');
+    }
+}
+export function extractAuth(obj, opts = {}) {
+    try {
+        return extractAuthInfo(obj, { allowUserId: opts.allowUserId || false }).auth;
+    }
+    catch (e) {
+        if (opts.optional) {
+            return undefined;
+        }
+        throw e;
+    }
+}

package/dist/types/client.d.ts

@@ -0,0 +1,326 @@
+import { AxiosResponse } from 'axios';
+import { Auth, AuthMethod, AuthParams, BackupKitEmailProps, BiometricLocationHint, Chain, CurrentWalletIds, EncryptedKeyShare, EncryptorType, KeyShareType, Network, OnRampAsset, OnRampConfig, OnRampProvider, OnRampPurchase, OnRampPurchaseCreateParams, OnRampPurchaseUpdateParams, PasswordStatus, PregenIds, PublicKeyStatus, PublicKeyType, TelegramAuthResponse, TPregenIdentifierType, VerificationEmailProps, WalletEntity, WalletParams, WalletScheme, WalletType } from './types/index.js';
+interface ConfigOpts {
+    useFetchAdapter?: boolean;
+}
+type ClientConfig = {
+    userManagementHost: string;
+    version?: string;
+    partnerId?: string;
+    apiKey?: string;
+    opts?: ConfigOpts;
+    retrieveSessionCookie?: () => string | undefined;
+    persistSessionCookie?: (cookie: string) => void;
+};
+interface createUserBody {
+    email: string;
+}
+interface createUserBodyForPhone {
+    phone: string;
+    countryCode: string;
+}
+interface ExternalWalletLoginBody {
+    externalAddress: string;
+    type: 'EVM' | 'SOLANA' | 'COSMOS';
+    externalWalletProvider?: string;
+}
+interface ExternalWalletLoginRes {
+    userId: string;
+}
+interface createUserIdRes {
+    protocolId: string;
+    userId: string;
+}
+interface verifyBody {
+    verificationCode: string;
+}
+interface getWebChallengeRes {
+    challenge: string;
+    allowedPublicKeys?: string[];
+}
+interface sessionPublicKeyBody {
+    publicKey?: string;
+    sigDerivedPublicKey?: string;
+    status?: PublicKeyStatus;
+    type?: PublicKeyType;
+    cosePublicKey?: string;
+    clientDataJSON?: string;
+    aaguid?: string;
+}
+interface WebSignature {
+    clientDataJSON: string;
+    authenticatorData: string;
+    signature: string;
+}
+interface MobileSignature {
+    r: string;
+    s: string;
+    recoveryParam: number;
+}
+type verifyWebChallengeBody = {
+    sessionLookupId?: string;
+    signature: WebSignature;
+    publicKey: string;
+    newDeviceSessionLookupId?: string;
+};
+type verifyPasswordChallengeBody = {
+    sessionLookupId?: string;
+    signature: string;
+    publicKey: string;
+    newDeviceSessionLookupId?: string;
+};
+interface verifySessionChallengeBody {
+    signature: MobileSignature | WebSignature;
+    publicKey?: string;
+}
+interface GetWalletsRes {
+    wallets: WalletEntity[];
+}
+interface PasswordEntity {
+    id: string;
+    userId: string;
+    status: PasswordStatus;
+    sigDerivedPublicKey: string;
+    salt: string;
+}
+interface createWalletBody {
+    useTwoSigners?: boolean;
+    scheme: WalletScheme;
+    type: WalletType;
+    cosmosPrefix?: string;
+}
+interface updatePregenWalletBody {
+    pregenIdentifier: string;
+    pregenIdentifierType: TPregenIdentifierType;
+}
+interface createWalletRes {
+    protocolId: string;
+    walletId: string;
+}
+interface createWalletPreGenBody {
+    pregenIdentifier: string;
+    pregenIdentifierType: TPregenIdentifierType;
+    scheme?: WalletScheme;
+    type: WalletType;
+    cosmosPrefix?: string;
+}
+interface claimPreGenWalletsBody {
+    userId: string;
+    walletIds: string[];
+}
+interface signTransactionBody {
+    transaction: string;
+    chainId: string;
+}
+interface sendTransactionBody {
+    transaction: string;
+    chain?: Chain;
+    chainId?: string;
+}
+interface AcceptScopesBody {
+    scopeIds: string[];
+    partnerId: string;
+}
+interface sessionPasswordBody {
+    status?: PasswordStatus;
+    sigDerivedPublicKey?: string;
+    salt?: string;
+}
+type BiometricLocationHintParams = AuthParams;
+export type VerifyTelegramRes = {
+    isValid: true;
+    userId: string;
+    telegramUserId: string;
+    isNewUser: boolean;
+    biometricHints?: BiometricLocationHint[];
+    supportedAuthMethods: AuthMethod[];
+} | {
+    isValid: false;
+};
+export declare const handleResponseSuccess: (response: AxiosResponse<any, any>) => AxiosResponse<any, any>;
+export declare const handleResponseError: (error: any) => never;
+declare class Client {
+    private baseRequest;
+    constructor({ userManagementHost, apiKey, partnerId, version, opts, retrieveSessionCookie, persistSessionCookie, }: ClientConfig);
+    createUser: (body: (createUserBody | createUserBodyForPhone) & VerificationEmailProps) => Promise<createUserIdRes>;
+    checkUserExists: (auth: Auth<"email" | "phone">) => Promise<any>;
+    verifyTelegram: (authObject: TelegramAuthResponse) => Promise<VerifyTelegramRes>;
+    externalWalletLogin: (body: ExternalWalletLoginBody) => Promise<ExternalWalletLoginRes>;
+    verifyEmail: (userId: string, body: verifyBody) => Promise<any>;
+    verifyPhone: (userId: string, body: verifyBody) => Promise<any>;
+    addSessionPublicKey: (userId: string, body: sessionPublicKeyBody) => Promise<any>;
+    getSessionPublicKeys: (userId: string) => Promise<any>;
+    getBiometricLocationHints: (params: BiometricLocationHintParams) => Promise<BiometricLocationHint[]>;
+    getSessionPublicKey: (userId: string, biometricId: string) => Promise<any>;
+    patchSessionPublicKey: (partnerId: string, userId: string, biometricId: string, body: sessionPublicKeyBody) => Promise<any>;
+    getWebChallenge: (auth?: Auth) => Promise<getWebChallengeRes>;
+    touchSession: (regenerate?: boolean) => Promise<any>;
+    sessionOrigin: (sessionLookupId: string) => Promise<{
+        origin?: string;
+    }>;
+    verifyWebChallenge: (partnerId: string, body: verifyWebChallengeBody) => Promise<any>;
+    getSessionChallenge: (userId: string) => Promise<any>;
+    verifySessionChallenge: (userId: string, body: verifySessionChallengeBody) => Promise<any>;
+    createWallet: (userId: string, body?: createWalletBody) => Promise<createWalletRes>;
+    createWalletPreGen: (body?: createWalletPreGenBody) => Promise<createWalletRes>;
+    getPregenWallets: <ReturnType = {
+        wallets: WalletEntity[];
+    }>(pregenIds: PregenIds, isPortal?: boolean, userId?: string) => Promise<ReturnType>;
+    claimPregenWallets: <ReturnType = {
+        walletIds?: string[];
+    }>(body?: claimPreGenWalletsBody) => Promise<ReturnType>;
+    sendTransaction: (userId: string, walletId: string, body: sendTransactionBody) => Promise<any>;
+    signTransaction: (userId: string, walletId: string, body: signTransactionBody) => Promise<any>;
+    refreshKeys: (userId: string, walletId: string, oldPartnerId?: string, newPartnerId?: string, keyShareProtocolId?: string) => Promise<any>;
+    updatePregenWallet: (walletId: string, body: updatePregenWalletBody) => Promise<any>;
+    getWallets: (userId: string, includePartnerData?: boolean) => Promise<AxiosResponse<GetWalletsRes, any>>;
+    getAllWallets: (userId: string) => Promise<AxiosResponse<GetWalletsRes, any>>;
+    setCurrentWalletIds: (userId: string, walletIds: CurrentWalletIds, needsWallet?: boolean, sessionLookupId?: string, newDeviceSessionLookupId?: string) => Promise<any>;
+    login: (props: {
+        email: string;
+    } & VerificationEmailProps) => Promise<any>;
+    verifyLogin: (verificationCode: string) => Promise<any>;
+    logout: () => Promise<any>;
+    recoveryVerification: (email: string, verificationCode: string) => Promise<any>;
+    recoveryInit: (email: string) => Promise<any>;
+    preSignMessage: (userId: string, walletId: string, message: string, scheme?: WalletScheme, cosmosSignDoc?: string) => Promise<any>;
+    deleteSelf: (userId: string) => Promise<any>;
+    uploadKeyshares(userId: string, walletId: string, encryptedKeyshares: EncryptedKeyShare[]): Promise<any>;
+    uploadUserKeyShares(userId: string, encryptedKeyshares: (EncryptedKeyShare & {
+        walletId: string;
+    })[]): Promise<any>;
+    getKeyshare(userId: string, walletId: string, type: KeyShareType, encryptor?: EncryptorType): Promise<any>;
+    getBiometricKeyshares(userId: string, biometricPublicKey: string, getAll?: boolean): Promise<any>;
+    getPasswordKeyshares(userId: string, passwordId: string, getAll?: boolean): Promise<any>;
+    uploadTransmissionKeyshares(userId: string, shares: {
+        walletId: string;
+        encryptedShare: string;
+        encryptedKey?: string;
+        sessionLookupId: string;
+    }[]): Promise<any>;
+    getTransmissionKeyshares(userId: string, sessionLookupId: string): Promise<any>;
+    getParaShare: (userId: string, walletId: string) => Promise<string>;
+    getBackupKit: (userId: string) => Promise<any>;
+    resendVerificationCode({ userId, ...rest }: {
+        userId: string;
+    } & VerificationEmailProps): Promise<AxiosResponse<any, any>>;
+    resendVerificationCodeByPhone({ userId, ...rest }: {
+        userId: string;
+    } & VerificationEmailProps): Promise<AxiosResponse<any, any>>;
+    cancelRecoveryAttempt(email: string): Promise<AxiosResponse<any, any>>;
+    check2FAStatus(userId: string): Promise<AxiosResponse<any, any>>;
+    enable2FA(userId: string, verificationCode: string): Promise<AxiosResponse<any, any>>;
+    setup2FA(userId: string): Promise<AxiosResponse<any, any>>;
+    initializeRecovery(email: string): Promise<AxiosResponse<any, any>>;
+    initializeFarcasterLogin(): Promise<AxiosResponse<any, any>>;
+    getFarcasterAuthStatus(): Promise<AxiosResponse<any, any>>;
+    initializeRecoveryForPhone(phone: string, countryCode: string): Promise<AxiosResponse<any, any>>;
+    finalizeRecovery(userId: string, walletId: string): Promise<AxiosResponse<any, any>>;
+    recoverUserShares(userId: string, walletId: string): Promise<AxiosResponse<{
+        keyShare: {
+            encryptedShare: string;
+            encryptedKey?: string;
+            type: string;
+            walletId: string;
+        };
+        keyShares: {
+            encryptedShare: string;
+            encryptedKey?: string;
+            type: string;
+            walletId: string;
+        }[];
+    }, any>>;
+    verifyEmailForRecovery(email: string, verificationCode: string): Promise<AxiosResponse<any, any>>;
+    verifyPhoneForRecovery(phone: string, countryCode: string, verificationCode: string): Promise<AxiosResponse<any, any>>;
+    verify2FA(email: string, verificationCode: string): Promise<AxiosResponse<any, any>>;
+    verify2FAForPhone(phone: string, countryCode: string, verificationCode: string): Promise<AxiosResponse<any, any>>;
+    tempTrasmissionInit(message: string, userId?: string): Promise<AxiosResponse<any, any>>;
+    tempTrasmission(id: string): Promise<AxiosResponse<any, any>>;
+    getPartner(partnerId: string): Promise<AxiosResponse<any, any>>;
+    acceptScopes(userId: string, walletId: string, body: AcceptScopesBody): Promise<AxiosResponse<any, any>>;
+    getPendingTransaction(userId: string, pendingTransactionId: string): Promise<AxiosResponse<any, any>>;
+    acceptPendingTransaction(userId: string, pendingTransactionId: string): Promise<AxiosResponse<any, any>>;
+    getOnRampConfig(): Promise<OnRampConfig>;
+    createOnRampPurchase({ userId, params: { type, walletType, address, provider, networks, assets, defaultNetwork, defaultAsset, fiat, fiatQuantity, testMode, }, ...params }: {
+        userId: string;
+        params: OnRampPurchaseCreateParams;
+    } & WalletParams): Promise<OnRampPurchase>;
+    updateOnRampPurchase({ userId, purchaseId, updates, ...params }: {
+        userId: string;
+        purchaseId: string;
+        updates: OnRampPurchaseUpdateParams;
+    } & WalletParams): Promise<OnRampPurchase>;
+    getOnRampPurchase({ userId, purchaseId, ...params }: {
+        userId: string;
+        purchaseId: string;
+    } & WalletParams): Promise<AxiosResponse<OnRampPurchase, any>>;
+    signMoonPayUrl(userId: string, { url, type, cosmosPrefix, testMode, walletId, externalWalletAddress, }: {
+        url: string;
+        type: WalletType;
+        cosmosPrefix: string;
+        testMode?: boolean;
+        walletId?: string;
+        externalWalletAddress?: string;
+    }): Promise<AxiosResponse<{
+        signature: string;
+    }, any>>;
+    generateOffRampTx<ReturnType = {
+        tx: string;
+        asset: OnRampAsset;
+        network: Network;
+    }>(userId: string, { provider, chainId, contractAddress, testMode, walletId, walletType, destinationAddress, sourceAddress, assetQuantity, }: {
+        provider: OnRampProvider;
+        chainId: string;
+        contractAddress?: string;
+        testMode?: boolean;
+        walletId: string;
+        walletType: WalletType;
+        destinationAddress: string;
+        sourceAddress?: string;
+        assetQuantity: string | number;
+    }): Promise<ReturnType>;
+    sendOffRampTx<ReturnType = {
+        txHash: string;
+    }>(userId: string, { tx, signature, network, walletId, walletType, }: {
+        tx: string;
+        signature: string;
+        network: Network;
+        walletId: string;
+        walletType: WalletType;
+    }): Promise<ReturnType>;
+    distributeParaShare({ userId, walletId, ...rest }: {
+        userId: string;
+        walletId: string;
+        useDKLS: boolean;
+    } & BackupKitEmailProps): Promise<AxiosResponse<any, any>>;
+    keepSessionAlive(userId: string): Promise<any>;
+    persistRecoveryPublicKeys(userId: string, publicKeys: string[]): Promise<{
+        recoveryPublicKeys: {
+            id: string;
+            publicKey: string;
+        }[];
+    }>;
+    getRecoveryPublicKeys(userId: string): Promise<{
+        recoveryPublicKeys: {
+            id: string;
+            publicKey: string;
+        }[];
+    }>;
+    uploadEncryptedWalletPrivateKey(userId: string, encryptedWalletPrivateKey: string, encryptionKeyHash: string, biometricPublicKey?: string, passwordId?: string): Promise<any>;
+    getEncryptedWalletPrivateKeys(userId: string, encryptionKeyHash: string): Promise<any>;
+    getConversionRate(chainId: string, symbol: string, currency: string): Promise<any>;
+    getGasEstimate(chainId: string, totalGasPrice: string): Promise<any>;
+    getGasOracle(chainId: string): Promise<any>;
+    isRefreshDone(userId: string, walletId: string, partnerId?: string, protocolId?: string): Promise<{
+        isDone: true;
+    }>;
+    deletePendingTransaction(userId: string, pendingTransactionId: string): Promise<any>;
+    addSessionPasswordPublicKey(userId: string, body: sessionPasswordBody): Promise<any>;
+    patchSessionPassword: (partnerId: string, userId: string, passwordId: string, body: sessionPasswordBody) => Promise<any>;
+    getSupportedAuthMethods(auth: Auth): Promise<any>;
+    getPasswords(auth: Auth): Promise<PasswordEntity[]>;
+    verifyPasswordChallenge(partnerId: string, body: verifyPasswordChallengeBody): Promise<any>;
+    getEncryptedWalletPrivateKey(passwordId: string): Promise<any>;
+    getUser(userId: string): Promise<any>;
+}
+export default Client;

package/dist/types/consts.d.ts

@@ -0,0 +1,4 @@
+export declare const SESSION_COOKIE_HEADER_NAME = "x-capsule-sid";
+export declare const VERSION_HEADER_NAME = "x-capsule-version";
+export declare const PARTNER_ID_HEADER_NAME = "x-partner-id";
+export declare const API_KEY_HEADER_NAME = "X-External-API-Key";

package/dist/types/error.d.ts

@@ -0,0 +1 @@
+export declare function ParaApiError(message: string, code?: string, status?: number, responseURL?: string): void;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client.js';
+export * from './types/index.js';
+export * from './utils.js';
+import Client from './client.js';
+export default Client;