@mictonode/widget 0.3.16 → 0.3.18

package/lib/wallet/EthermintMessageAdapter.ts

@@ -1,136 +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()
+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

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