@tomo-inc/cubist-wallet-sdk 0.0.6 → 0.0.8

package/dist/index.d.cts

@@ -0,0 +1,422 @@
+import { CubeSignerClient as CubeSignerClient$1, SessionData } from '@cubist-labs/cubesigner-sdk';
+export { SessionData } from '@cubist-labs/cubesigner-sdk';
+import { TomoStage, CubeStage } from '@tomo-inc/wallet-utils';
+import { TypedData } from '@tomo-inc/cubist-sig-sdk';
+
+type MfaType = "fido" | "emailOtp" | "totp";
+type SeedPhrase = any;
+interface MfaInfo {
+    success?: boolean;
+    message?: string;
+    data?: any;
+    error?: string;
+    id: string;
+    name: string;
+    type: MfaType;
+    status: {
+        allowed_approvers: string[];
+        allowed_mfa_types: string[];
+        approved_by: any;
+        count: number;
+        num_auth_factors: 1;
+    };
+    created_at: number;
+    created_by: string;
+    expires_at: number;
+    provenance: string;
+    receipt: any;
+    related_ids: string[];
+    request: {
+        body: any;
+        method: "DELETE" | "POST" | "PUT" | "DELETE" | "GET";
+        path: string;
+    };
+    verifyStatus?: "pending" | "approved" | "rejected";
+    mfaRequired?: {
+        fido: boolean;
+        totp: boolean;
+        emailOtp: boolean | number;
+        emailOtpRemainTime: number;
+    } | null;
+}
+type BizType = "createSession" | "addFido" | "deleteFido" | "registerTotp" | "registerEmailOtp" | "deleteTotp" | "initExport" | "completeExport";
+interface MfaReceipt {
+    mfaId: string;
+    mfaConf: string;
+    mfaOrgId: string;
+}
+type MfaRequest = any;
+interface MfaAnswer {
+    totpCode?: string;
+    email?: string;
+    emailCode?: string;
+}
+interface MfaVerifyResult {
+    success: boolean;
+    receipt: any;
+    error?: any;
+}
+interface MfaFinishResult {
+    success: boolean;
+    error?: any;
+}
+type AccountType = "google" | "x" | "email";
+interface CubeAccount {
+    userId: string;
+    name: string;
+    email: string;
+    otpEmail: string;
+    accountType: AccountType;
+}
+interface MfaConfig {
+    noMfa: boolean;
+    hasMfa: boolean;
+    account: CubeAccount;
+    emailOtp: {
+        data: string;
+        enabled: boolean;
+    };
+    fido: {
+        data: FidoKey[];
+        enabled: boolean;
+    };
+    totp: {
+        data: any;
+        enabled: boolean;
+    };
+}
+type OidcSessionResp = any;
+type CubeSignerClient = any;
+type ApiClient = any;
+interface CubeUserInfo {
+    user_id: string;
+    mfa: FidoKey[];
+    name?: string;
+    email?: string;
+    org_ids?: string[];
+    orgs?: any[];
+    verified_email?: {
+        email?: string;
+        updated_at?: number;
+    };
+}
+interface TotpInfo {
+    id: string;
+    url: string;
+    secret: string;
+    issuer: string;
+}
+interface FidoKey {
+    type: string;
+    id: string;
+    name: string;
+    updated_at: string;
+    status: string;
+    user_id: string;
+    discoverable: boolean;
+    created_at: number;
+    last_used_at: number;
+    aaguid: string;
+}
+interface CubeIdentity {
+    id: string;
+    preferred_username?: string;
+    aud?: any;
+    email?: string;
+    identity?: {
+        iss: string;
+        sub: string;
+    };
+    user_info?: {
+        user_id?: string;
+        initialized?: boolean;
+        configured_mfa?: any[];
+    };
+    exp_epoch?: number;
+}
+interface SeedPhraseExportInfo {
+    ready: boolean;
+    keyId?: string;
+    lastTime?: number;
+    duration?: number;
+    valid_epoch?: number;
+    exp_epoch?: number;
+}
+interface CubeRes {
+    success: boolean;
+    error?: any;
+    data?: any;
+    message?: string;
+}
+interface Mfa {
+    created_at?: number;
+    created_by: string;
+    expires_at: number;
+    id: string;
+    not_valid_until?: number;
+    provenance: "EditPolicy" | "Key" | "Role" | "KeyInRole" | "User";
+    receipt?: {
+        confirmation: string;
+        final_approver: string;
+        timestamp: number;
+    };
+    related_ids?: string[];
+    request: {
+        body?: Record<string, unknown>;
+        method: string;
+        path: string;
+    };
+    status: {
+        allowed_approvers: string[];
+        allowed_mfa_types?: string[];
+        approved_by: {
+            [key: string]: object;
+        };
+        count: number;
+        num_auth_factors: number;
+        request_comparer?: "Eq" | {
+            EvmTx: {
+                grace?: number;
+                ignore_gas?: boolean;
+                ignore_nonce?: boolean;
+            };
+        } | {
+            SolanaTx: {
+                ignore_blockhash?: boolean;
+            };
+        };
+    };
+}
+interface UserToken {
+    accessToken: string;
+    refreshToken: string;
+    expireTime: number;
+}
+interface User {
+    userId: string;
+    userID?: string;
+    accountID?: string;
+    tenantID?: string;
+    username?: string;
+    nickname: string;
+    avatar: string;
+    freePasswordAuth?: string;
+    forbidden?: boolean;
+    deleted?: boolean;
+}
+interface UserAddressType {
+    bitcoinP2pkhAddress: string;
+    bitcoinP2trAddress: string;
+    bitcoinP2shAddress: string;
+    bitcoinP2wpkhAddress: string;
+    ethereumAddress: string;
+    solanaAddress: string;
+    tronAddress: string;
+    tonAddressTest: string;
+    tonAddress: string;
+    tonPublicKey: string;
+    suiAddress: string;
+}
+interface LoginRes {
+    userToken?: UserToken;
+    user: User;
+    accountBaseInfo: any;
+    accountWallet: any;
+    walletId?: string;
+}
+declare enum LoginError {
+    FIDO_NOT_ALLOWED = "NotAllowedError",
+    MFA_NOT_APPROVED = "MFA not approved yet",
+    MFA_REQUIRED = "MFA should not be required after approval",
+    OIDC_TOKEN_NOT_FOUND = "Oidc token not found",
+    CUBE_IDENTITY_NOT_FOUND = "Cube identity not found",
+    CUBE_USER_INFO_NOT_FOUND = "Cube user info not found",
+    OIDC_TOKEN_EXPIRED = "ExpiredSignature",
+    FAILED_OPEN_POPUP = "Failed to open popup window",
+    OAUTH_LOGIN_TIMEOUT = "OAuth login timeout",
+    USER_CANCELLED_LOGIN = "User cancelled login"
+}
+interface CubeConfig {
+    rpId?: string;
+    tomoStage: TomoStage;
+    cubeSalt?: string;
+    cubeStage?: CubeStage;
+    tomoClientId: string;
+    jwtToken?: string;
+    oidcToken?: string;
+    name?: string;
+    logo?: string;
+}
+interface CubeConnectResult {
+    walletId: string;
+    session: object;
+    accountWallet: Record<string, any>;
+    token: object;
+    user: Record<string, any>;
+}
+
+declare class CubeMfaService {
+    private static instance;
+    private cubeAccountService;
+    cubeSignerClient: CubeSignerClient$1 | null;
+    apiClient: ApiClient;
+    private mfaType;
+    private mfaAnswer;
+    private mfaChallenge;
+    private registerChallenge;
+    constructor();
+    static getInstance(): CubeMfaService;
+    init(cubeAccountService: CubeAccountService): this;
+    setMfaType(mfaType: MfaType): void;
+    setMfaAnswer(mfaAnswer: MfaAnswer): void;
+    getMfaInfo(bizType?: BizType): Promise<MfaInfo | null>;
+    answerRegister(code: string): Promise<CubeRes>;
+    executeBizWithMfa(bizType: BizType, mfaInfo?: MfaInfo | null): Promise<CubeRes>;
+    approvalMfa(mfaId: string): Promise<CubeRes>;
+    private getPasskeyConfig;
+    passkeyClear(): void;
+    addFido(fidoName: string, receipt?: MfaReceipt): Promise<any>;
+    addFidoLocal(fidoName: string, receipt?: MfaReceipt): Promise<MfaInfo | null | boolean>;
+    deleteFido(fidoId: string, receipt?: MfaReceipt): Promise<MfaInfo | null>;
+    approvalFido(mfaId: string): Promise<MfaReceipt>;
+    approvalFidoLocal(mfaId: string): Promise<MfaReceipt>;
+    registerTotp(issuer: string, receipt?: MfaReceipt): Promise<MfaInfo | TotpInfo | null>;
+    deleteTotp(receipt?: MfaReceipt): Promise<MfaInfo | null>;
+    approvalTotp(mfaId: string): Promise<MfaReceipt>;
+    registerEmailOtp(email: string, receipt?: MfaReceipt): Promise<MfaInfo | null>;
+    approvalEmailOtp(mfaId: string): Promise<MfaReceipt | null>;
+    sendEmailCode(mfaId: string): Promise<boolean>;
+}
+
+declare class CubeSignService {
+    private static instance;
+    private cubeSession;
+    private services;
+    init({ cubeSession }: {
+        cubeSession: any;
+    }): Promise<void>;
+    static getInstance(): CubeSignService;
+    /**
+     * Get specific services by chainType and address
+     * @param chainType Chain type (EVM, TRON, SOL, DOGE)
+     * @param address Wallet address
+     * @returns The matching services object or null if not found
+     */
+    getServiceByChainAndAddress(chainType: string, address: string): Promise<any>;
+    /**
+     * Build key ID from chainType and address following the pattern in the services data
+     * @param chainType Chain type
+     * @param address Wallet address
+     * @returns Key ID string
+     */
+    private buildKeyId;
+    /**
+     * Unified transaction signing method for all supported chains
+     * @param chainType Chain type (EVM, SOL, DOGE, TRON, BTC)
+     * @param address User's wallet address
+     * @param params Signing parameters specific to each chain (always JSON stringified from social account)
+     * @returns Signed transaction
+     */
+    signTransaction(chainType: string, address: string, params: any): Promise<string>;
+    /**
+     * Unified message signing method for all supported chains
+     * @param chainType Chain type (EVM, SOL, DOGE, TRON)
+     * @param address User's wallet address
+     * @param message Message to be signed
+     * @returns Message signature
+     */
+    signMessage(chainType: string, address: string, message: string): Promise<string>;
+    /**
+     * Unified typed data signing method (supports EVM and TRON)
+     * @param chainType Chain type (EVM, TRON)
+     * @param address User's wallet address
+     * @param typedData Typed data to be signed
+     * @returns Typed data signature
+     */
+    signTypedData(chainType: string, address: string, typedData: TypedData): Promise<string>;
+}
+
+declare class CubeAccountService {
+    config: CubeConfig;
+    private static instance;
+    private jwtToken;
+    accountData: any;
+    cubeUserInfo: CubeUserInfo | null;
+    cubeIdentity: CubeIdentity | null;
+    private cubeSession;
+    cubeSignerClient: CubeSignerClient$1 | null;
+    apiClient: ApiClient | null;
+    cubeMfaService: CubeMfaService | null;
+    cubeExportService: CubeExportService | null;
+    accountWallet: any;
+    cubeEnv: any;
+    cubeOrgId: string;
+    constructor(config: CubeConfig);
+    static getInstance(config?: CubeConfig): CubeAccountService;
+    getCubeIdentity(): Promise<CubeIdentity | null>;
+    loginOrRegister(oidcToken: string, options?: any): Promise<LoginRes>;
+    updateUserInfo(userInfo: {
+        nickname: string;
+        avatar: `https://${string}`;
+    }): Promise<boolean>;
+    createSessionByOidcToken(oidcToken: string): Promise<boolean>;
+    createSession(receipt?: MfaReceipt): Promise<MfaInfo | null | SessionData>;
+    refreshSession(): Promise<boolean>;
+    getCubeSession(): SessionData | null;
+    private setCubeSession;
+    sessionRevoke(): void;
+    private refreshCubeClient;
+    private createCubeSignerClient;
+    getOidcClient(receipt?: MfaReceipt): Promise<any>;
+    private autoLogin;
+    init(oidcToken?: string): Promise<boolean>;
+    initSubServices(): Promise<void>;
+    initCubeSignService(): Promise<CubeSignService>;
+    getCubeUserInfo(): Promise<CubeUserInfo | null>;
+    getMfaConfig(): Promise<MfaConfig>;
+}
+
+declare class CubeExportService {
+    private static instance;
+    private cubeAccountService;
+    private cubeSignerClient;
+    private seedPhraseKey;
+    private exportKey;
+    constructor();
+    static getInstance(): CubeExportService;
+    init(cubeAccountService: CubeAccountService): this;
+    getExportKey(): Promise<string>;
+    getExportInfo(): Promise<SeedPhraseExportInfo | null>;
+    initExport(receipt?: MfaReceipt): Promise<MfaInfo | null>;
+    completeExport(receipt?: MfaReceipt): Promise<MfaInfo | SeedPhrase | null>;
+    deleteExport(): Promise<CubeRes>;
+}
+
+declare const CubeConnect: (config: CubeConfig) => Promise<{
+    cubeAccount: CubeAccountService;
+    cubeMfa: CubeMfaService | null;
+    cubeExport: CubeExportService | null;
+}>;
+
+declare const SEED_PHRASE_EXPORT_DURATION = 48;
+declare const EXPORT_TIME_FORMAT = "yyyy-MM-dd hh:mm:ss";
+declare const OIDC_TOKEN_LIFETIME: number;
+declare const CUBE_LIFETIME: {
+    auth: number;
+    refresh: number;
+};
+declare const CUBE_SCOPES: string[];
+declare const EXPORT_KEY_PREFIX = "Key#Mnemonic_";
+declare const ISS_MAP: Record<string, AccountType>;
+declare const CUBE_SALTS: {
+    prod: string;
+    pre: string;
+    dev: string;
+};
+declare const getMfaInfoConfig: (cubeStage: CubeStage) => Record<BizType, {
+    method: string;
+    path: string;
+    _allowed_mfa_types: string[];
+}>;
+
+export { type AccountType, type ApiClient, type BizType, CUBE_LIFETIME, CUBE_SALTS, CUBE_SCOPES, type CubeAccount, CubeAccountService, type CubeConfig, CubeConnect, type CubeConnectResult, CubeExportService, type CubeIdentity, CubeMfaService, type CubeRes, CubeSignService, type CubeSignerClient, type CubeUserInfo, EXPORT_KEY_PREFIX, EXPORT_TIME_FORMAT, type FidoKey, ISS_MAP, LoginError, type LoginRes, type Mfa, type MfaAnswer, type MfaConfig, type MfaFinishResult, type MfaInfo, type MfaReceipt, type MfaRequest, type MfaType, type MfaVerifyResult, OIDC_TOKEN_LIFETIME, type OidcSessionResp, SEED_PHRASE_EXPORT_DURATION, type SeedPhrase, type SeedPhraseExportInfo, type TotpInfo, type User, type UserAddressType, type UserToken, getMfaInfoConfig };