@mictonode/widget 0.3.9

package/lib/wallet/EthermintMessageAdapter.ts

@@ -0,0 +1,136 @@
+import { EncodeObject } from "@cosmjs/proto-signing"
+import { 
+    createMsgWithdrawDelegatorReward, 
+    createIBCMsgTransfer,
+    createMsgSend,
+    createMsgBeginRedelegate,
+    createMsgDelegate,
+    createMsgUndelegate,
+    createMsgVote,
+    // createMsgWithdrawValidatorCommission,
+} from '@tharsis/proto'
+import {
+    MSG_WITHDRAW_DELEGATOR_REWARD_TYPES,
+    MSG_BEGIN_REDELEGATE_TYPES,
+    MSG_DELEGATE_TYPES,
+    MSG_SEND_TYPES,
+    MSG_UNDELEGATE_TYPES,
+    MSG_VOTE_TYPES,
+    IBC_MSG_TRANSFER_TYPES,
+    MSG_WITHDRAW_VALIDATOR_COMMISSION_TYPES,
+} from "@tharsis/eip712"
+
+export interface MessageAdapter {
+    toProto(message: EncodeObject): object
+    getTypes: ()=> object
+}
+
+export class WithdrawMessageAdapter implements MessageAdapter {
+    toProto(message: EncodeObject) {
+        const param = message.value
+        return createMsgWithdrawDelegatorReward(param.delegatorAddress, param.validatorAddress)
+    }
+    getTypes() {
+        return MSG_WITHDRAW_DELEGATOR_REWARD_TYPES
+    }
+}
+
+export class WithdrawCommissionMessageAdapter implements MessageAdapter {
+    toProto(message: EncodeObject) {
+        const param = message.value
+        return createMsgWithdrawDelegatorReward(param.delegatorAddress, param.validatorAddress)
+    }
+    getTypes() {
+        return MSG_WITHDRAW_VALIDATOR_COMMISSION_TYPES
+    }
+}
+
+export class BeginRedelegateMessageAdapter implements MessageAdapter {
+    toProto(message: EncodeObject) {
+        const param = message.value
+        return createMsgBeginRedelegate(
+            param.delegatorAddress, 
+            param.validatorSrcAddress, 
+            param.validatorDstAddress, 
+            param.amount.amount,
+            param.amount.denom)
+    }
+    getTypes() {
+        return MSG_BEGIN_REDELEGATE_TYPES
+    }
+}
+
+export class DelegateMessageAdapter implements MessageAdapter {
+    toProto(message: EncodeObject) {
+        const param = message.value
+        const amount = Array.isArray(param.amount) ? param.amount[0] : param.amount
+        return createMsgDelegate(param.delegatorAddress, param.validatorAddress, amount.amount, amount.denom)
+    }
+    getTypes() {
+        return MSG_DELEGATE_TYPES
+    }
+}
+
+export class SendMessageAdapter implements MessageAdapter {
+    toProto(message: EncodeObject) {
+        const param = message.value
+        const amount = Array.isArray(param.amount) ? param.amount[0] : param.amount
+        return createMsgSend(param.fromAddress, param.toAddress, amount.amount, amount.denom)
+    }
+    getTypes() {
+        return MSG_SEND_TYPES
+    }
+}
+
+export class UndelegateMessageAdapter implements MessageAdapter {
+    toProto(message: EncodeObject) {
+        const param = message.value
+        const amount = Array.isArray(param.amount) ? param.amount[0] : param.amount
+        return createMsgUndelegate(param.delegatorAddress, param.validatorAddress, amount.amount, amount.denom)
+    }
+    getTypes() {
+        return MSG_UNDELEGATE_TYPES
+    }
+}
+
+export class VoteMessageAdapter implements MessageAdapter {
+    toProto(message: EncodeObject) {
+        const param = message.value
+        return createMsgVote(param.proposalId, param.option, param.voter)
+    }
+    getTypes() {
+        return MSG_VOTE_TYPES
+    }
+}
+
+export class IBCMessageAdapter implements MessageAdapter {
+    toProto(message: EncodeObject) {
+        const param = message.value
+        return createIBCMsgTransfer(
+            param.sourcePort,
+            param.sourceChannel,
+            param.amount.amount,
+            param.amount.denom,
+            param.sender,
+            param.receiver,
+            param.revisionNumber,
+            param.revisionHeight,
+            param.timeoutTimestamp
+        )
+    }
+    getTypes() {
+        return IBC_MSG_TRANSFER_TYPES
+    }
+}
+
+
+export const defaultMessageAdapter: Record<string, MessageAdapter> = {
+    "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward": new WithdrawMessageAdapter(),
+    "/cosmos.staking.v1beta1.MsgDelegate": new DelegateMessageAdapter(),
+    "/cosmos.staking.v1beta1.MsgBeginRedelegate": new BeginRedelegateMessageAdapter(),
+    "/cosmos.staking.v1beta1.MsgUndelegate": new UndelegateMessageAdapter(),
+    "/cosmos.bank.v1beta1.MsgSend": new SendMessageAdapter(),
+    "/cosmos.gov.v1beta1.MsgVote": new VoteMessageAdapter(),
+    "/ibc.applications.transfer.v1.MsgTransfer": new IBCMessageAdapter(),
+    "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission": new WithdrawCommissionMessageAdapter()
+}

package/lib/wallet/UniClient.ts

