winnode 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WinNode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# WinNode SDK
+
+[![npm version](https://img.shields.io/npm/v/winnode.svg)](https://www.npmjs.com/package/winnode)
+[![CI](https://github.com/winnode/sdk-cosmos/actions/workflows/ci.yml/badge.svg)](https://github.com/winnode/sdk-cosmos/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Transaction toolkits for Cosmos SDK and EVM chains — send, delegate, vote,
+and more, with a small dependency-free `isEvmChain` helper to pick the right
+toolkit for a given chain.
+
+## Features
+
+- **Cosmos SDK** (`cosmosTx`) — `send`, `delegate`, `undelegate`,
+  `redelegate`, `vote`, `unjail`, `withdrawRewards`. Signs via any
+  `OfflineSigner`-compatible wallet (Keplr, Leap, etc).
+- **EVM chains** (`evmTx`) — `sendNative`, `sendToken`, `writeContract`.
+  Signs via the injected browser wallet (MetaMask).
+- **Chain-type detection** — `isEvmChain(chain)` picks which toolkit
+  applies based on `coin_type` / `evm_rpc`.
+- Ships as CJS, ESM, and TypeScript types.
+
+## Installation
+
+```bash
+npm install winnode
+```
+
+Requires Node.js 18+ and (for EVM signing) a browser environment with
+MetaMask injected as `window.ethereum`.
+
+## Usage
+
+```typescript
+import { isEvmChain, cosmosTx, evmTx } from 'winnode';
+import type { ChainData } from 'winnode';
+
+declare const chain: ChainData;
+
+if (isEvmChain(chain)) {
+  // EVM chain
+  const signer = await evmTx.getBrowserSigner(chain);
+  const result = await evmTx.sendNative(signer, {
+    toAddress: '0x...',
+    amount: '1.5',
+  });
+} else {
+  // Cosmos SDK chain
+  const result = await cosmosTx.send(chain, offlineSigner, {
+    fromAddress: 'cosmos1...',
+    toAddress: 'cosmos1...',
+    amount: '1000000',
+  });
+}
+```
+
+### `ChainData`
+
+Both toolkits take a `ChainData` describing the chain (see
+[`types/chain.ts`](types/chain.ts)): `chain_name`, `chain_id`, `coin_type`,
+`assets`, `rpc`, `evm_rpc`, `evm_chain_id`, and `fees.fee_tokens` (used for
+Cosmos fee calculation).
+
+### Cosmos SDK API (`cosmosTx`)
+
+| Function | Description |
+| --- | --- |
+| `send(chain, signer, params, opts?)` | `MsgSend` |
+| `delegate(chain, signer, params, opts?)` | `MsgDelegate` |
+| `undelegate(chain, signer, params, opts?)` | `MsgUndelegate` |
+| `redelegate(chain, signer, params, opts?)` | `MsgBeginRedelegate` |
+| `vote(chain, signer, params, opts?)` | `MsgVote` |
+| `unjail(chain, signer, params, opts?)` | `MsgUnjail` |
+| `withdrawRewards(chain, signer, params, opts?)` | `MsgWithdrawDelegatorReward` |
+| `getSigningStargateClient(chain, signer)` | Cached `SigningStargateClient` |
+
+Every function returns a `Promise<TxResult>`:
+`{ success: boolean; txHash?: string; error?: string; raw?: any }`.
+
+### EVM API (`evmTx`)
+
+| Function | Description |
+| --- | --- |
+| `sendNative(signer, params, opts?)` | Send the chain's native coin |
+| `sendToken(signer, params, opts?)` | ERC-20 `transfer` |
+| `writeContract(signer, address, abi, method, args?, opts?)` | Generic contract write (e.g. staking/gov precompiles) |
+| `getReadProvider(chain)` | Read-only `JsonRpcProvider` |
+| `getBrowserSigner(chain)` | MetaMask-backed `JsonRpcSigner`, switching chains as needed |
+
+## Development
+
+```bash
+npm install         # install dependencies
+npm run build        # build dist/ (CJS + ESM + types via tsup)
+npm run typecheck    # tsc --noEmit
+npm run lint         # eslint .
+npm test             # vitest run
+```
+
+## Releasing
+
+Versions are bumped with `npm version`, which updates `package.json`,
+commits the change, and creates a matching git tag:
+
+```bash
+npm version patch   # bug fixes: 1.0.0 -> 1.0.1
+npm version minor   # new features: 1.0.0 -> 1.1.0
+npm version major   # breaking changes: 1.0.0 -> 2.0.0
+```
+
+Before bumping, add an entry to [CHANGELOG.md](CHANGELOG.md) describing what
+changed. Push the resulting commit and tag to `main`
+(`git push && git push --tags`); the `Publish to npm` workflow lints,
+typechecks, tests, builds, and publishes the package automatically.
+
+## Staying up to date
+
+[Dependabot](.github/dependabot.yml) opens weekly PRs to keep dependencies
+(`@cosmjs/*`, `ethers`, etc.) and GitHub Actions on their latest versions.
+Every dependency PR runs through the same [CI checks](.github/workflows/ci.yml)
+as any other change before it can be merged.
+
+## Security
+
+See [SECURITY.md](SECURITY.md) for supported versions and how to report a
+vulnerability.
+
+## License
+
+[MIT](LICENSE)

package/dist/chunk-J5LGTIGS.mjs

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/chunk-J5LGTIGS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.mts

@@ -0,0 +1,206 @@
+import { OfflineSigner, Registry } from '@cosmjs/proto-signing';
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { JsonRpcSigner, JsonRpcProvider } from 'ethers';
+
+interface RpcEndpoint {
+    address: string;
+    provider?: string;
+    tx_index?: string;
+}
+interface ChainAsset {
+    base: string;
+    display?: string;
+    symbol?: string;
+    denom_units?: Array<{
+        denom: string;
+        exponent: number;
+    }>;
+}
+interface FeeToken {
+    denom: string;
+    fixed_min_gas_price?: number;
+    low_gas_price?: number;
+    average_gas_price?: number;
+    high_gas_price?: number;
+}
+interface ChainFees {
+    fee_tokens?: FeeToken[];
+}
+interface ChainData {
+    chain_name: string;
+    chain_id?: string;
+    coin_type?: string;
+    assets?: ChainAsset[];
+    rpc?: RpcEndpoint[];
+    evm_rpc?: RpcEndpoint[];
+    evm_chain_id?: number;
+    fees?: ChainFees;
+}
+
+interface TxResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+    raw?: any;
+}
+interface TxOptions {
+    memo?: string;
+    gasLimit?: string;
+}
+/**
+ * A chain is treated as EVM when it declares evm_rpc endpoints or its
+ * coin_type is 60 (Ethereum's SLIP-44 index) — same heuristic used across
+ * the rest of the app (see lib/keplr.ts isEvmChain checks).
+ */
+declare function isEvmChain(chain: ChainData): boolean;
+
+interface SendParams {
+    fromAddress: string;
+    toAddress: string;
+    amount: string;
+    denom?: string;
+}
+interface DelegateParams {
+    delegatorAddress: string;
+    validatorAddress: string;
+    amount: string;
+    denom?: string;
+}
+interface UndelegateParams extends DelegateParams {
+}
+interface RedelegateParams {
+    delegatorAddress: string;
+    validatorSrcAddress: string;
+    validatorDstAddress: string;
+    amount: string;
+    denom?: string;
+}
+/** 1 = Yes, 2 = Abstain, 3 = No, 4 = NoWithVeto */
+type VoteOption = 1 | 2 | 3 | 4;
+interface VoteParams {
+    voterAddress: string;
+    proposalId: string;
+    option: VoteOption;
+}
+interface UnjailParams {
+    senderAddress: string;
+    validatorAddress: string;
+}
+interface WithdrawRewardsParams {
+    delegatorAddress: string;
+    validatorAddress: string;
+}
+declare function send(chain: ChainData, signer: OfflineSigner, params: SendParams, opts?: TxOptions): Promise<TxResult>;
+declare function delegate(chain: ChainData, signer: OfflineSigner, params: DelegateParams, opts?: TxOptions): Promise<TxResult>;
+declare function undelegate(chain: ChainData, signer: OfflineSigner, params: UndelegateParams, opts?: TxOptions): Promise<TxResult>;
+declare function redelegate(chain: ChainData, signer: OfflineSigner, params: RedelegateParams, opts?: TxOptions): Promise<TxResult>;
+declare function vote(chain: ChainData, signer: OfflineSigner, params: VoteParams, opts?: TxOptions): Promise<TxResult>;
+declare function unjail(chain: ChainData, signer: OfflineSigner, params: UnjailParams, opts?: TxOptions): Promise<TxResult>;
+declare function withdrawRewards(chain: ChainData, signer: OfflineSigner, params: WithdrawRewardsParams, opts?: TxOptions): Promise<TxResult>;
+
+/**
+ * Connects a SigningStargateClient for the given chain using any
+ * OfflineSigner-compatible wallet (Keplr's getOfflineSignerAuto/getOfflineSigner,
+ * Leap, etc). Clients are cached per rpc+address so repeated calls in the
+ * same session reuse the open connection.
+ */
+declare function getSigningStargateClient(chain: ChainData, signer: OfflineSigner): Promise<SigningStargateClient>;
+declare function clearCosmosClientCache(): void;
+
+/**
+ * @cosmjs/stargate's defaultRegistryTypes already covers MsgSend, MsgDelegate,
+ * MsgUndelegate, MsgBeginRedelegate, MsgVote and MsgWithdrawDelegatorReward.
+ * MsgUnjail is the only staking-adjacent message missing from it.
+ */
+declare function createCosmosRegistry(): Registry;
+
+declare function getPrimaryDenom(chain: ChainData): string;
+/**
+ * Delegates to the app's existing, battle-tested fee calculation
+ * (gas_price / fee_tokens / exponent-based fallbacks, PaxiHub minimums, etc.)
+ * so every SDK tx uses the same fee logic as the rest of the explorer.
+ */
+declare function buildFee(chain: ChainData, gasLimit: string): Promise<{
+    amount: Array<{
+        denom: string;
+        amount: string;
+    }>;
+    gas: string;
+}>;
+/**
+ * Picks the RPC endpoint with tx_index enabled when available, otherwise
+ * falls back to the first configured endpoint.
+ */
+declare function pickRpcEndpoint(chain: ChainData): string;
+
+type index$1_DelegateParams = DelegateParams;
+type index$1_RedelegateParams = RedelegateParams;
+type index$1_SendParams = SendParams;
+type index$1_UndelegateParams = UndelegateParams;
+type index$1_UnjailParams = UnjailParams;
+type index$1_VoteOption = VoteOption;
+type index$1_VoteParams = VoteParams;
+type index$1_WithdrawRewardsParams = WithdrawRewardsParams;
+declare const index$1_buildFee: typeof buildFee;
+declare const index$1_clearCosmosClientCache: typeof clearCosmosClientCache;
+declare const index$1_createCosmosRegistry: typeof createCosmosRegistry;
+declare const index$1_delegate: typeof delegate;
+declare const index$1_getPrimaryDenom: typeof getPrimaryDenom;
+declare const index$1_getSigningStargateClient: typeof getSigningStargateClient;
+declare const index$1_pickRpcEndpoint: typeof pickRpcEndpoint;
+declare const index$1_redelegate: typeof redelegate;
+declare const index$1_send: typeof send;
+declare const index$1_undelegate: typeof undelegate;
+declare const index$1_unjail: typeof unjail;
+declare const index$1_vote: typeof vote;
+declare const index$1_withdrawRewards: typeof withdrawRewards;
+declare namespace index$1 {
+  export { type index$1_DelegateParams as DelegateParams, type index$1_RedelegateParams as RedelegateParams, type index$1_SendParams as SendParams, type index$1_UndelegateParams as UndelegateParams, type index$1_UnjailParams as UnjailParams, type index$1_VoteOption as VoteOption, type index$1_VoteParams as VoteParams, type index$1_WithdrawRewardsParams as WithdrawRewardsParams, index$1_buildFee as buildFee, index$1_clearCosmosClientCache as clearCosmosClientCache, index$1_createCosmosRegistry as createCosmosRegistry, index$1_delegate as delegate, index$1_getPrimaryDenom as getPrimaryDenom, index$1_getSigningStargateClient as getSigningStargateClient, index$1_pickRpcEndpoint as pickRpcEndpoint, index$1_redelegate as redelegate, index$1_send as send, index$1_undelegate as undelegate, index$1_unjail as unjail, index$1_vote as vote, index$1_withdrawRewards as withdrawRewards };
+}
+
+interface SendNativeParams {
+    toAddress: string;
+    amount: string;
+    decimals?: number;
+}
+interface SendTokenParams {
+    tokenAddress: string;
+    toAddress: string;
+    amount: string;
+    decimals?: number;
+}
+/** Sends the chain's native coin (e.g. MON on Monad). */
+declare function sendNative(signer: JsonRpcSigner, params: SendNativeParams, opts?: TxOptions): Promise<TxResult>;
+/** Sends an ERC-20 token via its standard `transfer` method. */
+declare function sendToken(signer: JsonRpcSigner, params: SendTokenParams, opts?: TxOptions): Promise<TxResult>;
+/**
+ * Generic contract write, for chains that expose staking/governance actions
+ * (delegate, undelegate, vote, unjail) through a contract or precompile
+ * rather than a native Cosmos message — e.g. Cosmos-EVM staking/gov
+ * precompiles. Pass the ABI fragment for the single method being called.
+ */
+declare function writeContract(signer: JsonRpcSigner, contractAddress: string, abiFragment: string[], method: string, args?: any[], opts?: TxOptions): Promise<TxResult>;
+
+/**
+ * Read-only provider for the chain's EVM RPC (falls back to the Tendermint
+ * rpc list for chains that only expose one endpoint set).
+ */
+declare function getReadProvider(chain: ChainData): JsonRpcProvider;
+/**
+ * Signer backed by the injected wallet (MetaMask). Ensures the wallet is
+ * switched to the requested chain before returning the signer.
+ */
+declare function getBrowserSigner(chain: ChainData): Promise<JsonRpcSigner>;
+
+type index_SendNativeParams = SendNativeParams;
+type index_SendTokenParams = SendTokenParams;
+declare const index_getBrowserSigner: typeof getBrowserSigner;
+declare const index_getReadProvider: typeof getReadProvider;
+declare const index_sendNative: typeof sendNative;
+declare const index_sendToken: typeof sendToken;
+declare const index_writeContract: typeof writeContract;
+declare namespace index {
+  export { type index_SendNativeParams as SendNativeParams, type index_SendTokenParams as SendTokenParams, index_getBrowserSigner as getBrowserSigner, index_getReadProvider as getReadProvider, index_sendNative as sendNative, index_sendToken as sendToken, index_writeContract as writeContract };
+}
+
+export { type TxOptions, type TxResult, index$1 as cosmosTx, index as evmTx, isEvmChain };

package/dist/index.d.ts

@@ -0,0 +1,206 @@
+import { OfflineSigner, Registry } from '@cosmjs/proto-signing';
+import { SigningStargateClient } from '@cosmjs/stargate';
+import { JsonRpcSigner, JsonRpcProvider } from 'ethers';
+
+interface RpcEndpoint {
+    address: string;
+    provider?: string;
+    tx_index?: string;
+}
+interface ChainAsset {
+    base: string;
+    display?: string;
+    symbol?: string;
+    denom_units?: Array<{
+        denom: string;
+        exponent: number;
+    }>;
+}
+interface FeeToken {
+    denom: string;
+    fixed_min_gas_price?: number;
+    low_gas_price?: number;
+    average_gas_price?: number;
+    high_gas_price?: number;
+}
+interface ChainFees {
+    fee_tokens?: FeeToken[];
+}
+interface ChainData {
+    chain_name: string;
+    chain_id?: string;
+    coin_type?: string;
+    assets?: ChainAsset[];
+    rpc?: RpcEndpoint[];
+    evm_rpc?: RpcEndpoint[];
+    evm_chain_id?: number;
+    fees?: ChainFees;
+}
+
+interface TxResult {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+    raw?: any;
+}
+interface TxOptions {
+    memo?: string;
+    gasLimit?: string;
+}
+/**
+ * A chain is treated as EVM when it declares evm_rpc endpoints or its
+ * coin_type is 60 (Ethereum's SLIP-44 index) — same heuristic used across
+ * the rest of the app (see lib/keplr.ts isEvmChain checks).
+ */
+declare function isEvmChain(chain: ChainData): boolean;
+
+interface SendParams {
+    fromAddress: string;
+    toAddress: string;
+    amount: string;
+    denom?: string;
+}
+interface DelegateParams {
+    delegatorAddress: string;
+    validatorAddress: string;
+    amount: string;
+    denom?: string;
+}
+interface UndelegateParams extends DelegateParams {
+}
+interface RedelegateParams {
+    delegatorAddress: string;
+    validatorSrcAddress: string;
+    validatorDstAddress: string;
+    amount: string;
+    denom?: string;
+}
+/** 1 = Yes, 2 = Abstain, 3 = No, 4 = NoWithVeto */
+type VoteOption = 1 | 2 | 3 | 4;
+interface VoteParams {
+    voterAddress: string;
+    proposalId: string;
+    option: VoteOption;
+}
+interface UnjailParams {
+    senderAddress: string;
+    validatorAddress: string;
+}
+interface WithdrawRewardsParams {
+    delegatorAddress: string;
+    validatorAddress: string;
+}
+declare function send(chain: ChainData, signer: OfflineSigner, params: SendParams, opts?: TxOptions): Promise<TxResult>;
+declare function delegate(chain: ChainData, signer: OfflineSigner, params: DelegateParams, opts?: TxOptions): Promise<TxResult>;
+declare function undelegate(chain: ChainData, signer: OfflineSigner, params: UndelegateParams, opts?: TxOptions): Promise<TxResult>;
+declare function redelegate(chain: ChainData, signer: OfflineSigner, params: RedelegateParams, opts?: TxOptions): Promise<TxResult>;
+declare function vote(chain: ChainData, signer: OfflineSigner, params: VoteParams, opts?: TxOptions): Promise<TxResult>;
+declare function unjail(chain: ChainData, signer: OfflineSigner, params: UnjailParams, opts?: TxOptions): Promise<TxResult>;
+declare function withdrawRewards(chain: ChainData, signer: OfflineSigner, params: WithdrawRewardsParams, opts?: TxOptions): Promise<TxResult>;
+
+/**
+ * Connects a SigningStargateClient for the given chain using any
+ * OfflineSigner-compatible wallet (Keplr's getOfflineSignerAuto/getOfflineSigner,
+ * Leap, etc). Clients are cached per rpc+address so repeated calls in the
+ * same session reuse the open connection.
+ */
+declare function getSigningStargateClient(chain: ChainData, signer: OfflineSigner): Promise<SigningStargateClient>;
+declare function clearCosmosClientCache(): void;
+
+/**
+ * @cosmjs/stargate's defaultRegistryTypes already covers MsgSend, MsgDelegate,
+ * MsgUndelegate, MsgBeginRedelegate, MsgVote and MsgWithdrawDelegatorReward.
+ * MsgUnjail is the only staking-adjacent message missing from it.
+ */
+declare function createCosmosRegistry(): Registry;
+
+declare function getPrimaryDenom(chain: ChainData): string;
+/**
+ * Delegates to the app's existing, battle-tested fee calculation
+ * (gas_price / fee_tokens / exponent-based fallbacks, PaxiHub minimums, etc.)
+ * so every SDK tx uses the same fee logic as the rest of the explorer.
+ */
+declare function buildFee(chain: ChainData, gasLimit: string): Promise<{
+    amount: Array<{
+        denom: string;
+        amount: string;
+    }>;
+    gas: string;
+}>;
+/**
+ * Picks the RPC endpoint with tx_index enabled when available, otherwise
+ * falls back to the first configured endpoint.
+ */
+declare function pickRpcEndpoint(chain: ChainData): string;
+
+type index$1_DelegateParams = DelegateParams;
+type index$1_RedelegateParams = RedelegateParams;
+type index$1_SendParams = SendParams;
+type index$1_UndelegateParams = UndelegateParams;
+type index$1_UnjailParams = UnjailParams;
+type index$1_VoteOption = VoteOption;
+type index$1_VoteParams = VoteParams;
+type index$1_WithdrawRewardsParams = WithdrawRewardsParams;
+declare const index$1_buildFee: typeof buildFee;
+declare const index$1_clearCosmosClientCache: typeof clearCosmosClientCache;
+declare const index$1_createCosmosRegistry: typeof createCosmosRegistry;
+declare const index$1_delegate: typeof delegate;
+declare const index$1_getPrimaryDenom: typeof getPrimaryDenom;
+declare const index$1_getSigningStargateClient: typeof getSigningStargateClient;
+declare const index$1_pickRpcEndpoint: typeof pickRpcEndpoint;
+declare const index$1_redelegate: typeof redelegate;
+declare const index$1_send: typeof send;
+declare const index$1_undelegate: typeof undelegate;
+declare const index$1_unjail: typeof unjail;
+declare const index$1_vote: typeof vote;
+declare const index$1_withdrawRewards: typeof withdrawRewards;
+declare namespace index$1 {
+  export { type index$1_DelegateParams as DelegateParams, type index$1_RedelegateParams as RedelegateParams, type index$1_SendParams as SendParams, type index$1_UndelegateParams as UndelegateParams, type index$1_UnjailParams as UnjailParams, type index$1_VoteOption as VoteOption, type index$1_VoteParams as VoteParams, type index$1_WithdrawRewardsParams as WithdrawRewardsParams, index$1_buildFee as buildFee, index$1_clearCosmosClientCache as clearCosmosClientCache, index$1_createCosmosRegistry as createCosmosRegistry, index$1_delegate as delegate, index$1_getPrimaryDenom as getPrimaryDenom, index$1_getSigningStargateClient as getSigningStargateClient, index$1_pickRpcEndpoint as pickRpcEndpoint, index$1_redelegate as redelegate, index$1_send as send, index$1_undelegate as undelegate, index$1_unjail as unjail, index$1_vote as vote, index$1_withdrawRewards as withdrawRewards };
+}
+
+interface SendNativeParams {
+    toAddress: string;
+    amount: string;
+    decimals?: number;
+}
+interface SendTokenParams {
+    tokenAddress: string;
+    toAddress: string;
+    amount: string;
+    decimals?: number;
+}
+/** Sends the chain's native coin (e.g. MON on Monad). */
+declare function sendNative(signer: JsonRpcSigner, params: SendNativeParams, opts?: TxOptions): Promise<TxResult>;
+/** Sends an ERC-20 token via its standard `transfer` method. */
+declare function sendToken(signer: JsonRpcSigner, params: SendTokenParams, opts?: TxOptions): Promise<TxResult>;
+/**
+ * Generic contract write, for chains that expose staking/governance actions
+ * (delegate, undelegate, vote, unjail) through a contract or precompile
+ * rather than a native Cosmos message — e.g. Cosmos-EVM staking/gov
+ * precompiles. Pass the ABI fragment for the single method being called.
+ */
+declare function writeContract(signer: JsonRpcSigner, contractAddress: string, abiFragment: string[], method: string, args?: any[], opts?: TxOptions): Promise<TxResult>;
+
+/**
+ * Read-only provider for the chain's EVM RPC (falls back to the Tendermint
+ * rpc list for chains that only expose one endpoint set).
+ */
+declare function getReadProvider(chain: ChainData): JsonRpcProvider;
+/**
+ * Signer backed by the injected wallet (MetaMask). Ensures the wallet is
+ * switched to the requested chain before returning the signer.
+ */
+declare function getBrowserSigner(chain: ChainData): Promise<JsonRpcSigner>;
+
+type index_SendNativeParams = SendNativeParams;
+type index_SendTokenParams = SendTokenParams;
+declare const index_getBrowserSigner: typeof getBrowserSigner;
+declare const index_getReadProvider: typeof getReadProvider;
+declare const index_sendNative: typeof sendNative;
+declare const index_sendToken: typeof sendToken;
+declare const index_writeContract: typeof writeContract;
+declare namespace index {
+  export { type index_SendNativeParams as SendNativeParams, type index_SendTokenParams as SendTokenParams, index_getBrowserSigner as getBrowserSigner, index_getReadProvider as getReadProvider, index_sendNative as sendNative, index_sendToken as sendToken, index_writeContract as writeContract };
+}
+
+export { type TxOptions, type TxResult, index$1 as cosmosTx, index as evmTx, isEvmChain };