> ## Documentation Index
> Fetch the complete documentation index at: https://docs.walletsuite.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Signing
> Sign transactions across 84 chains. EVM, Tron, and Solana calls return a broadcast-ready transaction; Bitcoin returns per-input signatures to assemble.
Every EVM, Tron, and Solana sign call returns a transaction that is ready to broadcast. Bitcoin is the exception: `signBitcoin` returns one signature per input, and you assemble the final transaction yourself. You hold the wallet, the WalletSuite signing service holds a co-signing share, and both come together to sign your transaction. There is no seed phrase and the full key is never assembled.
Sign transactions across 84 chains including Ethereum, Base, Bitcoin, Solana, Tron, and more. One wallet works everywhere. See [Supported chains](/supported-chains).
The SDK signs. It does not broadcast. Send the result through your own RPC, or `POST` it to `https://api.walletsuite.io/api/txs/send` (header `x-api-key`) and poll `GET /api/txs/status/{hash}`. See [Broadcasting](/mpc/broadcasting) for the full flow.
## Authorization is automatic
Every signature is pre-authorized by a single-use, payload-bound signing intent that the SDK mints for you. There is nothing to pass in: you call a `sign*` method with the transfer parameters and the SDK handles the authorization internally, one intent per signing round. See [Signing intents](/mpc/signing-intents) for how it works under the hood.
## EVM batched transactions (EIP-7702)
`signEvm7702` is the default EVM signing path. It signs the EIP-7702 (type-4) smart-account transaction format. The SDK handles the transaction construction for you and returns one broadcast-ready transaction.
EIP-7702 is supported on enabled EVM chains. Use the target network's `chainId`; contact WalletSuite if the chain you need is not yet enabled.
* `token`, `data`, `delegate`, and `path` are optional. Pass a `token` contract address to move an ERC-20, with `value` in token base units.
```js sign-7702.js theme={null}
const signed = await client.signEvm7702(
wallet,
8453, // chain id (Base)
0, // tx nonce
"0xRecipientAddress",
"100000000000000", // value, wei
"1000000000", // max priority fee per gas, wei
"2000000000", // max fee per gas, wei
300000, // gas limit
null, // token: ERC-20 address (null for native)
null, // data
null, // delegate
null // path
);
signed.raw; // broadcast-ready transaction
```
```python sign_7702.py theme={null}
signed = client.sign_evm_7702(
wallet,
8453, # chain id (Base)
0, # tx nonce
"0xRecipientAddress",
100_000_000_000_000, # value, wei
1_000_000_000, # max priority fee per gas, wei
2_000_000_000, # max fee per gas, wei
300_000, # gas limit
)
signed.raw # broadcast-ready transaction
```
The result includes the signed transaction (`raw`), ready to broadcast.
Amounts are exact integers. Node takes and returns each amount as a decimal string (wei, or token base units when `token` is set), and Python uses native `int`.
## EVM single transactions (EIP-1559)
Use `signEvm1559` for a plain single transfer. It returns the raw signed transaction string, ready to broadcast. Prefer `signEvm7702` for EVM signing, and reach for `signEvm1559` when you specifically want a plain, non-batched transaction.
See [`signEvm1559`](/mpc/sdk-reference#signevm1559) for the full signature and a runnable example.
## Tron
Use `signTron` to sign transactions on Tron. Amounts are in sun (1 TRX is 1,000,000 sun). The reference block fields and timestamps come from a recent Tron block, which you read from a Tron RPC or TronGrid `getNowBlock` call. `signedTxHex` is the assembled transaction; post it straight to the send endpoint as `signedTx` with `chain` set to `tron`.
See [`signTron`](/mpc/sdk-reference#signtron) for the full signature and a runnable example.
## Bitcoin
Use `signBitcoin` to sign transactions on Bitcoin. It returns one signature per input, in input order. Build `unsignedTxHex` and the matching `prevouts` from your own UTXO source, then reassemble the returned per-input signatures into the final witness transaction (for example with bitcoinjs-lib) before broadcasting.
See [`signBitcoin`](/mpc/sdk-reference#signbitcoin) for the full signature and a runnable example.
## Solana
Use `signSolana` to sign transactions on Solana. It returns the signature and the signed, broadcast-ready transaction. `messageB64` is the compiled message, base64-encoded, which you produce with @solana/web3.js.
See [`signSolana`](/mpc/sdk-reference#signsolana) for the full signature and a runnable example.
One wallet covers every chain. See [One wallet, every chain](/mpc/curves) for how a single wallet works everywhere, and [Supported chains](/supported-chains) for the full list.
## Async surface
Node methods are async and return Promises. Python gives you both an async client and a blocking one, so you can pick what fits your stack.
| Context | Client | Methods |
| -------------- | ---------------- | ---------------- |
| Node | `MpcClient` | async (Promises) |
| Python asyncio | `AsyncMpcClient` | awaitable |
| Python sync | `MpcClient` | blocking |
`deriveAddress` / `derive_address` is always synchronous in every client. It never hits the network.
## Errors
Signing fails fast with a typed error you can branch on. Node throws a generic `Error` with the category in the message. Python raises `ValueError` for input you can fix and `RuntimeError` for failures you retry. See [Error handling](/mpc/errors) for the full list and how to respond to each one.
## Next steps
How every signature is pre-authorized under the hood.
Send the signed transaction through your own RPC or the WalletSuite send endpoint, then check status.
Every client, method, and return shape across Node and Python.
The complete journey from wallet creation to a confirmed transaction.