@@ -0,0 +1,152 @@
+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";
+import { TimeoutError, createAminoTypes, createRegistry, defined, getRPC } from "@initia/utils"
+export function isEthermint(chainId: string) {
+  return chainId.search(/\w+_\d+-\d+/g) > -1
+}
+
+
+export class UniClient {
+    registry: Registry
+    wallet: AbstractWallet
+    aminoTypes: any;
+    createAminoConverters = createAminoTypes()
+    constructor(name: WalletName, arg: WalletArgument) {
+      this.registry = createRegistry();
+      //this.registry = new Registry([...defaultRegistryTypes, ...wasmTypes])
+      this.wallet = createWallet(name, arg, this.registry)
+      this.aminoTypes = createAminoTypes();
+    }
+
+    async getAccounts() {
+        return this.wallet.getAccounts()
+    }
+
+    async sign(transaction: Transaction): Promise<TxRaw | TxResponse> {
+        // 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: string, 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

@@ -0,0 +1,138 @@
+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";
+import { InitiaWallet } from './wallets/InitiaWallet';
+
+
+
+export enum WalletName {
+    Keplr = "Keplr",
+    Initia = "Initia Wallet",
+    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,
+    endpoint?: 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) {
+        case chainId.search(/\w+_\d+-\d+/g) > -1:   // ethermint like chain: evmos_9002-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";
+            case chainId.startsWith("stratos"):
+                return "/stratos.crypto.v1.ethsecp256k1.PubKey";
+        default:
+            return "/cosmos.crypto.secp256k1.PubKey"
+    }
+}
+
+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.Initia:
+            return new InitiaWallet(arg, <IChain>chain, 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/InitiaWallet.ts

@@ -0,0 +1,189 @@
+import { fromBase64, fromHex } from '@cosmjs/encoding';
+import { makeAuthInfoBytes, makeSignBytes, makeSignDoc, Registry, TxBodyEncodeObject } from '@cosmjs/proto-signing';
+
+import { AbstractWallet, Account, IChain, WalletArgument, WalletName, keyType } from '../Wallet';
+import { Transaction, TxResponse } 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, createIbcAminoConverters } from '@cosmjs/stargate';
+import { makeSignDoc as makeSignDocAmino } from '@cosmjs/amino';
+import { createWasmAminoConverters } from '@cosmjs/cosmwasm-stargate';
+import { Buffer } from 'buffer';
+import { TimeoutError, createAminoTypes, createRegistry, defined, getRPC } from "@initia/utils"
+import { serializeSignDoc } from '@cosmjs/amino/build/signdoc';
+import { Signature } from '@initia/initia.js';
+declare global {
+  interface Window {
+      initia: any; // Adjust the type as needed
+  }
+}
+export class InitiaWallet implements AbstractWallet {
+  name: WalletName.Initia = WalletName.Initia;
+  chainId: string;
+  chain: IChain;
+  registry: Registry;
+  conf: WalletArgument;
+  aminoTypes: any;
+  wallet: any;
+  connectEventNamesOnWindow: string[] = [];
+  createAminoConverters = createAminoTypes()
+  constructor(arg: WalletArgument, chain: IChain, registry: Registry) {
+    this.chainId = arg.chainId || "cosmoshub";
+    this.aminoTypes = createAminoTypes();
+    // @ts-ignore
+
+    this.registry = createRegistry();
+    this.conf = arg;
+    this.chain = chain;
+    this.wallet = window.initia;
+  }
+  async getAccounts(): Promise<Account[]> {
+    // const chainId = 'cosmoshub'
+    // @ts-ignore
+    await this.wallet.getOfflineSigner(this.chainId)
+    // @ts-ignore
+    const offlineSigner = this.wallet.getOfflineSigner(this.chainId)
+    return offlineSigner.getAccounts()
+}
+  supportCoinType(): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  isEthermint() {
+    return this.conf.hdPath && this.conf.hdPath.startsWith("m/44'/60");
+  }
+  // @deprecated use signAmino instead
+  // because signDirect is not supported ledger wallet
+  async sign(transaction: Transaction): Promise<TxResponse> {
+    const accouts = await this.getAccounts();
+
+    const accountFromSigner = accouts[0];
+    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);
+    console.log("txBodyBytes: ", this.registry);
+    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
+    );
+    console.log("signDoc: ", signDoc);
+
+    const signDocBuffer = makeSignBytes(signDoc);
+
+    const signString = new TextDecoder().decode(signDocBuffer);
+
+    // @ts-ignore
+    const signature = await this.wallet.signAndBroadcastBlock(this.chainId, txBodyBytes, gasLimit);
+    console.log("result22: ", signature);
+
+    const signed = signDoc;
+    console.log("signed: ", signed);
+    const res: TxResponse = {
+      txhash: signature.transactionHash,
+      codespace: signature.codespace,
+      code: signature.code,
+      raw_log: signature.rawLog,
+      height: signature.height,
+      data: signature.data,
+  //    bodyBytes: signed.bodyBytes,
+   //   authInfoBytes: signed.authInfoBytes,
+   //   signatures: [fromBase64(signature)],
+    };
+    return res
+  }
+
+  async signAmino(tx: Transaction): Promise<TxRaw> {
+    const accouts = await this.getAccounts();
+
+    const accountFromSigner = accouts[0];
+    if (!accountFromSigner) {
+      throw new Error("Failed to retrieve account from signer");
+    }
+    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
+    );
+
+    const signed = signDoc;
+
+    const signDocBuffer = serializeSignDoc(signDoc);
+
+    const signString = Buffer.from(signDocBuffer).toString();
+
+    // @ts-ignore
+
+    const signature = await window.initia.signArbitrary(signString);
+    console.log("signature: ", signature);
+
+    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)],
+    });
+  }
+}