@ark-us/wasmx-stargate 0.0.10 → 0.0.12

package/src/signingwasmxclient.ts

@@ -1,660 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { encodeSecp256k1Pubkey, makeSignDoc as makeSignDocAmino } from "@cosmjs/amino";
-import { sha256 } from "@cosmjs/crypto";
-import { fromBase64, toHex, toUtf8 } from "@cosmjs/encoding";
-import { Int53, Uint53 } from "@cosmjs/math";
-import {
-  EncodeObject,
-  encodePubkey,
-  isOfflineDirectSigner,
-  makeAuthInfoBytes,
-  makeSignDoc,
-  OfflineSigner,
-  Registry,
-  TxBodyEncodeObject,
-} from "@cosmjs/proto-signing";
-import {
-  AminoTypes,
-  calculateFee,
-  Coin,
-  createBankAminoConverters,
-  defaultRegistryTypes as defaultStargateTypes,
-  DeliverTxResponse,
-  Event,
-  GasPrice,
-  isDeliverTxFailure,
-  logs,
-  MsgDelegateEncodeObject,
-  MsgSendEncodeObject,
-  MsgUndelegateEncodeObject,
-  MsgWithdrawDelegatorRewardEncodeObject,
-  SignerData,
-  StdFee,
-} from "@cosmjs/stargate";
-import { HttpEndpoint, Tendermint34Client } from "@cosmjs/tendermint-rpc";
-import {TendermintClient} from './tendermintclient';
-import { assert, assertDefined } from "@cosmjs/utils";
-import { MsgWithdrawDelegatorReward } from "cosmjs-types/cosmos/distribution/v1beta1/tx";
-import { MsgDelegate, MsgUndelegate } from "cosmjs-types/cosmos/staking/v1beta1/tx";
-import { SignMode } from "cosmjs-types/cosmos/tx/signing/v1beta1/signing";
-import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
-import {
-  MsgExecuteContract,
-  MsgInstantiateContract,
-  MsgStoreCode,
-  MsgDeployCode,
-  CodeMetadata,
-} from "@ark-us/wasmxjs";
-import Long from 'long';
-import pako from "pako";
-
-import { WasmXClient } from "./wasmxclient";
-import {
-  createWasmAminoConverters,
-  JsonObject,
-  MsgExecuteContractEncodeObject,
-  MsgInstantiateContractEncodeObject,
-  MsgStoreCodeEncodeObject,
-  MsgDeployCodeEncodeObject,
-  wasmTypes,
-} from "./modules";
-
-export interface UploadResult {
-  /** Size of the original wasm code in bytes */
-  readonly originalSize: number;
-  /** A hex encoded sha256 checksum of the original wasm code (that is stored on chain) */
-  readonly originalChecksum: string;
-  /** Size of the compressed wasm code in bytes */
-  readonly compressedSize: number;
-  /** A hex encoded sha256 checksum of the compressed wasm code (that stored in the transaction) */
-  readonly compressedChecksum: string;
-  /** The ID of the code asigned by the chain */
-  readonly codeId: number;
-  readonly logs: readonly logs.Log[];
-  /** Block height in which the transaction is included */
-  readonly height: number;
-  /** Transaction hash (might be used as transaction ID). Guaranteed to be non-empty upper-case hex */
-  readonly transactionHash: string;
-  readonly events: readonly Event[];
-  readonly gasWanted: number;
-  readonly gasUsed: number;
-}
-
-export interface DeployResult {
-  readonly checksum: string;
-  /** The ID of the code asigned by the chain */
-  readonly codeId: number;
-  readonly contractAddress: string;
-  readonly logs: readonly logs.Log[];
-  /** Block height in which the transaction is included */
-  readonly height: number;
-  /** Transaction hash (might be used as transaction ID). Guaranteed to be non-empty upper-case hex */
-  readonly transactionHash: string;
-  readonly events: readonly Event[];
-  readonly gasWanted: number;
-  readonly gasUsed: number;
-}
-
-/**
- * The options of an .instantiate() call.
- * All properties are optional.
- */
-export interface InstantiateOptions {
-  readonly memo?: string;
-  /**
-   * The funds that are transferred from the sender to the newly created contract.
-   * The funds are transferred as part of the message execution after the contract address is
-   * created and before the instantiation message is executed by the contract.
-   *
-   * Only native tokens are supported.
-   */
-  readonly funds?: readonly Coin[];
-}
-
-export interface InstantiateResult {
-  /** The address of the newly instantiated contract */
-  readonly contractAddress: string;
-  readonly logs: readonly logs.Log[];
-  /** Block height in which the transaction is included */
-  readonly height: number;
-  /** Transaction hash (might be used as transaction ID). Guaranteed to be non-empty upper-case hex */
-  readonly transactionHash: string;
-  readonly events: readonly Event[];
-  readonly gasWanted: number;
-  readonly gasUsed: number;
-}
-
-/**
- * Result type of updateAdmin and clearAdmin
- */
-export interface ChangeAdminResult {
-  readonly logs: readonly logs.Log[];
-  /** Block height in which the transaction is included */
-  readonly height: number;
-  /** Transaction hash (might be used as transaction ID). Guaranteed to be non-empty upper-case hex */
-  readonly transactionHash: string;
-  readonly events: readonly Event[];
-  readonly gasWanted: number;
-  readonly gasUsed: number;
-}
-
-export interface MigrateResult {
-  readonly logs: readonly logs.Log[];
-  /** Block height in which the transaction is included */
-  readonly height: number;
-  /** Transaction hash (might be used as transaction ID). Guaranteed to be non-empty upper-case hex */
-  readonly transactionHash: string;
-  readonly events: readonly Event[];
-  readonly gasWanted: number;
-  readonly gasUsed: number;
-}
-
-export interface ExecuteInstruction {
-  contractAddress: string;
-  msg: JsonObject;
-  funds?: readonly Coin[];
-}
-
-export interface ExecuteResult {
-  readonly logs: readonly logs.Log[];
-  /** Block height in which the transaction is included */
-  readonly height: number;
-  /** Transaction hash (might be used as transaction ID). Guaranteed to be non-empty upper-case hex */
-  readonly transactionHash: string;
-  readonly events: readonly Event[];
-  readonly gasWanted: number;
-  readonly gasUsed: number;
-}
-
-function createDeliverTxResponseErrorMessage(result: DeliverTxResponse): string {
-  return `Error when broadcasting tx ${result.transactionHash} at height ${result.height}. Code: ${result.code}; Raw log: ${result.rawLog}`;
-}
-
-function createDefaultRegistry(): Registry {
-  return new Registry([...defaultStargateTypes, ...wasmTypes]);
-}
-
-export interface SigningWasmXClientOptions {
-  readonly registry?: Registry;
-  readonly aminoTypes?: AminoTypes;
-  readonly broadcastTimeoutMs?: number;
-  readonly broadcastPollIntervalMs?: number;
-  readonly gasPrice?: GasPrice;
-}
-
-export class SigningWasmXClient extends WasmXClient {
-  public readonly registry: Registry;
-  public readonly broadcastTimeoutMs: number | undefined;
-  public readonly broadcastPollIntervalMs: number | undefined;
-
-  private readonly signer: OfflineSigner;
-  private readonly aminoTypes: AminoTypes;
-  private readonly gasPrice: GasPrice | undefined;
-
-  /**
-   * Creates an instance by connecting to the given Tendermint RPC endpoint.
-   *
-   * For now this uses the Tendermint 0.34 client. If you need Tendermint 0.37
-   * support, see `createWithSigner`.
-   */
-  public static async connectWithSigner(
-    endpoint: string | HttpEndpoint,
-    signer: OfflineSigner,
-    options: SigningWasmXClientOptions = {},
-  ): Promise<SigningWasmXClient> {
-    const tmClient = await Tendermint34Client.connect(endpoint);
-    return SigningWasmXClient.createWithSigner(tmClient, signer, options);
-  }
-
-  /**
-   * Creates an instance from a manually created Tendermint client.
-   * Use this to use `Tendermint37Client` instead of `Tendermint34Client`.
-   */
-  public static async createWithSigner(
-    tmClient: TendermintClient,
-    signer: OfflineSigner,
-    options: SigningWasmXClientOptions = {},
-  ): Promise<SigningWasmXClient> {
-    return new SigningWasmXClient(tmClient, signer, options);
-  }
-
-  /**
-   * Creates a client in offline mode.
-   *
-   * This should only be used in niche cases where you know exactly what you're doing,
-   * e.g. when building an offline signing application.
-   *
-   * When you try to use online functionality with such a signer, an
-   * exception will be raised.
-   */
-  public static async offline(
-    signer: OfflineSigner,
-    options: SigningWasmXClientOptions = {},
-  ): Promise<SigningWasmXClient> {
-    return new SigningWasmXClient(undefined, signer, options);
-  }
-
-  protected constructor(
-    tmClient: TendermintClient | undefined,
-    signer: OfflineSigner,
-    options: SigningWasmXClientOptions,
-  ) {
-    super(tmClient);
-    const {
-      registry = createDefaultRegistry(),
-      aminoTypes = new AminoTypes({ ...createWasmAminoConverters(), ...createBankAminoConverters() }),
-    } = options;
-    this.registry = registry;
-    this.aminoTypes = aminoTypes;
-    this.signer = signer;
-    this.broadcastTimeoutMs = options.broadcastTimeoutMs;
-    this.broadcastPollIntervalMs = options.broadcastPollIntervalMs;
-    this.gasPrice = options.gasPrice;
-  }
-
-  public async simulate(
-    signerAddress: string,
-    messages: readonly EncodeObject[],
-    memo: string | undefined,
-  ): Promise<number> {
-    const anyMsgs = messages.map((m) => this.registry.encodeAsAny(m));
-    const accountFromSigner = (await this.signer.getAccounts()).find(
-      (account) => account.address === signerAddress,
-    );
-    if (!accountFromSigner) {
-      throw new Error("Failed to retrieve account from signer");
-    }
-    const pubkey = encodeSecp256k1Pubkey(accountFromSigner.pubkey);
-    const { sequence } = await this.getSequence(signerAddress);
-    const { gasInfo } = await this.forceGetQueryClient().tx.simulate(anyMsgs, memo, pubkey, sequence);
-    assertDefined(gasInfo);
-    return Uint53.fromString(gasInfo.gasUsed.toString()).toNumber();
-  }
-
-  /** Uploads code and returns a receipt, including the code ID */
-  public async upload(
-    senderAddress: string,
-    wasmCode: Uint8Array,
-    deps: string[],
-    metadata: object,
-    fee: StdFee | "auto" | number,
-    memo = "",
-  ): Promise<UploadResult> {
-    const compressed = pako.gzip(wasmCode, { level: 9 });
-    const storeCodeMsg: MsgStoreCodeEncodeObject = {
-      typeUrl: "/mythos.wasmx.v1.MsgStoreCode",
-      value: MsgStoreCode.fromPartial({
-        sender: senderAddress,
-        byteCode: compressed,
-        deps: deps,
-        metadata: CodeMetadata.fromPartial(metadata),
-      }),
-    };
-
-    const result = await this.signAndBroadcast(senderAddress, [storeCodeMsg], fee, memo);
-    if (isDeliverTxFailure(result)) {
-      throw new Error(createDeliverTxResponseErrorMessage(result));
-    }
-    console.log("result", result);
-    const parsedLogs = logs.parseRawLog(result.rawLog || "[]");
-    // const codeIdAttr = logs.findAttribute(parsedLogs, "store_code", "code_id");
-    const storeCodeEvent = result.events.find((ev: any) => ev.type === "store_code")
-    if (!storeCodeEvent) throw new Error("No store_code event found in receipt: " + JSON.stringify(result));
-    const codeIdAttr = storeCodeEvent.attributes.find((attr: any) => attr.key === "code_id");
-    if (!codeIdAttr) throw new Error("No code_id attribute found in event: " + JSON.stringify(result));
-    return {
-      originalSize: wasmCode.length,
-      originalChecksum: toHex(sha256(wasmCode)),
-      compressedSize: compressed.length,
-      compressedChecksum: toHex(sha256(compressed)),
-      codeId: Number.parseInt(codeIdAttr.value, 10),
-      logs: parsedLogs,
-      height: result.height,
-      transactionHash: result.transactionHash,
-      events: result.events,
-      gasWanted: result.gasWanted,
-      gasUsed: result.gasUsed,
-    };
-  }
-
-  /** Uploads code and returns a receipt, including the code ID */
-  public async deployCode(
-    senderAddress: string,
-    code: Uint8Array,
-    metadata: object,
-    deps: string[],
-    msg: JsonObject,
-    label: string,
-    fee: StdFee | "auto" | number,
-    options: InstantiateOptions = {},
-  ): Promise<DeployResult> {
-    const storeCodeEvmMsg: MsgDeployCodeEncodeObject = {
-      typeUrl: "/mythos.wasmx.v1.MsgDeployCode",
-      value: MsgDeployCode.fromPartial({
-        sender: senderAddress,
-        byteCode: code,
-        metadata: CodeMetadata.fromPartial(metadata),
-        deps: deps,
-        label: label,
-        msg: toUtf8(JSON.stringify(msg)),
-        funds: [...(options.funds || [])],
-      }),
-    };
-
-    const result = await this.signAndBroadcast(senderAddress, [storeCodeEvmMsg], fee, options.memo);
-    if (isDeliverTxFailure(result)) {
-      throw new Error(createDeliverTxResponseErrorMessage(result));
-    }
-    const parsedLogs = logs.parseRawLog(result.rawLog || "[]");
-
-    // const codeIdAttr = logs.findAttribute(parsedLogs, "store_code", "code_id");
-    const storeCodeEvent = result.events.find((ev: any) => ev.type === "store_code")
-    if (!storeCodeEvent) throw new Error("No store_code event found in receipt: " + JSON.stringify(result));
-    const codeIdAttr = storeCodeEvent.attributes.find((attr: any) => attr.key === "code_id");
-    if (!codeIdAttr) throw new Error("No code_id attribute found in store_code event: " + JSON.stringify(result));
-
-    // const contractAddress = logs.findAttribute(parsedLogs, "instantiate", "contract_address");
-    const instantiateEvent = result.events.find((ev: any) => ev.type === "instantiate")
-    if (!instantiateEvent) throw new Error("No instantiate event found in receipt: " + JSON.stringify(result));
-    const contractAddress = instantiateEvent.attributes.find((attr: any) => attr.key === "contract_address");
-    if (!contractAddress) throw new Error("No contract_address attribute found in instantiate event: " + JSON.stringify(result));
-
-    return {
-      checksum: toHex(sha256(code)),
-      codeId: Number.parseInt(codeIdAttr.value, 10),
-      contractAddress: contractAddress.value,
-      logs: parsedLogs,
-      height: result.height,
-      transactionHash: result.transactionHash,
-      events: result.events,
-      gasWanted: result.gasWanted,
-      gasUsed: result.gasUsed,
-    };
-  }
-
-  public async instantiate(
-    senderAddress: string,
-    codeId: number,
-    msg: JsonObject,
-    label: string,
-    fee: StdFee | "auto" | number,
-    options: InstantiateOptions = {},
-  ): Promise<InstantiateResult> {
-    const instantiateContractMsg: MsgInstantiateContractEncodeObject = {
-      typeUrl: "/mythos.wasmx.v1.MsgInstantiateContract",
-      value: MsgInstantiateContract.fromPartial({
-        sender: senderAddress,
-        // @ts-ignore
-        codeId: Long.fromString(new Uint53(codeId).toString()),
-        label: label,
-        msg: toUtf8(JSON.stringify(msg)),
-        funds: [...(options.funds || [])],
-      }),
-    };
-    const result = await this.signAndBroadcast(senderAddress, [instantiateContractMsg], fee, options.memo);
-    if (isDeliverTxFailure(result)) {
-      throw new Error(createDeliverTxResponseErrorMessage(result));
-    }
-    const parsedLogs = logs.parseRawLog(result.rawLog || "[]");
-
-    // const contractAddressAttr = logs.findAttribute(parsedLogs, "instantiate", "contract_address");
-    const instantiateEvent = result.events.find((ev: any) => ev.type === "instantiate")
-    if (!instantiateEvent) throw new Error("No instantiate event found in receipt: " + JSON.stringify(result));
-    const contractAddressAttr = instantiateEvent.attributes.find((attr: any) => attr.key === "contract_address");
-    if (!contractAddressAttr) throw new Error("No contract_address attribute found in instantiate event: " + JSON.stringify(result));
-
-    return {
-      contractAddress: contractAddressAttr.value,
-      logs: parsedLogs,
-      height: result.height,
-      transactionHash: result.transactionHash,
-      events: result.events,
-      gasWanted: result.gasWanted,
-      gasUsed: result.gasUsed,
-    };
-  }
-
-  public async execute(
-    senderAddress: string,
-    contractAddress: string,
-    msg: JsonObject,
-    fee: StdFee | "auto" | number,
-    memo = "",
-    funds?: readonly Coin[],
-  ): Promise<ExecuteResult> {
-    const instruction: ExecuteInstruction = {
-      contractAddress: contractAddress,
-      msg: msg,
-      funds: funds,
-    };
-    return this.executeMultiple(senderAddress, [instruction], fee, memo);
-  }
-
-  /**
-   * Like `execute` but allows executing multiple messages in one transaction.
-   */
-  public async executeMultiple(
-    senderAddress: string,
-    instructions: readonly ExecuteInstruction[],
-    fee: StdFee | "auto" | number,
-    memo = "",
-  ): Promise<ExecuteResult> {
-    const msgs: MsgExecuteContractEncodeObject[] = instructions.map((i) => ({
-      typeUrl: "/mythos.wasmx.v1.MsgExecuteContract",
-      value: MsgExecuteContract.fromPartial({
-        sender: senderAddress,
-        contract: i.contractAddress,
-        msg: toUtf8(JSON.stringify(i.msg)),
-        funds: [...(i.funds || [])],
-      }),
-    }));
-    const result = await this.signAndBroadcast(senderAddress, msgs, fee, memo);
-    if (isDeliverTxFailure(result)) {
-      throw new Error(createDeliverTxResponseErrorMessage(result));
-    }
-    return {
-      logs: logs.parseRawLog(result.rawLog || "[]"),
-      height: result.height,
-      transactionHash: result.transactionHash,
-      events: result.events,
-      gasWanted: result.gasWanted,
-      gasUsed: result.gasUsed,
-    };
-  }
-
-  public async sendTokens(
-    senderAddress: string,
-    recipientAddress: string,
-    amount: readonly Coin[],
-    fee: StdFee | "auto" | number,
-    memo = "",
-  ): Promise<DeliverTxResponse> {
-    const sendMsg: MsgSendEncodeObject = {
-      typeUrl: "/cosmos.bank.v1beta1.MsgSend",
-      value: {
-        fromAddress: senderAddress,
-        toAddress: recipientAddress,
-        amount: [...amount],
-      },
-    };
-    return this.signAndBroadcast(senderAddress, [sendMsg], fee, memo);
-  }
-
-  public async delegateTokens(
-    delegatorAddress: string,
-    validatorAddress: string,
-    amount: Coin,
-    fee: StdFee | "auto" | number,
-    memo = "",
-  ): Promise<DeliverTxResponse> {
-    const delegateMsg: MsgDelegateEncodeObject = {
-      typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
-      value: MsgDelegate.fromPartial({ delegatorAddress: delegatorAddress, validatorAddress, amount }),
-    };
-    return this.signAndBroadcast(delegatorAddress, [delegateMsg], fee, memo);
-  }
-
-  public async undelegateTokens(
-    delegatorAddress: string,
-    validatorAddress: string,
-    amount: Coin,
-    fee: StdFee | "auto" | number,
-    memo = "",
-  ): Promise<DeliverTxResponse> {
-    const undelegateMsg: MsgUndelegateEncodeObject = {
-      typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
-      value: MsgUndelegate.fromPartial({ delegatorAddress: delegatorAddress, validatorAddress, amount }),
-    };
-    return this.signAndBroadcast(delegatorAddress, [undelegateMsg], fee, memo);
-  }
-
-  public async withdrawRewards(
-    delegatorAddress: string,
-    validatorAddress: string,
-    fee: StdFee | "auto" | number,
-    memo = "",
-  ): Promise<DeliverTxResponse> {
-    const withdrawDelegatorRewardMsg: MsgWithdrawDelegatorRewardEncodeObject = {
-      typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
-      value: MsgWithdrawDelegatorReward.fromPartial({ delegatorAddress: delegatorAddress, validatorAddress }),
-    };
-    return this.signAndBroadcast(delegatorAddress, [withdrawDelegatorRewardMsg], fee, memo);
-  }
-
-  /**
-   * Creates a transaction with the given messages, fee and memo. Then signs and broadcasts the transaction.
-   *
-   * @param signerAddress The address that will sign transactions using this instance. The signer must be able to sign with this address.
-   * @param messages
-   * @param fee
-   * @param memo
-   */
-  public async signAndBroadcast(
-    signerAddress: string,
-    messages: readonly EncodeObject[],
-    fee: StdFee | "auto" | number,
-    memo = "",
-  ): Promise<DeliverTxResponse> {
-    let usedFee: StdFee;
-    if (fee == "auto" || typeof fee === "number") {
-      assertDefined(this.gasPrice, "Gas price must be set in the client options when auto gas is used.");
-      const gasEstimation = await this.simulate(signerAddress, messages, memo);
-      const multiplier = typeof fee === "number" ? fee : 1.3;
-      usedFee = calculateFee(Math.round(gasEstimation * multiplier), this.gasPrice);
-    } else {
-      usedFee = fee;
-    }
-    const txRaw = await this.sign(signerAddress, messages, usedFee, memo);
-    const txBytes = TxRaw.encode(txRaw).finish();
-    return this.broadcastTx(txBytes, this.broadcastTimeoutMs, this.broadcastPollIntervalMs);
-  }
-
-  public async sign(
-    signerAddress: string,
-    messages: readonly EncodeObject[],
-    fee: StdFee,
-    memo: string,
-    explicitSignerData?: SignerData,
-  ): Promise<TxRaw> {
-    let signerData: SignerData;
-    if (explicitSignerData) {
-      signerData = explicitSignerData;
-    } else {
-      const { accountNumber, sequence } = await this.getSequence(signerAddress);
-      const chainId = await this.getChainId();
-      signerData = {
-        accountNumber: accountNumber,
-        sequence: sequence,
-        chainId: chainId,
-      };
-    }
-
-    return isOfflineDirectSigner(this.signer)
-      ? this.signDirect(signerAddress, messages, fee, memo, signerData)
-      : this.signAmino(signerAddress, messages, fee, memo, signerData);
-  }
-
-  private async signAmino(
-    signerAddress: string,
-    messages: readonly EncodeObject[],
-    fee: StdFee,
-    memo: string,
-    { accountNumber, sequence, chainId }: SignerData,
-  ): Promise<TxRaw> {
-    assert(!isOfflineDirectSigner(this.signer));
-    const accountFromSigner = (await this.signer.getAccounts()).find(
-      (account) => account.address === signerAddress,
-    );
-    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 = messages.map((msg) => this.aminoTypes.toAmino(msg));
-    const signDoc = makeSignDocAmino(msgs, fee, chainId, memo, accountNumber, sequence);
-    const { signature, signed } = await this.signer.signAmino(signerAddress, signDoc);
-    const signedTxBody: TxBodyEncodeObject = {
-      typeUrl: "/cosmos.tx.v1beta1.TxBody",
-      value: {
-        messages: signed.msgs.map((msg) => this.aminoTypes.fromAmino(msg)),
-        memo: signed.memo,
-      },
-    };
-    const signedTxBodyBytes = this.registry.encode(signedTxBody);
-    const signedGasLimit = Int53.fromString(signed.fee.gas).toNumber();
-    const signedSequence = Int53.fromString(signed.sequence).toNumber();
-    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)],
-    });
-  }
-
-  private async signDirect(
-    signerAddress: string,
-    messages: readonly EncodeObject[],
-    fee: StdFee,
-    memo: string,
-    { accountNumber, sequence, chainId }: SignerData,
-  ): Promise<TxRaw> {
-    assert(isOfflineDirectSigner(this.signer));
-    const accountFromSigner = (await this.signer.getAccounts()).find(
-      (account) => account.address === signerAddress,
-    );
-    if (!accountFromSigner) {
-      throw new Error("Failed to retrieve account from signer");
-    }
-    const pubkey = encodePubkey(encodeSecp256k1Pubkey(accountFromSigner.pubkey));
-    const txBody: TxBodyEncodeObject = {
-      typeUrl: "/cosmos.tx.v1beta1.TxBody",
-      value: {
-        messages: messages,
-        memo: memo,
-      },
-    };
-    const txBodyBytes = this.registry.encode(txBody);
-    const gasLimit = Int53.fromString(fee.gas).toNumber();
-    const authInfoBytes = makeAuthInfoBytes(
-      [{ pubkey, sequence }],
-      fee.amount,
-      gasLimit,
-      fee.granter,
-      fee.payer,
-    );
-    const signDoc = makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber);
-    const { signature, signed } = await this.signer.signDirect(signerAddress, signDoc);
-    return TxRaw.fromPartial({
-      bodyBytes: signed.bodyBytes,
-      authInfoBytes: signed.authInfoBytes,
-      signatures: [fromBase64(signature.signature)],
-    });
-  }
-}

package/src/tendermintclient.ts

@@ -1,7 +0,0 @@
-import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
-
-export type TendermintClient = Tendermint34Client;
-
-export function isTendermint34Client(client: TendermintClient): client is Tendermint34Client {
-  return client instanceof Tendermint34Client;
-}