@mictonode/widget 0.3.9

package/lib/wallet/wallets/KeplerWallet.ts

@@ -0,0 +1,158 @@
+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 { TxRaw } from "@initia/initia.proto/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";
+
+import { SignDoc } from "@initia/initia.js";
+
+import { TimeoutError, createAminoTypes, createRegistry, defined, getRPC } from "@initia/utils"
+
+
+
+
+export class KeplerWallet implements AbstractWallet {
+    aminoTypes: any;
+    name: WalletName.Keplr
+    chainId: string
+    registry: Registry
+    conf: WalletArgument
+    createAminoConverters = createAminoTypes()    
+    constructor(arg: WalletArgument, registry: Registry) {
+        this.chainId = arg.chainId || "initia"
+        this.aminoTypes = createAminoTypes();
+        // @ts-ignore
+        if (!window.getOfflineSigner || !window.keplr) {
+            throw new Error('Please install keplr extension')
+        }
+        this.registry = createRegistry();
+        this.conf = arg;
+        this.name = WalletName.Keplr;
+    }
+    
+    
+    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 accounts = await this.getAccounts();
+        const hex = toHex(fromBech32(tx.signerAddress).data);
+        const accountFromSigner = accounts.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(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: any) => 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)],
+        });
+    }
+}

package/lib/wallet/wallets/LeapWallet.ts

@@ -0,0 +1,142 @@
+import { fromBase64, fromBech32, toHex } from "@cosmjs/encoding";
+import { OfflineSigner, 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 LeapWallet implements AbstractWallet {
+    name: WalletName.Leap
+    chainId: string
+    registry: Registry
+    conf: WalletArgument
+    signer: OfflineSigner
+    aminoTypes = new AminoTypes( {...createDefaultAminoConverters(), ...createWasmAminoConverters()})
+    constructor(arg: WalletArgument, registry: Registry) {
+        this.chainId = arg.chainId || "cosmoshub"
+        // @ts-ignore
+        if (!window.getOfflineSigner || !window.leap) {
+            throw new Error('Please install Leap extension')
+        }
+        this.registry = registry
+        this.conf = arg
+    }
+    async getAccounts(): Promise<Account[]> {
+        // const chainId = 'cosmoshub'
+        // @ts-ignore
+        await window.leap.enable(this.chainId);
+
+        // @ts-ignore
+        this.signer = await window.leap.getOfflineSigner(this.chainId);
+        const accounts = await this.signer.getAccounts();
+        return accounts.map(account => ({ ...account }));
+    }
+    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> {
+        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 = await window.leap.getOfflineSignerAuto(this.chainId);
+        // console.log(offlineSigner)
+        const { signature, signed } = await this.signer.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 this.signer.signAmino(tx.signerAddress, signDoc);
+
+        console.log(signature, 'signature', signed)
+
+        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)],
+        });
+    }
+}

package/lib/wallet/wallets/LedgerWallet.ts

