@tcswap/wallet-extensions 4.1.16

package/src/keplr/chainRegistry.ts

@@ -0,0 +1,240 @@
+import type { ChainInfo } from "@keplr-wallet/types";
+import { ChainId } from "@tcswap/helpers";
+
+export const chainRegistry = new Map<ChainId, ChainInfo>([
+  [
+    ChainId.Kujira,
+    {
+      bech32Config: {
+        bech32PrefixAccAddr: "kujira",
+        bech32PrefixAccPub: "kujirapub",
+        bech32PrefixConsAddr: "kujiravalcons",
+        bech32PrefixConsPub: "kujiravalconspub",
+        bech32PrefixValAddr: "kujiravaloper",
+        bech32PrefixValPub: "kujiravaloperpub",
+      },
+      bip44: { coinType: 118 },
+      chainId: "kaiyo-1",
+      chainName: "Kujira",
+      chainSymbolImageUrl:
+        "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/kaiyo/chain.png",
+      currencies: [
+        {
+          coinDecimals: 6,
+          coinDenom: "KUJI",
+          coinGeckoId: "kujira",
+          coinImageUrl: "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/kaiyo/ukuji.png",
+          coinMinimalDenom: "ukuji",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "USK",
+          coinGeckoId: "usk",
+          coinMinimalDenom: "factory/kujira1qk00h5atutpsv900x202pxx42npjr9thg58dnqpa72f2p7m2luase444a7/uusk",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "MNTA",
+          coinGeckoId: "mantadao",
+          coinMinimalDenom: "factory/kujira1643jxg8wasy5cfcn7xm8rd742yeazcksqlg4d7/umnta",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "bKUJI",
+          coinImageUrl:
+            "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/kaiyo/factory/kujira15e8q5wzlk5k38gjxlhse3vu6vqnafysncx2ltexd6y9gx50vuj2qpt7dgv/bKUJI.png",
+          coinMinimalDenom: "factory/kujira15e8q5wzlk5k38gjxlhse3vu6vqnafysncx2ltexd6y9gx50vuj2qpt7dgv/boneKuji",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "AQLA",
+          coinGeckoId: "aqualibre",
+          coinImageUrl:
+            "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/kaiyo/factory/kujira1xe0awk5planmtsmjel5xtx2hzhqdw5p8z66yqd/AQLA.png",
+          coinMinimalDenom: "factory/kujira1xe0awk5planmtsmjel5xtx2hzhqdw5p8z66yqd/uaqla",
+        },
+      ],
+      features: ["cosmwasm"],
+      feeCurrencies: [
+        {
+          coinDecimals: 6,
+          coinDenom: "KUJI",
+          coinGeckoId: "kujira",
+          coinImageUrl: "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/kaiyo/ukuji.png",
+          coinMinimalDenom: "ukuji",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "USK",
+          coinGeckoId: "usk",
+          coinMinimalDenom: "factory/kujira1qk00h5atutpsv900x202pxx42npjr9thg58dnqpa72f2p7m2luase444a7/uusk",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "axlUSDC",
+          coinGeckoId: "usd-coin",
+          coinMinimalDenom: "ibc/295548A78785A1007F232DE286149A6FF512F180AF5657780FC89C009E2C348F",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "ATOM",
+          coinGeckoId: "cosmos",
+          coinMinimalDenom: "ibc/27394FB092D2ECCD56123C74F36E4C1F926001CEADA9CA97EA622B25F41E5EB2",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "OSMO",
+          coinGeckoId: "osmosis",
+          coinMinimalDenom: "ibc/47BD209179859CDE4A2806763D7189B6E6FE13A17880FE2B42DE1E6C1E329E23",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "CMDX",
+          coinGeckoId: "comdex",
+          coinMinimalDenom: "ibc/3607EB5B5E64DD1C0E12E07F077FF470D5BC4706AFCBC98FE1BA960E5AE4CE07",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "EVMOS",
+          coinGeckoId: "evmos",
+          coinMinimalDenom: "ibc/F3AA7EF362EC5E791FE78A0F4CCC69FEE1F9A7485EB1A8CAB3F6601C00522F10",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "JUNO",
+          coinGeckoId: "juno-network",
+          coinMinimalDenom: "ibc/EFF323CC632EC4F747C61BCE238A758EFDB7699C3226565F7C20DA06509D59A5",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "MNTA",
+          coinGeckoId: "mantadao",
+          coinMinimalDenom: "factory/kujira1643jxg8wasy5cfcn7xm8rd742yeazcksqlg4d7/umnta",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "SCRT",
+          coinGeckoId: "secret",
+          coinMinimalDenom: "ibc/A358D7F19237777AF6D8AD0E0F53268F8B18AE8A53ED318095C14D6D7F3B2DB5",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "STARS",
+          coinGeckoId: "stargaze",
+          coinMinimalDenom: "ibc/4F393C3FCA4190C0A6756CE7F6D897D5D1BE57D6CCB80D0BC87393566A7B6602",
+        },
+        {
+          coinDecimals: 18,
+          coinDenom: "wAVAX",
+          coinGeckoId: "avalanche-2",
+          coinMinimalDenom: "ibc/004EBF085BBED1029326D56BE8A2E67C08CECE670A94AC1947DF413EF5130EB2",
+        },
+        {
+          coinDecimals: 18,
+          coinDenom: "wETH",
+          coinGeckoId: "ethereum",
+          coinMinimalDenom: "ibc/1B38805B1C75352B28169284F96DF56BDEBD9E8FAC005BDCC8CF0378C82AA8E7",
+        },
+      ],
+      nodeProvider: { email: "pfc-validator@protonmail.com", name: "PFC", website: "https://pfc.zone/" },
+      rest: "https://rest.cosmos.directory/kujira/",
+      rpc: "https://kujira-rpc.nodes.defiantlabs.net",
+      stakeCurrency: {
+        coinDecimals: 6,
+        coinDenom: "KUJI",
+        coinGeckoId: "kujira",
+        coinImageUrl: "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/kaiyo/ukuji.png",
+        coinMinimalDenom: "ukuji",
+      },
+    },
+  ],
+  [
+    ChainId.Noble,
+    {
+      bech32Config: {
+        bech32PrefixAccAddr: "noble",
+        bech32PrefixAccPub: "noblepub",
+        bech32PrefixConsAddr: "noblevalcons",
+        bech32PrefixConsPub: "noblevalconspub",
+        bech32PrefixValAddr: "noblevaloper",
+        bech32PrefixValPub: "noblevaloperpub",
+      },
+      bip44: { coinType: 118 },
+      chainId: "noble-1",
+      chainName: "Noble",
+      chainSymbolImageUrl:
+        "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/noble/chain.png",
+      currencies: [
+        {
+          coinDecimals: 6,
+          coinDenom: "USDC",
+          coinGeckoId: "usd-coin",
+          coinImageUrl: "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/noble/uusdc.png",
+          coinMinimalDenom: "uusdc",
+        },
+        { coinDecimals: 6, coinDenom: "USDN", coinGeckoId: "usd-coin", coinMinimalDenom: "uusdn" },
+      ],
+      features: ["cosmwasm"],
+      feeCurrencies: [
+        {
+          coinDecimals: 6,
+          coinDenom: "USDC",
+          coinGeckoId: "usd-coin",
+          coinImageUrl: "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/noble/uusdc.png",
+          coinMinimalDenom: "uusdc",
+        },
+        {
+          coinDecimals: 6,
+          coinDenom: "USDN",
+          coinGeckoId: "usd-coin",
+          coinMinimalDenom:
+            "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/noble/uusdn.png",
+        },
+      ],
+      rest: "https://lcd-noble.keplr.app",
+      rpc: "https://rpc-noble.keplr.app",
+    },
+  ],
+  [
+    ChainId.THORChain,
+    {
+      bech32Config: {
+        bech32PrefixAccAddr: "thor",
+        bech32PrefixAccPub: "thorpub",
+        bech32PrefixConsAddr: "thorvalcons",
+        bech32PrefixConsPub: "thorvalconspub",
+        bech32PrefixValAddr: "thorvaloper",
+        bech32PrefixValPub: "thorvaloperpub",
+      },
+      bip44: { coinType: 931 },
+      chainId: "thorchain-1",
+      chainName: "THORChain",
+      chainSymbolImageUrl:
+        "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/thorchain/chain.png",
+      currencies: [
+        {
+          coinDecimals: 8,
+          coinDenom: "RUNE",
+          coinGeckoId: "thorchain",
+          coinImageUrl:
+            "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/thorchain/rune.png",
+          coinMinimalDenom: "rune",
+        },
+      ],
+      features: [],
+      feeCurrencies: [
+        {
+          coinDecimals: 8,
+          coinDenom: "RUNE",
+          coinGeckoId: "thorchain",
+          coinImageUrl:
+            "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/thorchain/rune.png",
+          coinMinimalDenom: "rune",
+          gasPriceStep: { average: 0.02, high: 0.03, low: 0.02 },
+        },
+      ],
+      rest: "https://lcd-thorchain.keplr.app",
+      rpc: "https://rpc-thorchain.keplr.app",
+    },
+  ],
+]);

