Cosmos

const provider = window.bitkeep && window.bitkeep.keplr;

getKey(chainId: string): Promise<{
    // Name of the selected Wallet.
    name: string;
    algo: string;
    pubKey: Uint8Array;
    address: Uint8Array;
    bech32Address: string;
}>

enable(chainId: string): Promise<void>

provider.on('keplr_keystorechange', () => {
  console.log('账户已变化')
})

interface StdSignature {
  signature: string; // The actual signature string (typically base64-encoded)
  pub_key: {
    type: string;  // The type of public key (e.g., "tendermint/PubKeySecp256k1")
    value: string; // The base64-encoded public key value
  };
}
/**
 * Verifies a previously generated signature against the original data and signer.
 * @param chainId - The chain ID used during signing
 * @param signer - The Bech32 address of the signer
 * @param data - The original data that was signed
 * @param signature - The StdSignature object to verify
 * @returns A promise that resolves to a boolean indicating whether the signature is valid
 */
function verifyArbitrary(
  chainId: string,
  signer: string,
  data: string | Uint8Array,
  signature: string
): Promise<boolean> {
  // Implementation goes here
}
 
/**
 * @param chainId - The chain ID (e.g., "cosmoshub-4")
 * @param signer - The Bech32 address of the account performing the signature
 * @param data - The raw data to be signed (as a string or byte array)
 * @returns Promise<StdSignature> - A promise that resolves to a StdSignature object containing the signature and public key
 */
function signArbitrary(
  chainId: string,
  signer: string,
  data: string | Uint8Array
): Promise<StdSignature> {
  // Implementation goes here
}
 

// Represents a single unit of currency and its amount
interface Coin {
  denom: string;  // The unit of currency (e.g., "uatom")
  amount: string; // The amount (as a string to support large integers)
}
 
// Represents the fee information for a transaction
interface StdFee {
  amount: readonly Coin[]; // Array of fee amounts
  gas: string;             // Gas limit
  granter?: string;        // (Optional) Address of the fee granter
  payer?: string;          // (Optional) Address of the fee payer
}
 
// Represents an Amino message used in signing documents
interface AminoMsg {
  type: string; // The type of the message (e.g., "cosmos-sdk/MsgSend")
  value: any;   // The actual message content (object structure depends on the message type)
}
 
// Represents the full document to be signed in Amino JSON format
interface StdSignDoc {
  chain_id: string;                 // Chain ID
  account_number: string;          // Account number of the signer
  sequence: string;                // Sequence number for preventing replay
  fee: StdFee;                     // Fee information
  msgs: readonly AminoMsg[];       // Array of messages
  memo: string;                    // Optional memo field for notes
  timeout_height?: string;         // (Optional) Timeout height for transaction expiration
}
 
interface SignAminoResponse {
    signed: StdSignDoc,
	signature: {
        signature: string,
		pub_key: {
        	type: string,
			value: string
		}
	}
}
 
function signAmino(
    chainId: string,
	signer: string,
	signDoc: StdSignDoc
): Promise<SignAminoResponse>
 

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;
  }): Promise<DirectSignResponse>

import { TxBody, AuthInfo, SignerInfo, Fee } from 'cosmjs-types/cosmos/tx/v1beta1/tx'
import {MsgSend} from 'cosmjs-types/cosmos/bank/v1beta1/tx'
import {Any} from 'cosmjs-types/google/protobuf/any'
function getBodyBytes(from, to, v) {
    const msgSend = MsgSend.fromPartial({
        fromAddress: from,
        toAddressL: to,
        amount: [{ denom: "uosmo", amount: v}]
    });
    const msgSendAny = Any.fromPartial({
        typeUrl: "/cosmos.bank.v1beta1.MsgSend",
        value: MsgSend.encode(msgSend).finish()
    });
    const txBody = TxBody.fromPartial({
        messages: [msgSendAny],
        memo: "test",
        timeoutHeight: '0',nonCriticalExtensionOptions: []
    });
    return TxBody.encode(txBody).finish();
}
 
function getAuthInfoBytes(pubKey, sequence) {
    const pubKeyAny = Any.fromPartial({
        typeUrl: '/cosmos.crypto.secp256k1.PubKey',
        value: pubKey
    })
    const signerInfo = SignerInfo.fromPartial({
        publicKey: pubKeyAny,
        modeInfo: { single: { mode: 1 } },
        sequence: sequence
    })
    const feeValue = Fee.fromPartial({
        amount: [{ denom: "uosmo", amount: "600" }],
        gasLimit: '200000',
        "granter": "",
        "payer": ""
    })
    const authInfo = AuthInfo.fromPartial({ signerInfos: [signerInfo], fee: feeValue })
    return AuthInfo.encode(authInfo).finish()
}
 
interface SignAminoResponse {
        signed: StdSignDoc,
	signature: {
        signature: string,
		pub_key: {
        	type: string,
			value: string
		}
	}
}
 
const signDoc = {
	bodyBytes: getBodyBytes(),
	authInfoBytes: authInfoBytes(),
	chainId: 'osmosis-1',
	accountNumber: ''  //
}
 
function signDirect(
    chainId: string,
	signer: string,
	signDoc
): Promise<SignAminoResponse>

sendTx(
    chainId: string,
    tx: Uint8Array,
    mode: BroadcastMode
): Promise<Uint8Array>;