@wauth/sdk/dist/index.d.ts

Web2 auth sdk for Arweave

import PocketBase, { type AuthRecord, type RecordAuthResponse, type RecordModel } from "pocketbase";
import type { GatewayConfig, PermissionType } from "arconnect";
import Transaction from "arweave/web/lib/transaction";
import type { SignatureOptions } from "arweave/web/lib/crypto/crypto-interface";
import { type DataItem as ArConnectDataItem } from "arconnect";
export declare enum WAuthProviders {
    Google = "google",
    Github = "github",
    Discord = "discord",
    X = "twitter"
}
export declare enum WalletActions {
    SIGN = "sign",
    ENCRYPT = "encrypt",
    DECRYPT = "decrypt",
    DISPATCH = "dispatch",
    SIGN_DATA_ITEM = "signDataItem",
    SIGNATURE = "signature"
}
type ModalTypes = "confirm-tx" | "password-new" | "password-existing";
export type { ModalTypes };
type ModalPayload = {
    transaction?: Transaction;
    dataItem?: ArConnectDataItem;
    tokenDetails?: any;
    errorMessage?: string;
};
export type { ModalPayload };
type ModalResult = {
    proceed: boolean;
    password?: string;
    skipPassword?: boolean;
};
export type { ModalResult };
export declare class WAuth {
    static devUrl: string;
    static devBackendUrl: string;
    static prodUrl: string;
    static prodBackendUrl: string;
    private pb;
    private authData;
    private wallet;
    private authRecord;
    private backendUrl;
    static version: string;
    version: string;
    private authDataListeners;
    private sessionPassword;
    private sessionKey;
    private sessionPasswordLoading;
    private modalInProgress;
    private initializeSessionKey;
    private storePasswordInSession;
    hasSessionStorageData(): boolean;
    private loadPasswordFromSession;
    private clearSessionPassword;
    private clearAllAuthData;
    private isBackendAccessible;
    constructor({ dev, url, backendUrl }: {
        dev?: boolean;
        url?: string;
        backendUrl?: string;
    });
    onAuthDataChange(callback: (data: any) => void): void;
    getEmail(): {
        email: string;
        verified: boolean;
    };
    private runAction;
    createModal(type: ModalTypes, payload: ModalPayload | undefined, callback: (result: ModalResult) => void): Promise<void>;
    connect({ provider, scopes }: {
        provider: WAuthProviders;
        scopes?: string[];
    }): Promise<RecordAuthResponse<RecordModel> | null>;
    private checkExistingWallet;
    private verifyPassword;
    private verifyAndStorePassword;
    addConnectedWallet(address: string, pkey: string, signature: string): Promise<any>;
    isLoggedIn(): boolean;
    getActiveAddress(): Promise<string>;
    getActivePublicKey(): Promise<string>;
    getPermissions(): Promise<PermissionType[]>;
    getWalletNames(): Promise<{
        [x: string]: string;
    }>;
    getArweaveConfig(): Promise<GatewayConfig>;
    getAuthData(): RecordAuthResponse<RecordModel> | null;
    getAuthToken(): string | null;
    getWallet(showPasswordModal?: boolean): Promise<RecordModel | null>;
    private createWalletWithoutPassword;
    getConnectedWallets(): Promise<RecordModel[]>;
    removeConnectedWallet(walletId: string): Promise<{
        success: boolean;
        walletId: string;
    }>;
    getAuthRecord(): AuthRecord;
    getUsername(): string | null;
    pocketbase(): PocketBase;
    sign(transaction: Transaction, options?: SignatureOptions): Promise<any>;
    signature(data: Uint8Array, algorithm?: AlgorithmIdentifier | RsaPssParams | EcdsaParams): Promise<Uint8Array>;
    signAns104(dataItem: ArConnectDataItem): Promise<{
        id: string;
        raw: ArrayBuffer;
    }>;
    signDataItem(dataItem: ArConnectDataItem): Promise<ArrayBuffer>;
    getWauthSigner(): WauthSigner;
    getAoSigner(): (create: any, createDataItem: any) => Promise<{
        id: string;
        raw: Buffer<ArrayBufferLike>;
    }>;
    hasSessionPassword(): boolean;
    isSessionPasswordLoading(): boolean;
    hasStoredSessionData(): boolean;
    refreshWallet(): Promise<void>;
    logout(): void;
}
export declare class WauthSigner {
    private wauth;
    publicKey: Buffer;
    ownerLength: number;
    signatureLength: number;
    signatureType: number;
    constructor(wauth: WAuth);
    setPublicKey(): Promise<void>;
    sign(message: Uint8Array): Promise<Uint8Array>;
    static verify(pk: string | Buffer, message: Uint8Array, signature: Uint8Array): Promise<boolean>;
}
//# sourceMappingURL=index.d.ts.map