@mictonode/widget 0.3.16 → 0.3.17

package/lib/wallet/UniClient.ts

@@ -1,145 +1,145 @@
-import { toBase64, fromBase64, toHex, fromBech32 } from "@cosmjs/encoding";
-import { EncodeObject, encodePubkey, Registry } from '@cosmjs/proto-signing'
-import { encodeSecp256k1Pubkey } from "@cosmjs/amino";
-import { defaultRegistryTypes } from "@cosmjs/stargate";
-import { AuthInfo, TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
-import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
-import { AbstractWallet, WalletArgument, WalletName, createWallet } from "./Wallet";
-import { post } from "../utils/http";
-import { BroadcastMode, Transaction, TxResponse } from "../utils/type";
-import { wasmTypes } from "@cosmjs/cosmwasm-stargate/build/modules";
-import { makeAuthInfoBytes, makeSignDoc, TxBodyEncodeObject } from "@cosmjs/proto-signing/build";
-import { Any } from "cosmjs-types/google/protobuf/any";
-
-export function isEthermint(chainId: string) {
-  return chainId.search(/\w+_\d+-\d+/g) > -1
-}
-
-export class UniClient {
-    registry: Registry
-    wallet: AbstractWallet
-    constructor(name: WalletName, arg: WalletArgument) {
-        this.registry = new Registry([...defaultRegistryTypes, ...wasmTypes])
-        this.wallet = createWallet(name, arg, this.registry)
-    }
-
-    async getAccounts() {
-        return this.wallet.getAccounts()
-    }
-
-    async sign(transaction: Transaction): Promise<TxRaw> {
-        // const { signature, signed } = await this.wallet.sign(transaction);
-        // return TxRaw.fromPartial({
-        //     bodyBytes: signed.bodyBytes,
-        //     authInfoBytes: signed.authInfoBytes,
-        //     signatures: [fromBase64(signature.signature)],
-        // });
-        return this.wallet.sign(transaction)
-    }
-    
-    async simulate (
-        endpoint: string,
-        transaction: Transaction,
-        mode: BroadcastMode = BroadcastMode.SYNC
-      ) {
-
-        const pubkey = Any.fromPartial({
-            typeUrl: '/cosmos.crypto.ed25519.PubKey',
-            value: new Uint8Array()
-        })
-        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 txRaw =  TxRaw.fromPartial({
-            bodyBytes: txBodyBytes,
-            authInfoBytes: authInfoBytes,
-            signatures: [new Uint8Array()],
-        });
-
-        const txbytes = toBase64(TxRaw.encode(txRaw).finish())
-        const request = {
-          tx_bytes: txbytes,
-          mode, // BROADCAST_MODE_SYNC, BROADCAST_MODE_BLOCK, BROADCAST_MODE_ASYNC
-        }
-        return post(`${endpoint}/cosmos/tx/v1beta1/simulate`, request).then(res => {
-          if (res.code && res.code !== 0) {
-            throw new Error(res.message)
-          }
-          if (res.tx_response && res.tx_response.code !== 0) {
-            throw new Error(res.tx_response.raw_log)
-          }
-          return Number(res.gas_info.gas_used)
-        })
-    }
-
-    // async simulate2(
-    //     endpoint: string, 
-    //     messages: readonly EncodeObject[],
-    //     memo: string | undefined,
-    //     sequence: number
-    // ) {
-        
-    //     const [first] = await this.wallet.getAccounts()
-    //     const pubkey = encodeSecp256k1Pubkey(first.pubkey);
-    //     const anyMsgs = messages.map((m) => this.registry.encodeAsAny(m));
-    //     const url = `${endpoint}/cosmos/tx/v1beta1/simulate`
-    //     const tx = Tx.fromPartial({
-    //         authInfo: AuthInfo.fromPartial({
-    //           fee: Fee.fromPartial({}),
-    //           signerInfos: [
-    //             {
-    //               publicKey: encodePubkey(pubkey),
-    //               sequence: sequence,
-    //               modeInfo: { single: { mode: SignMode.SIGN_MODE_UNSPECIFIED } },
-    //             },
-    //           ],
-    //         }),
-    //         body: TxBody.fromPartial({
-    //           messages: Array.from(anyMsgs),
-    //           memo: memo,
-    //         }),
-    //         signatures: [new Uint8Array()],
-    //       });
-    //     const request = SimulateRequest.fromPartial({
-    //         tx
-    //         // txBytes: Tx.encode(tx).finish(),
-    //     });
-    //     console.log(tx, request)
-    //     return await post(url, request)
-    // }
-
-
-  async broadcastTx(endpoint, bodyBytes: TxRaw, mode: BroadcastMode = BroadcastMode.SYNC) : Promise<{tx_response: TxResponse}> {
-    // const txbytes = bodyBytes.authInfoBytes ? TxRaw.encode(bodyBytes).finish() : bodyBytes
-    const txbytes = TxRaw.encode(bodyBytes).finish() 
-    const txString = toBase64(txbytes)
-    const txRaw = {
-      tx_bytes: txString,
-      mode, // BROADCAST_MODE_SYNC, BROADCAST_MODE_BLOCK, BROADCAST_MODE_ASYNC
-    }
-    return post(`${endpoint}/cosmos/tx/v1beta1/txs`, txRaw).then(res => {
-      if (res.code && res.code !== 0) {
-        throw new Error(res.message)
-      }
-      if (res.tx_response && res.tx_response.code !== 0) {
-        throw new Error(res.tx_response.raw_log)
-      }
-      return res
-    })
-  }
+import { toBase64, fromBase64, toHex, fromBech32 } from "@cosmjs/encoding";
+import { EncodeObject, encodePubkey, Registry } from '@cosmjs/proto-signing'
+import { encodeSecp256k1Pubkey } from "@cosmjs/amino";
+import { defaultRegistryTypes } from "@cosmjs/stargate";
+import { AuthInfo, TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
+import { AbstractWallet, WalletArgument, WalletName, createWallet } from "./Wallet";
+import { post } from "../utils/http";
+import { BroadcastMode, Transaction, TxResponse } from "../utils/type";
+import { wasmTypes } from "@cosmjs/cosmwasm-stargate/build/modules";
+import { makeAuthInfoBytes, makeSignDoc, TxBodyEncodeObject } from "@cosmjs/proto-signing/build";
+import { Any } from "cosmjs-types/google/protobuf/any";
+
+export function isEthermint(chainId: string) {
+  return chainId.search(/\w+_\d+-\d+/g) > -1
+}
+
+export class UniClient {
+    registry: Registry
+    wallet: AbstractWallet
+    constructor(name: WalletName, arg: WalletArgument) {
+        this.registry = new Registry([...defaultRegistryTypes, ...wasmTypes])
+        this.wallet = createWallet(name, arg, this.registry)
+    }
+
+    async getAccounts() {
+        return this.wallet.getAccounts()
+    }
+
+    async sign(transaction: Transaction): Promise<TxRaw> {
+        // const { signature, signed } = await this.wallet.sign(transaction);
+        // return TxRaw.fromPartial({
+        //     bodyBytes: signed.bodyBytes,
+        //     authInfoBytes: signed.authInfoBytes,
+        //     signatures: [fromBase64(signature.signature)],
+        // });
+        return this.wallet.sign(transaction)
+    }
+    
+    async simulate (
+        endpoint: string,
+        transaction: Transaction,
+        mode: BroadcastMode = BroadcastMode.SYNC
+      ) {
+
+        const pubkey = Any.fromPartial({
+            typeUrl: '/cosmos.crypto.ed25519.PubKey',
+            value: new Uint8Array()
+        })
+        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 txRaw =  TxRaw.fromPartial({
+            bodyBytes: txBodyBytes,
+            authInfoBytes: authInfoBytes,
+            signatures: [new Uint8Array()],
+        });
+
+        const txbytes = toBase64(TxRaw.encode(txRaw).finish())
+        const request = {
+          tx_bytes: txbytes,
+          mode, // BROADCAST_MODE_SYNC, BROADCAST_MODE_BLOCK, BROADCAST_MODE_ASYNC
+        }
+        return post(`${endpoint}/cosmos/tx/v1beta1/simulate`, request).then(res => {
+          if (res.code && res.code !== 0) {
+            throw new Error(res.message)
+          }
+          if (res.tx_response && res.tx_response.code !== 0) {
+            throw new Error(res.tx_response.raw_log)
+          }
+          return Number(res.gas_info.gas_used)
+        })
+    }
+
+    // async simulate2(
+    //     endpoint: string, 
+    //     messages: readonly EncodeObject[],
+    //     memo: string | undefined,
+    //     sequence: number
+    // ) {
+        
+    //     const [first] = await this.wallet.getAccounts()
+    //     const pubkey = encodeSecp256k1Pubkey(first.pubkey);
+    //     const anyMsgs = messages.map((m) => this.registry.encodeAsAny(m));
+    //     const url = `${endpoint}/cosmos/tx/v1beta1/simulate`
+    //     const tx = Tx.fromPartial({
+    //         authInfo: AuthInfo.fromPartial({
+    //           fee: Fee.fromPartial({}),
+    //           signerInfos: [
+    //             {
+    //               publicKey: encodePubkey(pubkey),
+    //               sequence: sequence,
+    //               modeInfo: { single: { mode: SignMode.SIGN_MODE_UNSPECIFIED } },
+    //             },
+    //           ],
+    //         }),
+    //         body: TxBody.fromPartial({
+    //           messages: Array.from(anyMsgs),
+    //           memo: memo,
+    //         }),
+    //         signatures: [new Uint8Array()],
+    //       });
+    //     const request = SimulateRequest.fromPartial({
+    //         tx
+    //         // txBytes: Tx.encode(tx).finish(),
+    //     });
+    //     console.log(tx, request)
+    //     return await post(url, request)
+    // }
+
+
+  async broadcastTx(endpoint, bodyBytes: TxRaw, mode: BroadcastMode = BroadcastMode.SYNC) : Promise<{tx_response: TxResponse}> {
+    // const txbytes = bodyBytes.authInfoBytes ? TxRaw.encode(bodyBytes).finish() : bodyBytes
+    const txbytes = TxRaw.encode(bodyBytes).finish() 
+    const txString = toBase64(txbytes)
+    const txRaw = {
+      tx_bytes: txString,
+      mode, // BROADCAST_MODE_SYNC, BROADCAST_MODE_BLOCK, BROADCAST_MODE_ASYNC
+    }
+    return post(`${endpoint}/cosmos/tx/v1beta1/txs`, txRaw).then(res => {
+      if (res.code && res.code !== 0) {
+        throw new Error(res.message)
+      }
+      if (res.tx_response && res.tx_response.code !== 0) {
+        throw new Error(res.tx_response.raw_log)
+      }
+      return res
+    })
+  }
 }

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")
+}