package/src/keplr/index.ts

@@ -0,0 +1,54 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { Chain, ChainId, ChainToChainId, filterSupportedChains, USwapError, WalletOption } from "@tcswap/helpers";
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+import { chainRegistry } from "./chainRegistry";
+
+const keplrSupportedChainIds = [ChainId.Cosmos, ChainId.Kujira, ChainId.Noble, ChainId.THORChain] as const;
+
+export const keplrWallet = createWallet({
+  connect: ({ addChain, supportedChains }) =>
+    async function connectKeplr(
+      chains: Chain[],
+      walletType: WalletOption.KEPLR | WalletOption.LEAP = WalletOption.KEPLR,
+    ) {
+      const extensionKey = walletType === WalletOption.LEAP ? "leap" : "keplr";
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+      const keplrClient = window[extensionKey];
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const chainId = ChainToChainId[chain] as (typeof keplrSupportedChainIds)[number];
+
+          if (!keplrSupportedChainIds.includes(chainId)) {
+            const chainConfig = chainRegistry.get(chainId);
+            if (!chainConfig) throw new USwapError("wallet_keplr_chain_not_supported", { chain });
+
+            await keplrClient.experimentalSuggestChain(chainConfig);
+          }
+
+          keplrClient?.enable(chainId);
+          const signer = keplrClient?.getOfflineSignerOnlyAmino(chainId);
+          if (!signer) throw new USwapError("wallet_keplr_signer_not_found");
+
+          const { getCosmosToolbox } = await import("@tcswap/toolboxes/cosmos");
+
+          const accounts = await signer.getAccounts();
+          if (!accounts?.[0]?.address) throw new USwapError("wallet_keplr_no_accounts");
+
+          const [{ address }] = accounts;
+          const toolbox = await getCosmosToolbox(chain, { signer });
+
+          addChain({ ...toolbox, address, chain, walletType });
+        }),
+      );
+
+      return true;
+    },
+  name: "connectKeplr",
+  supportedChains: [Chain.Cosmos, Chain.Kujira, Chain.Noble, Chain.THORChain],
+});
+
+export const KEPLR_SUPPORTED_CHAINS = getWalletSupportedChains(keplrWallet);

