@mictonode/widget 0.3.16 → 0.3.18

package/lib/wallet/Wallet.ts

@@ -1,142 +1,142 @@
-import { Registry } from '@cosmjs/proto-signing'
-import { defaultRegistryTypes } from "@cosmjs/stargate";
-import { Transaction } from "../utils/type";
-import { KeplerWallet } from './wallets/KeplerWallet';
-import { LedgerWallet } from './wallets/LedgerWallet';
-import { MetamaskWallet } from './wallets/MetamaskWallet';
-import { MetamaskSnapWallet } from './wallets/MetamaskSnapWallet';
-import { LeapWallet } from './wallets/LeapWallet';
-import { OKXWallet } from "./wallets/OKXWallet";
-import { UnisatWallet } from "./wallets/UnisatWallet";
-
-export enum WalletName {
-    Keplr = "Keplr",
-    Ledger = "LedgerUSB",
-    LedgerBLE = "LedgerBLE",
-    Metamask = "Metamask",
-    MetamaskSnap = "MetamaskSnap",
-    Leap = "Leap",
-    OKX = "OKX Wallet",
-    Unisat = "UniSat Wallet",
-    // None Signning
-    Address = "Address",
-    NameService = "Nameservice",
-}
-
-export interface IChain {
-    chainID: string;
-    name: string;
-    prefix: string;
-    rpcUrl: string;
-    restUrl: string;
-    denom: string;
-    hdPath: string;
-    logo: string;
-    faucetUrl: string;
-    explorerUrl: string;
-}
-
-export interface ConnectedWallet {
-    wallet: WalletName,
-    cosmosAddress: string
-    hdPath?: string
-}
-
-export interface Account {
-    address: string,
-    algo: string,
-    pubkey: Uint8Array,
-}
-
-export interface WalletArgument {
-    chainId?: string,
-    hdPath?: string,
-    address?: string,
-    name?: string,
-    transport?: string
-    prefix?: string,
-}
-
-export interface AbstractWallet {
-    name: WalletName
-    /**
-     * The the accounts from the wallet (addresses)
-     */
-    getAccounts(): Promise<Account[]>
-    supportCoinType(coinType?: string): Promise<boolean>
-    sign(transaction: Transaction): Promise<any>
-}
-
-export const DEFAULT_HDPATH = "m/44'/118/0'/0/0";
-
-export function keyType(chainId: string) {
-    switch (true) {
-        // Cosmos EVM chains (Warden, etc.) - uses cosmos.evm module
-        case chainId.startsWith("warden"):
-        case chainId.startsWith("barra"):  // Warden testnet
-            return "/cosmos.evm.crypto.v1.ethsecp256k1.PubKey";
-        // Ethermint-like chains: evmos_9002-1, cronos_25-1, etc.
-        case chainId.search(/\w+_\d+-\d+/g) > -1:
-            return "/ethermint.crypto.v1.ethsecp256k1.PubKey"
-        case chainId.startsWith("injective"):
-            return "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
-        case chainId.startsWith("stratos"):
-            return "/stratos.crypto.v1.ethsecp256k1.PubKey";
-        default:
-            return "/cosmos.crypto.secp256k1.PubKey"
-    }
-}
-
-// Check if chain is EVM-based (requires higher fees)
-export function isEvmChain(chainId: string): boolean {
-    return chainId.startsWith("warden") ||
-        chainId.startsWith("barra") ||
-        chainId.search(/\w+_\d+-\d+/g) > -1 ||
-        chainId.startsWith("injective") ||
-        chainId.startsWith("stratos");
-}
-
-export function readWallet(hdPath?: string) {
-    return JSON.parse(
-        localStorage.getItem(hdPath || DEFAULT_HDPATH) || '{}'
-    ) as ConnectedWallet
-}
-export function writeWallet(connected: ConnectedWallet, hdPath?: string) {
-    localStorage.setItem(hdPath || DEFAULT_HDPATH, JSON.stringify(connected))
-}
-
-export function removeWallet(hdPath?: string) {
-    localStorage.removeItem(hdPath || DEFAULT_HDPATH);
-}
-
-export function extractChainId(chainId: string) {
-    const start = chainId.indexOf('_')
-    const end = chainId.indexOf('-')
-    if (end > start && start > 0) {
-        return Number(chainId.substring(start + 1, end))
-    }
-    return 0
-}
-
-export function createWallet(name: WalletName, arg: WalletArgument, registry?: Registry, chain?: IChain,): AbstractWallet {
-    const reg = registry || new Registry(defaultRegistryTypes)
-    switch (name) {
-        case WalletName.OKX:
-            return new OKXWallet(arg, <IChain>chain, reg);
-        case WalletName.Unisat:
-            return new UnisatWallet(arg, <IChain>chain, reg);
-        case WalletName.Keplr:
-            return new KeplerWallet(arg, reg)
-        case WalletName.Ledger:
-            return new LedgerWallet(arg, reg)
-        case WalletName.Leap:
-            return new LeapWallet(arg, reg)
-        case WalletName.MetamaskSnap:
-            return new MetamaskSnapWallet(arg, reg)
-        case WalletName.Metamask:
-            return arg.hdPath &&
-                (arg.hdPath.startsWith('m/44/60') || arg.hdPath.startsWith("m/44'/60"))
-                ? new MetamaskWallet(arg, reg) : new MetamaskSnapWallet(arg, reg)
-    }
-    throw new Error("No wallet connected")
-}
+import { Registry } from '@cosmjs/proto-signing'
+import { defaultRegistryTypes } from "@cosmjs/stargate";
+import { Transaction } from "../utils/type";
+import { KeplerWallet } from './wallets/KeplerWallet';
+import { LedgerWallet } from './wallets/LedgerWallet';
+import { MetamaskWallet } from './wallets/MetamaskWallet';
+import { MetamaskSnapWallet } from './wallets/MetamaskSnapWallet';
+import { LeapWallet } from './wallets/LeapWallet';
+import { OKXWallet } from "./wallets/OKXWallet";
+import { UnisatWallet } from "./wallets/UnisatWallet";
+
+export enum WalletName {
+    Keplr = "Keplr",
+    Ledger = "LedgerUSB",
+    LedgerBLE = "LedgerBLE",
+    Metamask = "Metamask",
+    MetamaskSnap = "MetamaskSnap",
+    Leap = "Leap",
+    OKX = "OKX Wallet",
+    Unisat = "UniSat Wallet",
+    // None Signning
+    Address = "Address",
+    NameService = "Nameservice",
+}
+
+export interface IChain {
+    chainID: string;
+    name: string;
+    prefix: string;
+    rpcUrl: string;
+    restUrl: string;
+    denom: string;
+    hdPath: string;
+    logo: string;
+    faucetUrl: string;
+    explorerUrl: string;
+}
+
+export interface ConnectedWallet {
+    wallet: WalletName,
+    cosmosAddress: string
+    hdPath?: string
+}
+
+export interface Account {
+    address: string,
+    algo: string,
+    pubkey: Uint8Array,
+}
+
+export interface WalletArgument {
+    chainId?: string,
+    hdPath?: string,
+    address?: string,
+    name?: string,
+    transport?: string
+    prefix?: string,
+}
+
+export interface AbstractWallet {
+    name: WalletName
+    /**
+     * The the accounts from the wallet (addresses)
+     */
+    getAccounts(): Promise<Account[]>
+    supportCoinType(coinType?: string): Promise<boolean>
+    sign(transaction: Transaction): Promise<any>
+}
+
+export const DEFAULT_HDPATH = "m/44'/118/0'/0/0";
+
+export function keyType(chainId: string) {
+    switch (true) {
+        // Cosmos EVM chains (Warden, etc.) - uses cosmos.evm module
+        case chainId.startsWith("warden"):
+        case chainId.startsWith("barra"):  // Warden testnet
+            return "/cosmos.evm.crypto.v1.ethsecp256k1.PubKey";
+        // Ethermint-like chains: evmos_9002-1, cronos_25-1, etc.
+        case chainId.search(/\w+_\d+-\d+/g) > -1:
+            return "/ethermint.crypto.v1.ethsecp256k1.PubKey"
+        case chainId.startsWith("injective"):
+            return "/injective.crypto.v1beta1.ethsecp256k1.PubKey";
+        case chainId.startsWith("stratos"):
+            return "/stratos.crypto.v1.ethsecp256k1.PubKey";
+        default:
+            return "/cosmos.crypto.secp256k1.PubKey"
+    }
+}
+
+// Check if chain is EVM-based (requires higher fees)
+export function isEvmChain(chainId: string): boolean {
+    return chainId.startsWith("warden") ||
+        chainId.startsWith("barra") ||
+        chainId.search(/\w+_\d+-\d+/g) > -1 ||
+        chainId.startsWith("injective") ||
+        chainId.startsWith("stratos");
+}
+
+export function readWallet(hdPath?: string) {
+    return JSON.parse(
+        localStorage.getItem(hdPath || DEFAULT_HDPATH) || '{}'
+    ) as ConnectedWallet
+}
+export function writeWallet(connected: ConnectedWallet, hdPath?: string) {
+    localStorage.setItem(hdPath || DEFAULT_HDPATH, JSON.stringify(connected))
+}
+
+export function removeWallet(hdPath?: string) {
+    localStorage.removeItem(hdPath || DEFAULT_HDPATH);
+}
+
+export function extractChainId(chainId: string) {
+    const start = chainId.indexOf('_')
+    const end = chainId.indexOf('-')
+    if (end > start && start > 0) {
+        return Number(chainId.substring(start + 1, end))
+    }
+    return 0
+}
+
+export function createWallet(name: WalletName, arg: WalletArgument, registry?: Registry, chain?: IChain,): AbstractWallet {
+    const reg = registry || new Registry(defaultRegistryTypes)
+    switch (name) {
+        case WalletName.OKX:
+            return new OKXWallet(arg, <IChain>chain, reg);
+        case WalletName.Unisat:
+            return new UnisatWallet(arg, <IChain>chain, reg);
+        case WalletName.Keplr:
+            return new KeplerWallet(arg, reg)
+        case WalletName.Ledger:
+            return new LedgerWallet(arg, reg)
+        case WalletName.Leap:
+            return new LeapWallet(arg, reg)
+        case WalletName.MetamaskSnap:
+            return new MetamaskSnapWallet(arg, reg)
+        case WalletName.Metamask:
+            return arg.hdPath &&
+                (arg.hdPath.startsWith('m/44/60') || arg.hdPath.startsWith("m/44'/60"))
+                ? new MetamaskWallet(arg, reg) : new MetamaskSnapWallet(arg, reg)
+    }
+    throw new Error("No wallet connected")
+}

