@keplr-wallet/types
Version:
178 lines (177 loc) • 8.43 kB
TypeScript
import { ChainInfo, ChainInfoWithoutEndpoints } from "../chain-info";
import { EthSignType } from "../ethereum";
import { BroadcastMode, AminoSignResponse, StdSignDoc, OfflineAminoSigner, StdSignature, DirectSignResponse, OfflineDirectSigner } from "../cosmjs";
import { SecretUtils } from "../secretjs";
import Long from "long";
import { SettledResponses } from "../settled";
import { DirectAuxSignResponse } from "../cosmjs-alt";
import { IEthereumProvider } from "./ethereum";
import { IStarknetProvider } from "./starknet";
import type { Call, DeployAccountSignerDetails, InvocationsSignerDetails } from "starknet";
import { IBitcoinProvider, SignPsbtOptions, SupportedPaymentType } from "./bitcoin";
export interface Key {
readonly name: string;
readonly algo: string;
readonly pubKey: Uint8Array;
readonly address: Uint8Array;
readonly bech32Address: string;
readonly ethereumHexAddress: string;
readonly isNanoLedger: boolean;
readonly isKeystone: boolean;
}
export type ICNSAdr36Signatures = {
chainId: string;
bech32Prefix: string;
bech32Address: string;
addressHash: "cosmos" | "ethereum";
pubKey: Uint8Array;
signatureSalt: number;
signature: Uint8Array;
}[];
export type KeplrMode = "core" | "extension" | "mobile-web" | "walletconnect";
export interface KeplrIntereactionOptions {
readonly sign?: KeplrSignOptions;
}
export interface KeplrSignOptions {
readonly preferNoSetFee?: boolean;
readonly preferNoSetMemo?: boolean;
readonly disableBalanceCheck?: boolean;
}
export interface Keplr {
readonly version: string;
/**
* mode means that how Keplr is connected.
* If the connected Keplr is browser's extension, the mode should be "extension".
* If the connected Keplr is on the mobile app with the embeded web browser, the mode should be "mobile-web".
*/
readonly mode: KeplrMode;
defaultOptions: KeplrIntereactionOptions;
ping(): Promise<void>;
experimentalSuggestChain(chainInfo: ChainInfo): Promise<void>;
enable(chainIds: string | string[]): Promise<void>;
/**
* Delete permissions granted to origin.
* If chain ids are specified, only the permissions granted to each chain id are deleted (In this case, permissions such as getChainInfosWithoutEndpoints() are not deleted).
* Else, remove all permissions granted to origin (In this case, permissions that are not assigned to each chain, such as getChainInfosWithoutEndpoints(), are also deleted).
*
* @param chainIds disable(Remove approve domain(s)) target chain ID(s).
*/
disable(chainIds?: string | string[]): Promise<void>;
getKey(chainId: string): Promise<Key>;
getKeysSettled(chainIds: string[]): Promise<SettledResponses<Key>>;
signAmino(chainId: string, signer: string, signDoc: StdSignDoc, signOptions?: KeplrSignOptions): Promise<AminoSignResponse>;
signDirect(chainId: string, signer: string, signDoc: {
/** SignDoc bodyBytes */
bodyBytes?: Uint8Array | null;
/** SignDoc authInfoBytes */
authInfoBytes?: Uint8Array | null;
/** SignDoc chainId */
chainId?: string | null;
/** SignDoc accountNumber */
accountNumber?: Long | null;
}, signOptions?: KeplrSignOptions): Promise<DirectSignResponse>;
signDirectAux(chainId: string, signer: string, signDoc: {
bodyBytes?: Uint8Array | null;
publicKey?: {
typeUrl: string;
value: Uint8Array;
} | null;
chainId?: string | null;
accountNumber?: Long | null;
sequence?: Long | null;
tip?: {
amount: {
denom: string;
amount: string;
}[];
tipper: string;
} | null;
}, signOptions?: Exclude<KeplrSignOptions, "preferNoSetFee" | "disableBalanceCheck">): Promise<DirectAuxSignResponse>;
sendTx(chainId: string, tx: Uint8Array, mode: BroadcastMode): Promise<Uint8Array>;
signICNSAdr36(chainId: string, contractAddress: string, owner: string, username: string, addressChainIds: string[]): Promise<ICNSAdr36Signatures>;
signArbitrary(chainId: string, signer: string, data: string | Uint8Array): Promise<StdSignature>;
verifyArbitrary(chainId: string, signer: string, data: string | Uint8Array, signature: StdSignature): Promise<boolean>;
signEthereum(chainId: string, signer: string, data: string | Uint8Array, type: EthSignType): Promise<Uint8Array>;
getOfflineSigner(chainId: string, signOptions?: KeplrSignOptions): OfflineAminoSigner & OfflineDirectSigner;
getOfflineSignerOnlyAmino(chainId: string, signOptions?: KeplrSignOptions): OfflineAminoSigner;
getOfflineSignerAuto(chainId: string, signOptions?: KeplrSignOptions): Promise<OfflineAminoSigner | OfflineDirectSigner>;
suggestToken(chainId: string, contractAddress: string, viewingKey?: string): Promise<void>;
getSecret20ViewingKey(chainId: string, contractAddress: string): Promise<string>;
getEnigmaUtils(chainId: string): SecretUtils;
getEnigmaPubKey(chainId: string): Promise<Uint8Array>;
getEnigmaTxEncryptionKey(chainId: string, nonce: Uint8Array): Promise<Uint8Array>;
enigmaEncrypt(chainId: string, contractCodeHash: string, msg: object): Promise<Uint8Array>;
enigmaDecrypt(chainId: string, ciphertext: Uint8Array, nonce: Uint8Array): Promise<Uint8Array>;
/**
* Sign the sign doc with ethermint's EIP-712 format.
* The difference from signEthereum(..., EthSignType.EIP712) is that this api returns a new sign doc changed by the user's fee setting and the signature for that sign doc.
* Encoding tx to EIP-712 format should be done on the side using this api.
* Not compatible with cosmjs.
* The returned signature is (r | s | v) format which used in ethereum.
* v should be 27 or 28 which is used in the ethereum mainnet regardless of chain.
* @param chainId
* @param signer
* @param eip712
* @param signDoc
* @param signOptions
*/
experimentalSignEIP712CosmosTx_v0(chainId: string, signer: string, eip712: {
types: Record<string, {
name: string;
type: string;
}[] | undefined>;
domain: Record<string, any>;
primaryType: string;
}, signDoc: StdSignDoc, signOptions?: KeplrSignOptions): Promise<AminoSignResponse>;
getChainInfosWithoutEndpoints(): Promise<ChainInfoWithoutEndpoints[]>;
getChainInfoWithoutEndpoints(chainId: string): Promise<ChainInfoWithoutEndpoints>;
/** Change wallet extension user name **/
changeKeyRingName(opts: {
defaultName: string;
editable?: boolean;
}): Promise<string>;
sendEthereumTx(chainId: string, tx: Uint8Array): Promise<string>;
suggestERC20(chainId: string, contractAddress: string): Promise<void>;
getStarknetKey(chainId: string): Promise<{
name: string;
hexAddress: string;
pubKey: Uint8Array;
address: Uint8Array;
isNanoLedger: boolean;
}>;
getStarknetKeysSettled(chainIds: string[]): Promise<SettledResponses<{
name: string;
hexAddress: string;
pubKey: Uint8Array;
address: Uint8Array;
isNanoLedger: boolean;
}>>;
signStarknetDeployAccountTransaction(chainId: string, transaction: DeployAccountSignerDetails): Promise<{
transaction: DeployAccountSignerDetails;
signature: string[];
}>;
signStarknetTx(chainId: string, transactions: Call[], details: InvocationsSignerDetails): Promise<{
transactions: Call[];
details: InvocationsSignerDetails;
signature: string[];
}>;
getBitcoinKey(chainId: string): Promise<{
name: string;
pubKey: Uint8Array;
address: string;
paymentType: SupportedPaymentType;
isNanoLedger: boolean;
}>;
getBitcoinKeysSettled(chainIds: string[]): Promise<SettledResponses<{
name: string;
pubKey: Uint8Array;
address: string;
paymentType: SupportedPaymentType;
isNanoLedger: boolean;
}>>;
signPsbt(chainId: string, psbtHex: string, options?: SignPsbtOptions): Promise<string>;
signPsbts(chainId: string, psbtsHexes: string[], options?: SignPsbtOptions): Promise<string[]>;
readonly ethereum: IEthereumProvider;
readonly starknet: IStarknetProvider;
readonly bitcoin: IBitcoinProvider;
}