package/src/okx/helpers.ts

@@ -0,0 +1,192 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  Chain,
+  type EVMChain,
+  type GenericTransferParams,
+  getChainConfig,
+  getRPCUrl,
+  prepareNetworkSwitch,
+  switchEVMWalletNetwork,
+  USwapError,
+} from "@tcswap/helpers";
+import type { TronSigner, TronTransaction } from "@tcswap/toolboxes/tron";
+import { Psbt } from "bitcoinjs-lib";
+import type { Eip1193Provider } from "ethers";
+
+const cosmosTransfer =
+  (sender: string) =>
+  async ({ recipient, assetValue, memo }: GenericTransferParams) => {
+    if (!(window.okxwallet && "keplr" in window.okxwallet)) {
+      throw new USwapError("wallet_okx_not_found", { chain: Chain.Cosmos });
+    }
+    const { createSigningStargateClient } = await import("@tcswap/toolboxes/cosmos");
+
+    const { keplr: wallet } = window.okxwallet;
+    const offlineSigner = wallet?.getOfflineSignerOnlyAmino(getChainConfig(Chain.Cosmos).chainId);
+
+    const rpcUrl = await getRPCUrl(Chain.Cosmos);
+    const cosmJS = await createSigningStargateClient(rpcUrl, offlineSigner);
+
+    const denom = assetValue?.symbol === "MUON" ? "umuon" : "uatom";
+    const coins = [{ amount: assetValue.getBaseValue("string"), denom }];
+
+    const { transactionHash } = await cosmJS.sendTokens(sender, recipient, coins, 1.6, memo);
+    return transactionHash;
+  };
+
+async function getWeb3WalletMethods({
+  walletProvider,
+  chain,
+}: {
+  walletProvider: Eip1193Provider | undefined;
+  chain: EVMChain;
+}) {
+  const { getEvmToolbox } = await import("@tcswap/toolboxes/evm");
+  const { BrowserProvider } = await import("ethers");
+  if (!walletProvider) throw new USwapError("wallet_okx_not_found");
+
+  const provider = new BrowserProvider(walletProvider, "any");
+  const signer = await provider.getSigner();
+  const toolbox = await getEvmToolbox(chain, { provider, signer });
+
+  try {
+    if (chain !== Chain.Ethereum && "getNetworkParams" in toolbox) {
+      await switchEVMWalletNetwork(provider, chain, toolbox.getNetworkParams());
+    }
+  } catch {
+    throw new USwapError("wallet_okx_failed_to_switch_network", { chain });
+  }
+
+  return prepareNetworkSwitch({ chain, provider, toolbox });
+}
+
+export async function getWalletMethods(chain: Chain) {
+  const { match, P } = await import("ts-pattern");
+
+  return (
+    match(chain)
+      .with(
+        P.union(
+          Chain.Arbitrum,
+          Chain.Aurora,
+          Chain.Avalanche,
+          Chain.Base,
+          Chain.Berachain,
+          Chain.BinanceSmartChain,
+          Chain.Ethereum,
+          Chain.Gnosis,
+          Chain.Monad,
+          Chain.Optimism,
+          Chain.Polygon,
+          Chain.XLayer,
+        ),
+        async () => {
+          if (!(window.okxwallet && "send" in window.okxwallet)) {
+            throw new USwapError("wallet_okx_not_found", { chain });
+          }
+
+          const evmWallet = await getWeb3WalletMethods({ chain: chain as EVMChain, walletProvider: window.okxwallet });
+          const address: string = (await window.okxwallet.send("eth_requestAccounts", [])).result[0];
+
+          return { ...evmWallet, address };
+        },
+      )
+      .with(Chain.Bitcoin, async () => {
+        if (!(window.okxwallet && "bitcoin" in window.okxwallet)) {
+          throw new USwapError("wallet_okx_not_found", { chain: Chain.Bitcoin });
+        }
+
+        const { getUtxoToolbox } = await import("@tcswap/toolboxes/utxo");
+
+        const { bitcoin: wallet } = window.okxwallet;
+        const address = (await wallet.connect()).address;
+
+        const signer = {
+          getAddress: async () => Promise.resolve(address),
+          signTransaction: async (psbt: InstanceType<typeof Psbt>) => {
+            const signedPsbt = await wallet.signPsbt(psbt.toHex(), { from: address, type: "list" });
+
+            return Psbt.fromHex(signedPsbt);
+          },
+        };
+
+        const toolbox = await getUtxoToolbox(Chain.Bitcoin, { signer });
+
+        return { ...toolbox, address };
+      })
+      .with(Chain.Cosmos, async () => {
+        if (!(window.okxwallet && "keplr" in window.okxwallet)) {
+          throw new USwapError("wallet_okx_not_found", { chain: Chain.Cosmos });
+        }
+        const { keplr: wallet } = window.okxwallet;
+
+        await wallet.enable(getChainConfig(chain).chainId);
+        const offlineSigner = wallet.getOfflineSignerOnlyAmino(getChainConfig(chain).chainId);
+        const accounts = await offlineSigner.getAccounts();
+
+        // Add defensive check for accounts array
+        if (!(accounts && Array.isArray(accounts)) || accounts.length === 0) {
+          throw new USwapError("wallet_okx_no_accounts", {
+            chain: Chain.Cosmos,
+            message: "No Cosmos accounts returned from OKX Wallet",
+          });
+        }
+
+        const { getCosmosToolbox } = await import("@tcswap/toolboxes/cosmos");
+        const [{ address }] = accounts;
+        const toolbox = await getCosmosToolbox(Chain.Cosmos);
+
+        return { ...toolbox, address, transfer: cosmosTransfer(address) };
+      })
+      // INFO: OK wallet near is broken
+      // .with(Chain.Near, async () => {
+      //   if (!(window.okxwallet && "near" in window.okxwallet)) {
+      //     throw new USwapError("wallet_okx_not_found", { chain: Chain.Near });
+      //   }
+
+      //   const { createNearSignerFromProvider } = await import("../helpers/near");
+      //   const { getNearToolbox } = await import("@tcswap/toolboxes/near");
+
+      //   const provider = window.okxwallet.near;
+      //   const signer = await createNearSignerFromProvider(provider, "OKX");
+      //   const accountId = await signer.getAddress();
+      //   const toolbox = await getNearToolbox({ signer });
+
+      //   return { ...toolbox, address: accountId } as NearToolbox & { address: string };
+      // })
+      .with(Chain.Tron, async () => {
+        if (!(window.okxwallet && "tronLink" in window.okxwallet)) {
+          throw new USwapError("wallet_okx_not_found", { chain: Chain.Tron });
+        }
+
+        const { createTronToolbox } = await import("@tcswap/toolboxes/tron");
+
+        const tronLink = window.okxwallet.tronLink;
+
+        // Request account access
+        const accounts = await tronLink.request({ method: "tron_requestAccounts" });
+        if (!accounts || accounts.length === 0) {
+          throw new USwapError("wallet_okx_no_accounts", { chain: Chain.Tron });
+        }
+
+        const address = tronLink.tronWeb.defaultAddress.base58;
+
+        const signer: TronSigner = {
+          getAddress: async () => address,
+          signTransaction: async (transaction: TronTransaction) => {
+            return await tronLink.tronWeb.trx.sign(transaction);
+          },
+        };
+
+        const toolbox = await createTronToolbox({ signer });
+
+        return { ...toolbox, address };
+      })
+      .otherwise(() => {
+        throw new USwapError("wallet_okx_chain_not_supported", { chain });
+      })
+  );
+}

