@keplr-ewallet/ewallet-sdk-core/dist/index.d.ts

import { Result } from '@keplr-ewallet/stdlib-js';
import { FeeCurrency, AppCurrency, Bech32Config, BIP44, EVMInfo, KeplrSignOptions, ChainInfo } from '@keplr-wallet/types';
import { StdSignDoc, StdSignature } from '@cosmjs/amino';
import { RpcTransactionRequest, SignableMessage, Hex } from 'viem';

type EventType = {
    type: string;
    [key: string]: any;
};
type EventHandlerType = {
    type: string;
    handler: (payload: any) => void;
};
type EventEmitError = {
    type: "handle_error";
    error: string;
} | {
    type: "handler_not_found";
    event_type: string;
};

declare class EventEmitter3<E extends EventType, H extends EventHandlerType> {
    listeners: {
        [K in E["type"]]?: H["handler"][];
    };
    constructor();
    on<T extends E["type"]>(handlerDef: H): void;
    emit<T extends E["type"]>(event: E): Result<void, EventEmitError>;
    off<T extends E["type"]>(handlerDef: H): void;
}

interface AccountsChangedPayload {
    email: string | null;
    publicKey: string | null;
}
type KeplrEWalletCoreEvent2 = {
    type: "CORE__accountsChanged";
    email: string | null;
    publicKey: string | null;
} | {
    type: "CORE__chainChanged";
};
type KeplrEWalletCoreEventHandler2 = {
    type: "CORE__accountsChanged";
    handler: (payload: AccountsChangedPayload) => void;
} | {
    type: "CORE__chainChanged";
    handler: (payload: void) => void;
};

interface SignDoc {
    bodyBytes: Uint8Array;
    authInfoBytes: Uint8Array;
    chainId: string;
    accountNumber: bigint;
}

type ChainInfoForAttachedModal = {
    readonly chain_id: string;
    readonly chain_name: string;
    readonly chain_symbol_image_url?: string;
    readonly rpc_url: string;
    readonly rest_url?: string;
    readonly block_explorer_url?: string;
    readonly fee_currencies?: FeeCurrency[];
    readonly currencies?: AppCurrency[];
    readonly bech32_config?: Bech32Config;
    readonly bip44?: BIP44;
    readonly features?: string[];
    readonly evm?: EVMInfo;
};

type MakeSigError = {
    type: "api_key_not_found";
} | {
    type: "key_share_not_combined";
} | {
    type: "wallet_not_found";
} | {
    type: "jwt_not_found";
} | MakeSignOutputError;
type MakeSignOutputError = RunTriplesError | RunSignError | RunPresignError;
type RunTriplesError = {
    type: "aborted";
} | {
    type: "triples_fail";
    error: any;
};
type RunSignError = {
    type: "aborted";
} | {
    type: "sign_fail";
    error: any;
};
type RunPresignError = {
    type: "aborted";
} | {
    type: "presign_fail";
    error: any;
};

type MakeCosmosSigData = CosmosTxSigData | CosmosArbitrarySigData;
interface MakeCosmosSigModalResult {
    chain_type: "cosmos";
    sig_result: MakeCosmosSigResult;
}
interface CosmosTxSigData {
    chain_type: "cosmos";
    sign_type: "tx";
    payload: CosmosTxSignPayload;
}
interface CosmosArbitrarySigData {
    chain_type: "cosmos";
    sign_type: "arbitrary";
    payload: CosmosArbitrarySignPayload;
}
type CosmosTxSignPayload = CosmosTxSignDirectPayload | CosmosTxSignAminoPayload;
interface CosmosTxSignDirectPayload {
    origin: string;
    chain_info: ChainInfoForAttachedModal;
    signer: string;
    signDoc: SignDoc;
    signOptions?: KeplrSignOptions;
}
interface CosmosTxSignAminoPayload {
    origin: string;
    chain_info: ChainInfoForAttachedModal;
    signer: string;
    signDoc: StdSignDoc;
    signOptions?: KeplrSignOptions;
}
type CosmosArbitrarySignPayload = {
    chain_info: ChainInfoForAttachedModal;
    signer: string;
    data: string | Uint8Array;
    signDoc: StdSignDoc;
    origin: string;
};
type MakeCosmosSigResult = {
    signature: StdSignature;
    signed: StdSignDoc | SignDoc;
};
type MakeCosmosSigError = {
    type: "unknown_error";
    error: any;
} | {
    type: "sign_doc_parse_fail";
    error: any;
} | {
    type: "sign_doc_extract_fail";
    error: any;
} | MakeSigError;