@@ -0,0 +1,203 @@
+import { fromBase64, fromBech32, toHex, toBech32, toBase64 } from "@cosmjs/encoding";
+import { Registry, TxBodyEncodeObject, encodePubkey, makeAuthInfoBytes } from "@cosmjs/proto-signing"
+import { AbstractWallet, Account, DEFAULT_HDPATH, WalletArgument, WalletName, extractChainId } from "../Wallet"
+import { AminoTypes, createDefaultAminoConverters } from "@cosmjs/stargate"
+import TransportWebUSB from "@ledgerhq/hw-transport-webusb"
+import TransportWebBLE from "@ledgerhq/hw-transport-web-ble"
+import { LedgerSigner } from "@cosmjs/ledger-amino"
+import { Transaction } from "../../utils/type"
+import { Chain, createTxRawEIP712, signatureToWeb3Extension } from "@tharsis/transactions";
+import { createEIP712, generateFee, generateMessageWithMultipleTransactions, generateTypes } from "@tharsis/eip712";
+import { defaultMessageAdapter } from "../EthermintMessageAdapter";
+import { createTransactionWithMultipleMessages } from "@tharsis/proto";
+import { encodeSecp256k1Pubkey, makeSignDoc as makeSignDocAmino } from "@cosmjs/amino";
+import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { stringToPath } from '@cosmjs/crypto'
+import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
+import { ethermintToEth } from "../../utils/format";
+import { createWasmAminoConverters } from "@cosmjs/cosmwasm-stargate";
+
+export class LedgerWallet implements AbstractWallet {
+    name: WalletName.Ledger
+    transport: string
+    hdPath: string
+    registry: Registry
+    aminoTypes = new AminoTypes({...createDefaultAminoConverters(), ...createWasmAminoConverters()})
+    conf: WalletArgument
+    constructor(arg: WalletArgument, registry: Registry) {
+        this.transport = arg.transport || 'usb'
+        this.hdPath = arg.hdPath || DEFAULT_HDPATH
+        this.registry = registry
+        this.conf = arg
+    }
+
+    async getSigner() {
+        const transport = this.transport === 'usb' ? await TransportWebUSB.create() : await TransportWebBLE.create()
+        // extract Cointype from from HDPath
+        const hdPath = stringToPath(this.hdPath)
+        const coinType = Number(hdPath[1])
+        let ledgerAppName = 'Cosmos'
+        switch (coinType) {
+            case 60:
+               throw new Error("Not support.")
+            case 529:
+                ledgerAppName = 'Secret' // 'Secret'
+                break
+            case 852:
+                ledgerAppName = 'Desmos' // 'Desmos'
+                break
+            case 330:
+                ledgerAppName = 'Terra' // 'Terra'
+                break
+            case 118:
+            default:
+        }
+        // const path = stringToPath(this.hdPath)
+        return new LedgerSigner(transport, { ledgerAppName, hdPaths: [hdPath] })
+    }
+
+    async getAccounts(): Promise<Account[]> {
+        const signer = await this.getSigner();
+        const account = (await signer.getAccounts()).map(x => ({
+            address: x.address,
+            algo: x.algo,
+            pubkey: x.pubkey,
+        }))
+        return account
+    }
+    supportCoinType(coinType?: string | undefined): Promise<boolean> {
+        return Promise.resolve(true);
+    }
+    isEthermint() {
+        return this.conf.hdPath && this.conf.hdPath.startsWith("m/44'/60")
+    }
+
+    async sign(tx: Transaction): Promise<TxRaw | Uint8Array> {
+        // if (this.isEthermint()) {
+        //     return this.sign712(tx)
+        // }
+        return this.signAmino(tx)
+    }
+
+    // not finished, due to the outdated dependency.
+    async sign712(tx: Transaction): Promise<Uint8Array> {
+        const chain: Chain = {
+            chainId: extractChainId(tx.signerData.chainId),
+            cosmosChainId: tx.chainId,
+        }
+
+        const signer = await this.getSigner()
+        const ethAddr = ethermintToEth(tx.signerAddress)
+
+        // this.signer.prefix = fromBech32(signerAddress).prefix
+        const account = await signer.getAccounts()
+
+        const acc = account.find(x => x.address === ethAddr)
+        if (!acc) {
+            throw new Error('The signer address dose not exsits in Ledger!')
+        }
+        const sender = {
+            accountAddress: tx.signerAddress,
+            sequence: tx.signerData.sequence,
+            accountNumber: tx.signerData.accountNumber,
+            pubkey: toBase64(account[0].pubkey),
+        }
+
+        const fees = generateFee(tx.fee.amount[0].amount, tx.fee.amount[0].denom, tx.fee.gas, tx.signerAddress)
+
+        const msgs = tx.messages.map(x => this.aminoTypes.toAmino(x))
+        const toSignTx = generateMessageWithMultipleTransactions(
+            sender.accountNumber.toString(),
+            sender.sequence.toString(),
+            tx.signerData.chainId,
+            tx.memo,
+            fees,
+            msgs,
+        )
+
+        const types = generateTypes(defaultMessageAdapter[tx.messages[0].typeUrl].getTypes())
+        const eip = createEIP712(types, chain.chainId, toSignTx)
+
+        // @ts-ignore
+        const sig = await this.getSigner().sign712(eip)
+
+        const rawTx = this.makeRawTxEvmos(sender, tx.messages, tx.memo, tx.fee, sig, chain)
+        return rawTx
+    }
+
+    makeRawTxEvmos(sender, messages, memo, fee, signature, chain): Uint8Array {
+        /// evmos style
+        /// *
+        const protoMsgs = messages.map(x => {
+          const adapter = defaultMessageAdapter[x.typeUrl]
+          return adapter.toProto(x)
+        })
+      
+        const evmos = createTransactionWithMultipleMessages(
+          protoMsgs,
+          memo,
+          fee.amount[0].amount,
+          fee.amount[0].denom,
+          Number(fee.gas),
+          'ethsecp256',
+          sender.pubkey,
+          sender.sequence,
+          sender.accountNumber,
+          chain.cosmosChainId,
+        )
+      
+        const extension = signatureToWeb3Extension(chain, sender, signature)
+      
+        // Create the txRaw
+        const prototx = createTxRawEIP712(evmos.legacyAmino.body, evmos.legacyAmino.authInfo, extension)
+        return prototx.message.serializeBinary()
+        /// end of EVMOS style */
+    }
+      
+
+    async signAmino(tx: Transaction): Promise<TxRaw> {
+        const signer = await this.getSigner();
+        // assert(!isOfflineDirectSigner(signer));
+
+        const accounts = await this.getAccounts()
+        const {data} = fromBech32(tx.signerAddress)
+        const hex = toHex(data)
+        const signerAddress = toBech32("cosmos", data)
+        const accountFromSigner = accounts.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 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 { signature, signed } = await signer.signAmino(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)],
+        });
+    }
+
+}