package/lib/wallet/wallets/KeplerWallet.ts

@@ -1,141 +1,141 @@
-import { fromBase64, fromBech32, toHex } from "@cosmjs/encoding";
-import { Registry, TxBodyEncodeObject, encodePubkey, makeAuthInfoBytes, makeSignDoc } from "@cosmjs/proto-signing"
-import { AbstractWallet, Account, WalletArgument, WalletName, keyType } from "../Wallet"
-import { Transaction } from "../../utils/type"
-import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
-import { Any } from "cosmjs-types/google/protobuf/any";
-import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys'
-import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
-import { AminoTypes, createDefaultAminoConverters } from "@cosmjs/stargate";
-import { encodeSecp256k1Pubkey, makeSignDoc as makeSignDocAmino } from "@cosmjs/amino";
-import { createWasmAminoConverters } from "@cosmjs/cosmwasm-stargate";
-
-export class KeplerWallet implements AbstractWallet {
-    name: WalletName.Keplr
-    chainId: string
-    registry: Registry
-    conf: WalletArgument
-    aminoTypes = new AminoTypes( {...createDefaultAminoConverters(), ...createWasmAminoConverters()})
-    constructor(arg: WalletArgument, registry: Registry) {
-        this.chainId = arg.chainId || "cosmoshub"
-        // @ts-ignore
-        if (!window.getOfflineSigner || !window.keplr) {
-            throw new Error('Please install keplr extension')
-        }
-        this.registry = registry
-        this.conf = arg
-    }
-    
-    async getAccounts(): Promise<Account[]> {
-        // const chainId = 'cosmoshub'
-        // @ts-ignore
-        await window.keplr.enable(this.chainId)
-        // @ts-ignore
-        const offlineSigner = window.getOfflineSigner(this.chainId)
-        return offlineSigner.getAccounts()
-    }
-    supportCoinType(coinType?: string | undefined): Promise<boolean> {
-        return Promise.resolve(true);
-    }
-    isEthermint() {
-        return this.conf.hdPath && this.conf.hdPath.startsWith("m/44'/60")
-    }
-    async sign(transaction: Transaction): Promise<TxRaw> {
-        // sign wasm tx with signDirect
-        if(transaction.messages.findIndex(x => x.typeUrl.startsWith("/cosmwasm.wasm")) > -1) {
-            return this.signDirect(transaction)
-        }
-        return this.signAmino(transaction)
-    }
-    // @deprecated use signAmino instead
-    // because signDirect is not supported ledger wallet
-    async signDirect(transaction: Transaction): Promise<TxRaw> {
-        const accouts = await this.getAccounts()
-        const hex = toHex(fromBech32(transaction.signerAddress).data)
-        const accountFromSigner = accouts.find((account) => toHex(fromBech32(account.address).data) === hex);
-        if (!accountFromSigner) {
-            throw new Error("Failed to retrieve account from signer");
-        }
-        const pubkey = Any.fromPartial({
-            typeUrl: keyType(transaction.chainId),
-            value: PubKey.encode({
-                key: accountFromSigner.pubkey,
-            }).finish()
-        })
-        const txBodyEncodeObject: TxBodyEncodeObject = {
-            typeUrl: "/cosmos.tx.v1beta1.TxBody",
-            value: {
-                messages: transaction.messages,
-                memo: transaction.memo,
-            },
-        };
-        const txBodyBytes = this.registry.encode(txBodyEncodeObject);
-        const gasLimit = Number(transaction.fee.gas);
-        const authInfoBytes = makeAuthInfoBytes(
-            [{ pubkey, sequence: transaction.signerData.sequence }],
-            transaction.fee.amount,
-            gasLimit,
-            transaction.fee.granter,
-            transaction.fee.payer,
-        );
-        const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, transaction.chainId, transaction.signerData.accountNumber);
-
-        // @ts-ignore
-        const offlineSigner = window.getOfflineSigner(this.chainId)
-        const { signature, signed } = await offlineSigner.signDirect(transaction.signerAddress, signDoc);;
-        return TxRaw.fromPartial({
-            bodyBytes: signed.bodyBytes,
-            authInfoBytes: signed.authInfoBytes,
-            signatures: [fromBase64(signature.signature)],
-        });
-    }
-
-    async signAmino(tx: Transaction): Promise<TxRaw> {
-        const accouts = await this.getAccounts()
-        const hex = toHex(fromBech32(tx.signerAddress).data)
-        const accountFromSigner = accouts.find((account) => toHex(fromBech32(account.address).data) === hex);
-        if (!accountFromSigner) {
-            throw new Error("Failed to retrieve account from signer");
-        }
-        // const pubkey = encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey));
-        const pubkey = Any.fromPartial({
-            typeUrl: keyType(tx.chainId),
-            value: PubKey.encode({
-                key: accountFromSigner.pubkey,
-            }).finish()
-        })
-        const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
-        const msgs = tx.messages.map((msg) => this.aminoTypes.toAmino(msg));
-        const signDoc = makeSignDocAmino(msgs, tx.fee, tx.chainId, tx.memo, tx.signerData.accountNumber, tx.signerData.sequence);
-        
-        // @ts-ignore
-        const offlineSigner = window.getOfflineSigner(this.chainId)
-        const { signature, signed } = await offlineSigner.signAmino(tx.signerAddress, signDoc);
-
-        const signedTxBody = {
-            messages: signed.msgs.map((msg) => this.aminoTypes.fromAmino(msg)),
-            memo: signed.memo,
-        };
-        const signedTxBodyEncodeObject: TxBodyEncodeObject = {
-            typeUrl: "/cosmos.tx.v1beta1.TxBody",
-            value: signedTxBody,
-        };
-        const signedTxBodyBytes = this.registry.encode(signedTxBodyEncodeObject);
-
-        const signedGasLimit = Number(signed.fee.gas);
-        const signedSequence = Number(signed.sequence);
-        const signedAuthInfoBytes = makeAuthInfoBytes(
-            [{ pubkey, sequence: signedSequence }],
-            signed.fee.amount,
-            signedGasLimit,
-            signed.fee.granter,
-            signed.fee.payer,
-            signMode,
-        );
-        return TxRaw.fromPartial({
-            bodyBytes: signedTxBodyBytes,
-            authInfoBytes: signedAuthInfoBytes,
-            signatures: [fromBase64(signature.signature)],
-        });
-    }
-}
+import { fromBase64, fromBech32, toHex } from "@cosmjs/encoding";
+import { Registry, TxBodyEncodeObject, encodePubkey, makeAuthInfoBytes, makeSignDoc } from "@cosmjs/proto-signing"
+import { AbstractWallet, Account, WalletArgument, WalletName, keyType } from "../Wallet"
+import { Transaction } from "../../utils/type"
+import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { Any } from "cosmjs-types/google/protobuf/any";
+import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys'
+import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
+import { AminoTypes, createDefaultAminoConverters } from "@cosmjs/stargate";
+import { encodeSecp256k1Pubkey, makeSignDoc as makeSignDocAmino } from "@cosmjs/amino";
+import { createWasmAminoConverters } from "@cosmjs/cosmwasm-stargate";
+
+export class KeplerWallet implements AbstractWallet {
+    name: WalletName.Keplr
+    chainId: string
+    registry: Registry
+    conf: WalletArgument
+    aminoTypes = new AminoTypes( {...createDefaultAminoConverters(), ...createWasmAminoConverters()})
+    constructor(arg: WalletArgument, registry: Registry) {
+        this.chainId = arg.chainId || "cosmoshub"
+        // @ts-ignore
+        if (!window.getOfflineSigner || !window.keplr) {
+            throw new Error('Please install keplr extension')
+        }
+        this.registry = registry
+        this.conf = arg
+    }
+    
+    async getAccounts(): Promise<Account[]> {
+        // const chainId = 'cosmoshub'
+        // @ts-ignore
+        await window.keplr.enable(this.chainId)
+        // @ts-ignore
+        const offlineSigner = window.getOfflineSigner(this.chainId)
+        return offlineSigner.getAccounts()
+    }
+    supportCoinType(coinType?: string | undefined): Promise<boolean> {
+        return Promise.resolve(true);
+    }
+    isEthermint() {
+        return this.conf.hdPath && this.conf.hdPath.startsWith("m/44'/60")
+    }
+    async sign(transaction: Transaction): Promise<TxRaw> {
+        // sign wasm tx with signDirect
+        if(transaction.messages.findIndex(x => x.typeUrl.startsWith("/cosmwasm.wasm")) > -1) {
+            return this.signDirect(transaction)
+        }
+        return this.signAmino(transaction)
+    }
+    // @deprecated use signAmino instead
+    // because signDirect is not supported ledger wallet
+    async signDirect(transaction: Transaction): Promise<TxRaw> {
+        const accouts = await this.getAccounts()
+        const hex = toHex(fromBech32(transaction.signerAddress).data)
+        const accountFromSigner = accouts.find((account) => toHex(fromBech32(account.address).data) === hex);
+        if (!accountFromSigner) {
+            throw new Error("Failed to retrieve account from signer");
+        }
+        const pubkey = Any.fromPartial({
+            typeUrl: keyType(transaction.chainId),
+            value: PubKey.encode({
+                key: accountFromSigner.pubkey,
+            }).finish()
+        })
+        const txBodyEncodeObject: TxBodyEncodeObject = {
+            typeUrl: "/cosmos.tx.v1beta1.TxBody",
+            value: {
+                messages: transaction.messages,
+                memo: transaction.memo,
+            },
+        };
+        const txBodyBytes = this.registry.encode(txBodyEncodeObject);
+        const gasLimit = Number(transaction.fee.gas);
+        const authInfoBytes = makeAuthInfoBytes(
+            [{ pubkey, sequence: transaction.signerData.sequence }],
+            transaction.fee.amount,
+            gasLimit,
+            transaction.fee.granter,
+            transaction.fee.payer,
+        );
+        const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, transaction.chainId, transaction.signerData.accountNumber);
+
+        // @ts-ignore
+        const offlineSigner = window.getOfflineSigner(this.chainId)
+        const { signature, signed } = await offlineSigner.signDirect(transaction.signerAddress, signDoc);;
+        return TxRaw.fromPartial({
+            bodyBytes: signed.bodyBytes,
+            authInfoBytes: signed.authInfoBytes,
+            signatures: [fromBase64(signature.signature)],
+        });
+    }
+
+    async signAmino(tx: Transaction): Promise<TxRaw> {
+        const accouts = await this.getAccounts()
+        const hex = toHex(fromBech32(tx.signerAddress).data)
+        const accountFromSigner = accouts.find((account) => toHex(fromBech32(account.address).data) === hex);
+        if (!accountFromSigner) {
+            throw new Error("Failed to retrieve account from signer");
+        }
+        // const pubkey = encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+        const pubkey = Any.fromPartial({
+            typeUrl: keyType(tx.chainId),
+            value: PubKey.encode({
+                key: accountFromSigner.pubkey,
+            }).finish()
+        })
+        const signMode = SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+        const msgs = tx.messages.map((msg) => this.aminoTypes.toAmino(msg));
+        const signDoc = makeSignDocAmino(msgs, tx.fee, tx.chainId, tx.memo, tx.signerData.accountNumber, tx.signerData.sequence);
+        
+        // @ts-ignore
+        const offlineSigner = window.getOfflineSigner(this.chainId)
+        const { signature, signed } = await offlineSigner.signAmino(tx.signerAddress, signDoc);
+
+        const signedTxBody = {
+            messages: signed.msgs.map((msg) => this.aminoTypes.fromAmino(msg)),
+            memo: signed.memo,
+        };
+        const signedTxBodyEncodeObject: TxBodyEncodeObject = {
+            typeUrl: "/cosmos.tx.v1beta1.TxBody",
+            value: signedTxBody,
+        };
+        const signedTxBodyBytes = this.registry.encode(signedTxBodyEncodeObject);
+
+        const signedGasLimit = Number(signed.fee.gas);
+        const signedSequence = Number(signed.sequence);
+        const signedAuthInfoBytes = makeAuthInfoBytes(
+            [{ pubkey, sequence: signedSequence }],
+            signed.fee.amount,
+            signedGasLimit,
+            signed.fee.granter,
+            signed.fee.payer,
+            signMode,
+        );
+        return TxRaw.fromPartial({
+            bodyBytes: signedTxBodyBytes,
+            authInfoBytes: signedAuthInfoBytes,
+            signatures: [fromBase64(signature.signature)],
+        });
+    }
+}