interface MakeEthSigModalResult {
    chain_type: "eth";
    sig_result: MakeEthereumSigResult;
}
type MakeEthereumSigData = MakeTxSignSigData | MakeArbitrarySigData | MakeEIP712SigData;
interface MakeTxSignSigData {
    chain_type: "eth";
    sign_type: "tx";
    payload: EthereumTxSignPayload;
}
interface MakeArbitrarySigData {
    chain_type: "eth";
    sign_type: "arbitrary";
    payload: EthereumArbitrarySignPayload;
}
interface MakeEIP712SigData {
    chain_type: "eth";
    sign_type: "eip712";
    payload: EthereumEip712SignPayload;
}
type MakeEthereumSigResult = EthereumTxSignResult;
type EthereumTxSignResult = {
    type: "signed_transaction";
    signedTransaction: Hex;
} | {
    type: "signature";
    signature: Hex;
};
type EthereumTxSignPayload = {
    origin: string;
    chain_info: ChainInfoForAttachedModal;
    signer: string;
    data: {
        transaction: RpcTransactionRequest;
    };
};
type EthereumArbitrarySignPayload = {
    origin: string;
    chain_info: ChainInfoForAttachedModal;
    signer: string;
    data: {
        message: SignableMessage;
    };
};
type EthereumEip712SignPayload = {
    origin: string;
    chain_info: ChainInfoForAttachedModal;
    signer: string;
    data: {
        version: "4";
        serialized_typed_data: string;
    };
};
type MakeEthSigError = {
    type: "unknown_error";
    error: any;
} | {
    type: "not_signable_tx";
} | {
    type: "chain_not_supported";
    data: {
        chain_id: string;
        chain_name: string;
        chain_symbol_image_url?: string;
    };
} | MakeSigError;

type MakeSigModalPayload = {
    modal_type: "cosmos/make_signature";
    modal_id: string;
    data: MakeCosmosSigData;
} | {
    modal_type: "eth/make_signature";
    modal_id: string;
    data: MakeEthereumSigData;
};
type MakeSigModalApproveAckPayload = {
    modal_type: "cosmos/make_signature";
    modal_id: string;
    type: "approve";
    data: MakeCosmosSigModalResult;
} | {
    modal_type: "eth/make_signature";
    modal_id: string;
    type: "approve";
    data: MakeEthSigModalResult;
};
type MakeSigModalRejectAckPayload = {
    modal_type: "eth/make_signature";
    modal_id: string;
    type: "reject";
} | {
    modal_type: "cosmos/make_signature";
    modal_id: string;
    type: "reject";
};
type MakeSigModalErrorAckPayload = {
    modal_type: "eth/make_signature";
    modal_id: string;
    type: "error";
    error: MakeEthSigError;
} | {
    modal_type: "cosmos/make_signature";
    modal_id: string;
    type: "error";
    error: MakeCosmosSigError;
};

interface OtherModalPayload {
    modal_type: "other";
    modal_id: string;
    data: {};
}
type OtherModalApproveAckPayload = {
    modal_type: "other";
    modal_id: string;
    type: "approve";
    data: any;
};
type OtherModalRejectAckPayload = {
    modal_type: "other";
    modal_id: string;
    type: "reject";
};
type OtherModalErrorAckPayload = {
    modal_type: "other";
    modal_id: string;
    type: "error";
    error: OtherModalError;
};
type OtherModalError = {
    type: "unknown_error";
    error: any;
} | {
    type: "data_null";
    original_modal_type: string;
};

type OpenModalPayload = MakeSigModalPayload | OtherModalPayload;
type OpenModalAckPayload = MakeSigModalApproveAckPayload | MakeSigModalRejectAckPayload | MakeSigModalErrorAckPayload | OtherModalApproveAckPayload | OtherModalRejectAckPayload | OtherModalErrorAckPayload;

type InitPayload = {
    email: string | null;
    public_key: string | null;
};

type OAuthSignInError = {
    type: "origin_not_registered";
} | {
    type: "key_share_combine_fail";
    error: string;
} | {
    type: "check_user_request_fail";
    error: string;
} | {
    type: "sign_in_request_fail";
    error: string;
} | {
    type: "nonce_missing";
} | {
    type: "active_nodes_below_threshold";
} | {
    type: "signup_not_ready";
} | {
    type: "reshare_not_ready";
} | {
    type: "reshare_fail";
    error: string;
} | {
    type: "invalid_msg_type";
    msg_type: string;
} | {
    type: "vendor_token_verification_failed";
} | {
    type: "api_key_missing";
} | {
    type: "unknown";
    error: string;
};

type OAuthState = {
    apiKey: string;
    targetOrigin: string;
};
declare enum RedirectUriSearchParamsKey {
    STATE = "state"
}
interface OAuthPayload {
    access_token: string;
    id_token: string;
    api_key: string;
    target_origin: string;
}