package/lib/wallet/wallets/MetamaskSnapWallet.ts

@@ -0,0 +1,105 @@
+import {
+    AbstractWallet,
+    Account,
+    WalletArgument,
+    WalletName,
+    keyType,
+} from '../Wallet';
+import {
+    fromBase64,
+    fromBech32,
+    toHex,
+} from '@cosmjs/encoding';
+import {
+    Registry,
+    TxBodyEncodeObject,
+    makeAuthInfoBytes,
+    makeSignDoc,
+} from '@cosmjs/proto-signing';
+import { Transaction } from '../../utils/type';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+// import { AminoTypes, createDefaultAminoConverters } from '@cosmjs/stargate';
+import { Any } from 'cosmjs-types/google/protobuf/any';
+import { PubKey } from 'cosmjs-types/cosmos/crypto/secp256k1/keys';
+
+import { connectSnap, getKey, getSnap, CosmjsOfflineSigner } from '@leapwallet/cosmos-snap-provider';
+// import { createWasmAminoConverters } from "@cosmjs/cosmwasm-stargate";
+
+export class MetamaskSnapWallet implements AbstractWallet {
+    name: WalletName.MetamaskSnap;
+    chainId: string;
+    registry: Registry;
+    prefix: string;    
+    // aminoTypes = new AminoTypes( {...createDefaultAminoConverters(), ...createWasmAminoConverters()});
+
+    constructor(arg: WalletArgument, registry: Registry) {
+        this.chainId = arg.chainId || 'cosmoshub';
+        this.registry = registry;
+        this.prefix = arg.prefix || 'cosmos';
+    }
+
+    async getAccounts(): Promise<Account[]> {
+        const snapInstalled = await getSnap().catch(() => {
+            throw new Error('Metamask snap not installed');
+        });
+        if (!snapInstalled) {
+            await connectSnap()
+        }
+        const key = await getKey(this.chainId)
+        return [key]
+    }
+
+    async supportCoinType(coinType?: string): Promise<boolean> {
+        return true;
+    }
+
+    async sign(transaction: Transaction): Promise<TxRaw | Uint8Array> {
+        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: new Uint8Array(Object.values(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
+        );
+
+        const offlineSigner = new CosmjsOfflineSigner(this.chainId);
+        const { signature, signed } = await offlineSigner.signDirect(transaction.signerAddress, signDoc);
+
+        return TxRaw.fromPartial({
+            bodyBytes: signed.bodyBytes,
+            authInfoBytes: signed.authInfoBytes,
+            signatures: [fromBase64(signature.signature)],
+        });
+    }
+}