package/src/okx/index.ts

@@ -0,0 +1,43 @@
+import { Chain, filterSupportedChains, WalletOption } from "@tcswap/helpers";
+
+import { createWallet, getWalletSupportedChains } from "@tcswap/wallet-core";
+import { getWalletMethods } from "./helpers";
+
+export const okxWallet = createWallet({
+  connect: ({ addChain, supportedChains, walletType }) =>
+    async function connectOkx(chains: Chain[]) {
+      const filteredChains = filterSupportedChains({ chains, supportedChains, walletType });
+
+      await Promise.all(
+        filteredChains.map(async (chain) => {
+          const walletMethods = await getWalletMethods(chain);
+          addChain({ ...walletMethods, chain, walletType });
+        }),
+      );
+
+      return true;
+    },
+  name: "connectOkx",
+  supportedChains: [
+    Chain.Arbitrum,
+    Chain.Aurora,
+    Chain.Avalanche,
+    Chain.Base,
+    Chain.Berachain,
+    Chain.BinanceSmartChain,
+    Chain.Bitcoin,
+    Chain.Cosmos,
+    Chain.Ethereum,
+    Chain.Gnosis,
+    Chain.Monad,
+    // NEAR transfer is not yet supported in OKX Wallet
+    // Chain.Near,
+    Chain.Optimism,
+    Chain.Polygon,
+    Chain.XLayer,
+    Chain.Tron,
+  ],
+  walletType: WalletOption.OKX,
+});
+
+export const OKX_SUPPORTED_CHAINS = getWalletSupportedChains(okxWallet);