type EWalletMsgGetPublicKey = {
    target: "keplr_ewallet_attached";
    msg_type: "get_public_key";
    payload: null;
};
type EWalletMsgGetPublicKeyAck = {
    target: "keplr_ewallet_sdk";
    msg_type: "get_public_key_ack";
    payload: Result<string, string>;
};
type EWalletMsgSetOAuthNonce = {
    target: "keplr_ewallet_attached";
    msg_type: "set_oauth_nonce";
    payload: string;
};
type EWalletMsgSetOAuthNonceAck = {
    target: "keplr_ewallet_sdk";
    msg_type: "set_oauth_nonce_ack";
    payload: Result<null, string>;
};
type EWalletMsgOAuthSignInUpdate = {
    target: "keplr_ewallet_sdk";
    msg_type: "oauth_sign_in_update";
    payload: Result<null, OAuthSignInError>;
};
type EWalletMsgOAuthSignInUpdateAck = {
    target: "keplr_ewallet_attached";
    msg_type: "oauth_sign_in_update_ack";
    payload: null;
};
type EWalletMsgOAuthInfoPass = {
    target: "keplr_ewallet_attached";
    msg_type: "oauth_info_pass";
    payload: OAuthPayload;
};
type EWalletMsgOAuthInfoPassAck = {
    target: "keplr_ewallet_attached_popup";
    msg_type: "oauth_info_pass_ack";
    payload: null;
};
type EWalletMsgSignOut = {
    target: "keplr_ewallet_attached";
    msg_type: "sign_out";
    payload: null;
};
type EWalletMsgSignOutAck = {
    target: "keplr_ewallet_sdk";
    msg_type: "sign_out_ack";
    payload: Result<null, string>;
};
type EWalletMsgOpenModal = {
    target: "keplr_ewallet_attached";
    msg_type: "open_modal";
    payload: OpenModalPayload;
};
type EWalletMsgOpenModalAck = {
    target: "keplr_ewallet_sdk";
    msg_type: "open_modal_ack";
    payload: OpenModalAckPayload;
};
type EWalletMsgHideModal = {
    target: "keplr_ewallet_attached";
    msg_type: "hide_modal";
    payload: null;
};
type EWalletMsgHideModalAck = {
    target: "keplr_ewallet_sdk";
    msg_type: "hide_modal_ack";
    payload: Result<null, string>;
};
type EWalletMsgInit = {
    target: "keplr_ewallet_sdk";
    msg_type: "init";
    payload: Result<InitPayload, string>;
};
type EWalletMsgInitAck = {
    target: "keplr_ewallet_attached";
    msg_type: "init_ack";
    payload: Result<null, string>;
};
type EWalletMsgGetEmail = {
    target: "keplr_ewallet_attached";
    msg_type: "get_email";
    payload: null;
};
type EWalletMsgGetEmailAck = {
    target: "keplr_ewallet_sdk";
    msg_type: "get_email_ack";
    payload: Result<string, string>;
};
type EWalletMsgGetCosmosChainInfo = {
    target: "keplr_ewallet_attached";
    msg_type: "get_cosmos_chain_info";
    payload: {
        chain_id: string | null;
    };
};
type EWalletMsgGetCosmosChainInfoAck = {
    target: "keplr_ewallet_sdk";
    msg_type: "get_cosmos_chain_info_ack";
    payload: Result<ChainInfo[], string>;
};
type EWalletMsgGetEthChainInfo = {
    target: "keplr_ewallet_attached";
    msg_type: "get_eth_chain_info";
    payload: {
        chain_id: string | null;
    };
};
type EWalletMsgGetEthChainInfoAck = {
    target: "keplr_ewallet_sdk";
    msg_type: "get_eth_chain_info_ack";
    payload: Result<ChainInfo[], string>;
};
type EWalletMsg = EWalletMsgInit | EWalletMsgInitAck | EWalletMsgGetPublicKey | EWalletMsgGetPublicKeyAck | EWalletMsgSetOAuthNonce | EWalletMsgSetOAuthNonceAck | EWalletMsgOAuthSignInUpdate | EWalletMsgOAuthSignInUpdateAck | EWalletMsgOAuthInfoPass | EWalletMsgOAuthInfoPassAck | EWalletMsgSignOut | EWalletMsgSignOutAck | EWalletMsgOpenModal | EWalletMsgOpenModalAck | EWalletMsgHideModal | EWalletMsgHideModalAck | EWalletMsgGetEmail | EWalletMsgGetEmailAck | EWalletMsgGetCosmosChainInfo | EWalletMsgGetCosmosChainInfoAck | EWalletMsgGetEthChainInfo | EWalletMsgGetEthChainInfoAck | {
    target: "keplr_ewallet_sdk";
    msg_type: "unknown_msg_type";
    payload: string | null;
};

type KeplrEwalletInitError = {
    type: "is_locked";
} | {
    type: "not_in_browser";
} | {
    type: "host_origin_empty";
} | {
    type: "sdk_endpoint_invalid_url";
} | {
    type: "iframe_setup_fail";
    msg: string;
} | {
    type: "unknown_error";
    msg: string;
};
type OpenModalError = {
    type: "timeout";
} | {
    type: "invalid_ack_type";
    received: string;
} | {
    type: "unknown_error";
    error: any;
};

interface KeplrEWalletStaticInterface {
    new (apiKey: string, iframe: HTMLIFrameElement, sdkEndpoint: string): void;
    init: (args: KeplrEwalletInitArgs) => Result<KeplrEWalletInterface, KeplrEwalletInitError>;
}
interface KeplrEWalletInterface {
    state: KeplrEWalletState;
    apiKey: string;
    iframe: HTMLIFrameElement;
    sdkEndpoint: string;
    eventEmitter: EventEmitter3<KeplrEWalletCoreEvent2, KeplrEWalletCoreEventHandler2>;
    origin: string;
    waitUntilInitialized: Promise<Result<KeplrEWalletState, string>>;
    openModal: (msg: EWalletMsgOpenModal) => Promise<Result<OpenModalAckPayload, OpenModalError>>;
    closeModal: () => void;
    sendMsgToIframe: (msg: EWalletMsg) => Promise<EWalletMsg>;
    signIn: (type: "google") => Promise<void>;
    signOut: () => Promise<void>;
    getPublicKey: () => Promise<string | null>;
    getEmail: () => Promise<string | null>;
    on: (handlerDef: KeplrEWalletCoreEventHandler2) => void;
}
interface KeplrEwalletInitArgs {
    api_key: string;
    sdk_endpoint?: string;
}
interface KeplrEWalletState {
    email: string | null;
    publicKey: string | null;
}

interface FullSignature {
    big_r: string;
    s: string;
}
interface SignOutput {
    sig: FullSignature;
    is_high: boolean;
}
type EWalletMakeSignaturePayload = {
    msg: Uint8Array;
};

declare const KeplrEWallet: KeplrEWalletStaticInterface;

declare const KEPLR_IFRAME_ID = "keplr-ewallet-attached";
declare function setUpIframeElement(url: URL): Result<HTMLIFrameElement, string>;

export { EventEmitter3, KEPLR_IFRAME_ID, KeplrEWallet, RedirectUriSearchParamsKey, setUpIframeElement };
export type { AccountsChangedPayload, ChainInfoForAttachedModal, CosmosArbitrarySigData, CosmosArbitrarySignPayload, CosmosTxSigData, CosmosTxSignAminoPayload, CosmosTxSignDirectPayload, CosmosTxSignPayload, EWalletMakeSignaturePayload, EWalletMsg, EWalletMsgGetCosmosChainInfo, EWalletMsgGetCosmosChainInfoAck, EWalletMsgGetEmail, EWalletMsgGetEmailAck, EWalletMsgGetEthChainInfo, EWalletMsgGetEthChainInfoAck, EWalletMsgGetPublicKey, EWalletMsgGetPublicKeyAck, EWalletMsgHideModal, EWalletMsgHideModalAck, EWalletMsgInit, EWalletMsgInitAck, EWalletMsgOAuthInfoPass, EWalletMsgOAuthInfoPassAck, EWalletMsgOAuthSignInUpdate, EWalletMsgOAuthSignInUpdateAck, EWalletMsgOpenModal, EWalletMsgOpenModalAck, EWalletMsgSetOAuthNonce, EWalletMsgSetOAuthNonceAck, EWalletMsgSignOut, EWalletMsgSignOutAck, EthereumArbitrarySignPayload, EthereumEip712SignPayload, EthereumTxSignPayload, EthereumTxSignResult, EventEmitError, EventHandlerType, EventType, FullSignature, InitPayload, KeplrEWalletCoreEvent2, KeplrEWalletCoreEventHandler2, KeplrEWalletInterface, KeplrEWalletState, KeplrEWalletStaticInterface, KeplrEwalletInitArgs, KeplrEwalletInitError, MakeArbitrarySigData, MakeCosmosSigData, MakeCosmosSigError, MakeCosmosSigModalResult, MakeCosmosSigResult, MakeEIP712SigData, MakeEthSigError, MakeEthSigModalResult, MakeEthereumSigData, MakeEthereumSigResult, MakeSigError, MakeSigModalApproveAckPayload, MakeSigModalErrorAckPayload, MakeSigModalPayload, MakeSigModalRejectAckPayload, MakeSignOutputError, MakeTxSignSigData, OAuthPayload, OAuthSignInError, OAuthState, OpenModalAckPayload, OpenModalError, OpenModalPayload, OtherModalApproveAckPayload, OtherModalError, OtherModalErrorAckPayload, OtherModalPayload, OtherModalRejectAckPayload, RunPresignError, RunSignError, RunTriplesError, SignDoc, SignOutput };