package/src/okx/types.ts

@@ -0,0 +1,117 @@
+import type { StdSignDoc } from "@cosmjs/amino";
+
+export enum BroadcastMode {
+  /** Return after tx commit */
+  Block = "block",
+  /** Return after CheckTx */
+  Sync = "sync",
+  /** Return right away */
+  Async = "async",
+}
+
+export interface Coin {
+  readonly denom: string;
+  readonly amount: string;
+}
+
+export interface StdFee {
+  readonly amount: readonly Coin[];
+  readonly gas: string;
+  readonly payer?: string;
+  readonly granter?: string;
+  readonly feePayer?: string;
+}
+
+export interface Msg {
+  readonly type: string;
+  readonly value: any;
+}
+
+export interface PubKey {
+  readonly type: string;
+  readonly value: string;
+}
+
+export interface StdSignature {
+  readonly pub_key: PubKey;
+  readonly signature: string;
+}
+
+export interface StdTx {
+  readonly msg: readonly Msg[];
+  readonly fee: StdFee;
+  readonly signatures: readonly StdSignature[];
+  readonly memo: string | undefined;
+}
+
+export interface AminoSignResponse {
+  readonly signed: StdSignDoc;
+  readonly signature: StdSignature;
+}
+
+export interface SignDoc {
+  /**
+   * body_bytes is protobuf serialization of a TxBody that matches the
+   * representation in TxRaw.
+   */
+  bodyBytes: Uint8Array;
+  /**
+   * auth_info_bytes is a protobuf serialization of an AuthInfo that matches the
+   * representation in TxRaw.
+   */
+  authInfoBytes: Uint8Array;
+  /**
+   * chain_id is the unique identifier of the chain this transaction targets.
+   * It prevents signed transactions from being used on another chain by an
+   * attacker
+   */
+  chainId: string;
+  /** account_number is the account number of the account in state */
+  accountNumber: any;
+}
+
+/**
+ * This is the same as Algo from @cosmjs/launchpad but those might diverge in the future.
+ */
+export type Algo = "secp256k1" | "ed25519" | "sr25519";
+
+/**
+ * This is the same as AccountData from @cosmjs/launchpad but those might diverge in the future.
+ */
+export interface AccountData {
+  /** A printable address (typically bech32 encoded) */
+  readonly address: string;
+  readonly algo: Algo;
+  readonly pubkey: Uint8Array;
+}
+
+export interface DirectSignResponse {
+  /**
+   * The sign doc that was signed.
+   * This may be different from the input signDoc when the signer modifies it as part of the signing process.
+   */
+  readonly signed: SignDoc;
+  readonly signature: StdSignature;
+}
+
+export interface OfflineDirectSigner {
+  readonly getAccounts: () => Promise<readonly AccountData[]>;
+  readonly signDirect: (signerAddress: string, signDoc: SignDoc) => Promise<DirectSignResponse>;
+}
+
+export interface OfflineAminoSigner {
+  /**
+   * Get AccountData array from wallet. Rejects if not enabled.
+   */
+  readonly getAccounts: () => Promise<readonly AccountData[]>;
+  /**
+   * Request signature from whichever key corresponds to provided bech32-encoded address. Rejects if not enabled.
+   *
+   * The signer implementation may offer the user the ability to override parts of the signDoc. It must
+   * return the doc that was signed in the response.
+   *
+   * @param signerAddress The address of the account that should sign the transaction
+   * @param signDoc The content that should be signed
+   */
+  readonly signAmino: (signerAddress: string, signDoc: StdSignDoc) => Promise<AminoSignResponse>;
+}